aleidk/master-wiki
1
0
Fork 0
Code Issues 11 Pull requests Projects Releases Packages Wiki Activity Actions

Merge remote-tracking branch 'origin/main'

Browse source
This commit is contained in:
Alexander Navarro 2024-02-20 12:24:43 -03:00
commit ddce2bf5b0
44 changed files with 83749 additions and 272 deletions
Download patch file Download diff file Expand all files Collapse all files

2
.gitignore vendored
View file

@ -3,5 +3,3 @@
.env
.obsidian/workspace.json
.trash
!**/.gitkeep

5
.obsidian/app.json vendored
View file

@ -8,8 +8,5 @@
"useMarkdownLinks": true,
"showUnsupportedFiles": true,
"attachmentFolderPath": "./",
"newFileFolderPath": "notes",
"showInlineTitle": false,
"strictLineBreaks": true,
"propertiesInDocument": "hidden"
"newFileFolderPath": "notes"
}

3
.obsidian/appearance.json vendored
View file

@ -2,6 +2,5 @@
"accentColor": "",
"cssTheme": "Catppuccin",
"textFontFamily": "JetBrainsMono Nerd Font,Helvetica",
"monospaceFontFamily": "JetBrainsMono Nerd Font Mono,Source Code Pro",
"showViewHeader": true
"monospaceFontFamily": "JetBrainsMono Nerd Font Mono,Source Code Pro"
}

5
.obsidian/community-plugins.json vendored
View file

@ -4,6 +4,7 @@
"obsidian-style-settings",
"obsidian-kanban",
"editor-width-slider",
"dbfolder",
"dataview",
"obsidian-plugin-toc",
"obsidian-linter",
@ -12,7 +13,5 @@
"obsidian-mind-map",
"obsidian-omnivore",
"templater-obsidian",
"update-time-on-edit",
"periodic-notes",
"calendar"
"update-time-on-edit"
]

2
.obsidian/core-plugins-migration.json vendored
View file

@ -8,7 +8,7 @@
"outgoing-link": true,
"tag-pane": true,
"page-preview": true,
"daily-notes": false,
"daily-notes": true,
"templates": true,
"note-composer": true,
"command-palette": true,

1
.obsidian/core-plugins.json vendored
View file

@ -8,6 +8,7 @@
"tag-pane",
"properties",
"page-preview",
"daily-notes",
"templates",
"note-composer",
"command-palette",

2
.obsidian/plugins/dataview/data.json vendored
View file

@ -15,7 +15,7 @@
"tableGroupColumnName": "Group",
"showResultCount": true,
"allowHtml": true,
"inlineQueryPrefix": ";",
"inlineQueryPrefix": "=",
"inlineJsQueryPrefix": "$=",
"inlineQueriesInCodeblocks": true,
"enableInlineDataview": true,

48
.obsidian/plugins/dbfolder/data.json vendored Normal file
View file

@ -0,0 +1,48 @@
{
"global_settings": {
"enable_debug_mode": false,
"enable_show_state": false,
"enable_row_shadow": true,
"enable_auto_update": true,
"show_search_bar_by_default": false,
"logger_level_info": "error",
"csv_file_header_key": "File",
"media_settings": {
"link_alias_enabled": true,
"enable_media_view": true,
"width": 100,
"height": 100
}
},
"local_settings": {
"remove_field_when_delete_column": true,
"cell_size": "normal",
"sticky_first_column": true,
"group_folder_column": "",
"remove_empty_folders": false,
"automatically_group_files": false,
"hoist_files_with_empty_attributes": true,
"show_metadata_created": false,
"show_metadata_modified": true,
"show_metadata_tasks": false,
"show_metadata_inlinks": false,
"show_metadata_outlinks": false,
"show_metadata_tags": true,
"source_data": "current_folder",
"source_form_result": "",
"source_destination_path": "/",
"row_templates_folder": "templates",
"current_row_template": "",
"pagination_size": 10,
"font_size": 16,
"enable_js_formulas": false,
"formula_folder_path": "/",
"inline_default": false,
"inline_new_position": "last_field",
"date_format": "yyyy-MM-dd",
"datetime_format": "yyyy-MM-dd HH:mm:ss",
"metadata_date_format": "yyyy-MM-dd HH:mm:ss",
"enable_footer": false,
"implementation": "default"
}
}

141
.obsidian/plugins/dbfolder/main.js vendored Normal file
View file

File diff suppressed because one or more lines are too long

11
.obsidian/plugins/dbfolder/manifest.json vendored Normal file
View file

@ -0,0 +1,11 @@
{
"id": "dbfolder",
"name": "DB Folder",
"version": "3.5.0",
"minAppVersion": "1.1.1",
"description": "Folder with the capability to store and retrieve data from a folder like database",
"author": "RafaelGB",
"authorUrl": "https://github.com/RafaelGB/obsidian-bd-folder",
"isDesktopOnly": false,
"fundingUrl": "https://www.buymeacoffee.com/5tsytn22v9Z"
}

1864
.obsidian/plugins/dbfolder/styles.css vendored Normal file
View file

File diff suppressed because it is too large Load diff

641
.obsidian/plugins/obsidian-advanced-slides/main.js vendored Normal file
View file

File diff suppressed because one or more lines are too long

10
.obsidian/plugins/obsidian-advanced-slides/manifest.json vendored Normal file
View file

@ -0,0 +1,10 @@
{
"id": "obsidian-advanced-slides",
"name": "Advanced Slides",
"version": "1.20.0",
"minAppVersion": "0.12.0",
"description": "Create markdown-based presentations in Obsidian",
"author": "Matthäus Szturc",
"authorUrl": "https://github.com/MSzturc",
"isDesktopOnly": true
}

34
.obsidian/plugins/obsidian-advanced-slides/styles.css vendored Normal file
View file

@ -0,0 +1,34 @@
/* Styles */
.view-content.reveal-preview-view {
padding: 0;
overflow: hidden;
}
.view-content.reveal-preview-view>iframe, div.reveal-preview-view>iframe {
border-style: none;
width: 100%;
height: 100%;
}
div.reveal-preview-view {
aspect-ratio: 16/9;
padding: 0;
overflow: hidden;
}
.releaseNotes .modal-content{
padding-right: 5px;
margin-right: -5px;
user-select: text;
}
.releaseNotes .modal {
max-height: 90%;
width: auto;
max-width: 70ch;
}
.releaseNotes p>a>img {
width: 100%
}

1
.obsidian/plugins/obsidian-omnivore/data.json vendored
View file

@ -20,4 +20,3 @@
"intervalId": 14,
"frontMatterVariables": [],
"frontMatterTemplate": "id: {{{ id }}}\ntitle: >\n {{{ title }}}\nstatus: {{{ state }}}\ntags:\n - read-later\n{{#labels.length}}\n{{#labels}} - {{{name}}}\n{{/labels}}\n{{/labels.length}}\ndate_added: {{{ dateSaved}}}\nurl_omnivore: >\n {{{ omnivoreUrl}}}\nurl_original: >\n {{{ originalUrl}}}"
}

139
.obsidian/plugins/obsidian-projects/data.json vendored Normal file
View file

@ -0,0 +1,139 @@
{
"version": 2,
"projects": [
{
"fieldConfig": {},
"defaultName": "",
"templates": [],
"excludedNotes": [],
"isDefault": false,
"dataSource": {
"kind": "folder",
"config": {
"path": "projects/personal-page",
"recursive": true
}
},
"newNotesFolder": "",
"views": [
{
"config": {
"fieldConfig": {
"path": {
"width": 213
}
}
},
"filter": {
"conditions": []
},
"colors": {
"conditions": []
},
"sort": {
"criteria": []
},
"id": "b6be3d23-49d2-45ed-b359-4266a8bfdd46",
"name": "Table",
"type": "table"
},
{
"config": {
"groupByField": "status",
"includeFields": []
},
"filter": {
"conditions": []
},
"colors": {
"conditions": []
},
"sort": {
"criteria": []
},
"id": "f1f17300-a47e-47ab-a3fb-c77aba52fd77",
"name": "Kanban",
"type": "board"
}
],
"id": "693ec588-0a43-4498-9428-7337ddef9516",
"name": "personal-page"
},
{
"fieldConfig": {},
"defaultName": "",
"templates": [],
"excludedNotes": [],
"isDefault": false,
"dataSource": {
"kind": "folder",
"config": {
"path": "games",
"recursive": true
}
},
"newNotesFolder": "",
"views": [
{
"config": {},
"filter": {
"conditions": []
},
"colors": {
"conditions": []
},
"sort": {
"criteria": []
},
"id": "29122e1a-d208-4203-ba3b-6b3373595e5b",
"name": "Table",
"type": "table"
}
],
"id": "3666070f-21b0-4bcd-97b9-54b21dde9fdd",
"name": "Games"
},
{
"fieldConfig": {},
"defaultName": "",
"templates": [],
"excludedNotes": [],
"isDefault": false,
"dataSource": {
"kind": "folder",
"config": {
"path": "books",
"recursive": true
}
},
"newNotesFolder": "",
"views": [
{
"config": {},
"filter": {
"conditions": []
},
"colors": {
"conditions": []
},
"sort": {
"criteria": []
},
"id": "28021a9b-69bb-4972-aa3a-e7e61c0f6423",
"name": "Table",
"type": "table"
}
],
"id": "f2e8e811-8e26-411d-a45e-95bd5e9c5402",
"name": "books"
}
],
"preferences": {
"projectSizeLimit": 1000,
"frontmatter": {
"quoteStrings": "PLAIN"
},
"commands": [],
"linkBehavior": "open-editor"
}
}

77618
.obsidian/plugins/obsidian-projects/main.js vendored Normal file
View file

File diff suppressed because one or more lines are too long

11
.obsidian/plugins/obsidian-projects/manifest.json vendored Normal file
View file

@ -0,0 +1,11 @@
{
"id": "obsidian-projects",
"name": "Projects",
"version": "1.16.3",
"minAppVersion": "1.0.0",
"description": "Plain text project planning.",
"author": "Marcus Olsson",
"authorUrl": "https://marcus.se.net",
"fundingUrl": "https://www.buymeacoffee.com/marcusolsson",
"isDesktopOnly": false
}

80
.obsidian/plugins/obsidian-projects/styles.css vendored Normal file
View file

@ -0,0 +1,80 @@
.projects--board {
display: grid;
column-gap: 8px;
align-items: flex-start;
margin: 8px;
}
.projects--board--column {
border: 1px solid var(--background-modifier-border);
border-radius: var(--radius-m);
background-color: var(--background-secondary);
display: flex;
gap: var(--size-4-2);
flex-direction: column;
padding: var(--size-4-2);
}
.projects--board--card {
background-color: var(--background-primary);
border-radius: var(--radius-s);
border: 1px solid var(--background-modifier-border);
padding: var(--size-4-2);
}
.projects--board--card:hover {
border: 1px solid var(--background-modifier-border-hover);
}
.projects--board--card-list {
display: flex;
flex-direction: column;
gap: var(--size-4-2);
min-height: 35px;
transition: all 150ms ease-in-out;
}
.projects--gallery--grid {
display: grid;
gap: 24px;
}
.projects--gallery--card {
background-color: var(--background-secondary);
border-radius: var(--radius-s);
border: 1px solid var(--background-modifier-border);
padding: 0;
margin: 0;
}
.projects--gallery--card:hover {
border: 1px solid var(--background-modifier-border-hover);
}
.projects--gallery--card__body {
padding: 8px;
}
.projects--gallery--card__media {
height: 180px;
border-top-left-radius: var(--radius-s);
border-top-right-radius: var(--radius-s);
display: flex;
align-items: center;
justify-content: center;
border-bottom: 1px solid var(--background-modifier-border);
}
.projects--gallery--card__media img {
width: 100%;
height: 100%;
border-top-left-radius: var(--radius-s);
border-top-right-radius: var(--radius-s);
}
.workspace-leaf-content[data-type=obsidian-projects] .view-content {
padding: 0;
}
.sortable-drag {
opacity: 0 !important;
}
/*# sourceMappingURL=styles.css.map */

11
.obsidian/plugins/update-time-on-edit/data.json vendored
View file

@ -17,7 +17,7 @@
"templates/base-note.md": "23eff811614efdfb18252c14d7d548b50a707dcfda5f4bf6e0259020f1eeb80a",
"notes/testo.md": "24df1da31f19afae3f434032b447e804a8bcbdeeb1b270c6d04f28bfba5583fb",
"notes/North Start.md": "662704939ce34782d6578cd8d91d5d7d738de19ce5eb34196f71733744bc1286",
"README.md": "10ebf3cf75edbc6a6ccaf5c000185cde1e70bdc86c13d5b150d06546bad9c4dc",
"README.md": "bf94212604234d2f47d6bfd337c42876da63945ab9bede0e15d51827fe72feda",
"notes/Devlog.md": "8796c41169b072acea9ef97211e294ba7b464ccffabc1259c7763440fea7a63e",
"01. Projects/Obtener pasaporte/Obtener pasaporte.md": "f3c1769ca0f40f87c41954c48b4cc791cf77dc22422e15a7005a880d9b030de9",
"02. Areas/Dotfiles/dotfiles tasks.md": "9b662ba9122aaff0817522108a3a2dce6ee203b7f2c58abc8f4934e3899d878a",
@ -38,8 +38,8 @@
"04. Periodic/05. Yearly/2024.md": "7193ba0a3cec692d430ad0fb86f8ad9f210767f801c56a1bfbf7d18dbdbc3823",
"03. Resources/Notetaking/PARA method.md": "6b97f39b4fb42c6f9cdf52abb0221f9d802e163019fbc53d1a618d02e6ab2aaf",
"03. Resources/Notetaking/Progresive Summarization.md": "9236f0faf755cc57e1d6e548f0727f6a2909cc847f8afbef3dc14fa43efa7a44",
"01. Projects/Playa/comida.md": "0c27a53d357c1ffab1d4e6bf98545923dc211004041a3233528164ca47b0ef25",
"01. Projects/Playa/Comprar.md": "28114ba2502978f1a5a748766ed312dead7472155961ece2cf4b82aee13de322",
"01. Projects/Playa/comida.md": "fd69a9aa693a2146a45db3a96d12dad07845c96ceaef7efb248431b2f1323fa8",
"01. Projects/Playa/Comprar.md": "a8b0f8dbd680e48ef070937a3f2f0c840d91a5d2210a29f8d14a672b02c3bcb4",
"03. Resources/Notetaking/Habits.md": "2b6688471702b678ce2a8872ef86049592be866948871d8d3fbca5186f663d93",
"03. Resources/Development/Git.md": "f019123de154b2b1ea6bb2e60b7f0fe25094c9084c257c04c5e10f1fae0a7126",
"03. Resources/Development/Fix messy commits.md": "b1cd788af785ff651eed230eb313b09e984356de8bc2f1ab16b6858e2e5c6acf",
@ -50,6 +50,9 @@
"02. Areas/Escape Latam/Canada.md": "974bdb92354ff2d46e67f524390bce477c8b0f753012f4f86eb0d4291b10a6ce",
"02. Areas/Escape Latam/Comparación de Paises.md": "6fb41dde50e73d696948be100340f951fc490f40cbcdda45584719fd7ba57194",
"02. Areas/Escape Latam/Escapar de Latam.md": "4ac856a52471f5eb6923790a96bbbf9daa867137cf9b8add09f498ba87e4469e",
"02. Areas/Escape Latam/New Zeldand.md": "c46e7d6cb08da2a7d5500640abc560f5db37dd056561420bce56df1c6eb485c7"
"02. Areas/Escape Latam/New Zeldand.md": "c46e7d6cb08da2a7d5500640abc560f5db37dd056561420bce56df1c6eb485c7",
"notes/Good Enough.md": "0bb2e063f1f416af89a28b03bee9f40b0b3cbb170167efea08ad1fbb13751c58",
"notes/Git.md": "c94e17e08d108bdfb69d3a1bda02bcb74e4e02f1bb827c8c518d0c4e299fdc7a",
"conflict-files-obsidian-git.md": "f47a30e9c50c5fe01481f7e7aad0d42268aa4ef39cdcb2f6a17ea59aa2e4cdd1"
}
}

240
.obsidian/workspaces.json vendored
View file

@ -159,245 +159,7 @@
}
},
"active": "cc8b90c9f364aa3f"
},
"Main": {
"main": {
"id": "562d7786e8852d38",
"type": "split",
"children": [
{
"id": "37e1d8b92dea984d",
"type": "tabs",
"children": [
{
"id": "be3160140440a406",
"type": "leaf",
"state": {
"type": "markdown",
"state": {
"file": "04. Periodic/03. Monthly/2024-02.md",
"mode": "source",
"source": false
}
}
}
]
}
],
"direction": "vertical"
},
"left": {
"id": "329187d0b724eea8",
"type": "split",
"children": [
{
"id": "52f737f07314ccc6",
"type": "tabs",
"children": [
{
"id": "e1cc054d09ed6ded",
"type": "leaf",
"state": {
"type": "git-view",
"state": {}
}
},
{
"id": "8d7dca2686874e38",
"type": "leaf",
"state": {
"type": "file-explorer",
"state": {
"sortOrder": "alphabetical"
}
}
},
{
"id": "7554409ced8a27ba",
"type": "leaf",
"state": {
"type": "search",
"state": {
"query": "",
"matchingCase": false,
"explainSearch": false,
"collapseAll": false,
"extraContext": false,
"sortOrder": "alphabetical"
}
}
},
{
"id": "b8151ae49b872165",
"type": "leaf",
"state": {
"type": "bookmarks",
"state": {}
}
}
],
"currentTab": 1
},
{
"id": "cce37a107233693d",
"type": "tabs",
"children": [
{
"id": "b51035fd488f06cb",
"type": "leaf",
"state": {
"type": "calendar",
"state": {}
}
}
]
}
],
"direction": "horizontal",
"width": 434
},
"right": {
"id": "fca86750b2867923",
"type": "split",
"children": [
{
"id": "b2aeb0b1779bc56d",
"type": "tabs",
"children": [
{
"id": "2317e23d35b58541",
"type": "leaf",
"state": {
"type": "file-properties",
"state": {
"file": "04. Periodic/03. Monthly/2024-02.md"
}
}
},
{
"id": "9b65a6cf59dadc4f",
"type": "leaf",
"state": {
"type": "outline",
"state": {
"file": "04. Periodic/03. Monthly/2024-02.md"
}
}
},
{
"id": "15148a0310063e2c",
"type": "leaf",
"state": {
"type": "backlink",
"state": {
"file": "04. Periodic/03. Monthly/2024-02.md",
"collapseAll": false,
"extraContext": false,
"sortOrder": "alphabetical",
"showSearch": false,
"searchQuery": "",
"backlinkCollapsed": false,
"unlinkedCollapsed": true
}
}
},
{
"id": "2bd2d7df7b2e0f88",
"type": "leaf",
"state": {
"type": "outgoing-link",
"state": {
"file": "04. Periodic/03. Monthly/2024-02.md",
"linksCollapsed": false,
"unlinkedCollapsed": true
}
}
},
{
"id": "7ca7ab454aba7be1",
"type": "leaf",
"state": {
"type": "tag",
"state": {
"sortOrder": "frequency",
"useHierarchy": true
}
}
},
{
"id": "5200eab2bb1c942e",
"type": "leaf",
"state": {
"type": "all-properties",
"state": {
"sortOrder": "frequency",
"showSearch": false,
"searchQuery": ""
}
}
}
]
},
{
"id": "659b2005e093e0fe",
"type": "tabs",
"children": [
{
"id": "85da40ededf1ce00",
"type": "leaf",
"state": {
"type": "localgraph",
"state": {
"file": "04. Periodic/03. Monthly/2024-02.md",
"options": {
"collapse-filter": false,
"search": "",
"localJumps": 1,
"localBacklinks": true,
"localForelinks": true,
"localInterlinks": true,
"showTags": true,
"showAttachments": true,
"hideUnresolved": false,
"collapse-color-groups": true,
"colorGroups": [],
"collapse-display": true,
"showArrow": true,
"textFadeMultiplier": 0,
"nodeSizeMultiplier": 1,
"lineSizeMultiplier": 1,
"collapse-forces": true,
"centerStrength": 0.518713248970312,
"repelStrength": 10,
"linkStrength": 1,
"linkDistance": 250,
"scale": 1,
"close": true
}
}
}
}
]
}
],
"direction": "horizontal",
"width": 423
},
"left-ribbon": {
"hiddenItems": {
"switcher:Open quick switcher": false,
"graph:Open graph view": false,
"templates:Insert template": false,
"command-palette:Open command palette": true,
"workspaces:Manage workspace layouts": false,
"obsidian-excalidraw-plugin:Create new drawing": false,
"obsidian-omnivore:Omnivore": false,
"templater-obsidian:Templater": false,
"periodic-notes:Open today": false
}
},
"active": "be3160140440a406"
}
},
"active": "Main"
"active": "Quests"
}

7
01. Projects/Playa/Comprar.md
View file

@ -1,7 +1,8 @@
---
created: 2024-02-18 20:48
updated: 2024-02-18 21:14
created: 2024-02-18T20:48:00-03:00
updated: 2024-02-19T14:28:30-03:00
---
Hay que revisar que wea hay para ir a comprar
## Super
@ -18,6 +19,8 @@ Hay que revisar que wea hay para ir a comprar
- Salsa blanca o crema
- Harina
- 1 paquete de legumbres
- Bolsa de basura
- Huevos
## Carnicería
- Medio kilo de posta (carnicería)

5
01. Projects/Playa/comida.md
View file

@ -1,7 +1,8 @@
---
created: 2024-02-18 15:29
updated: 2024-02-18 21:14
created: 2024-02-18T15:29:00-03:00
updated: 2024-02-19T14:54:57-03:00
---
## Main
- Tallarines

8
README.md
View file

@ -1,11 +1,3 @@
---
created: 2023-08-08 15:59
updated: 2024-02-02 20:06
---
# docs
Markdown files for general purpose
## Workflow
I use the [PARA method](PARA%20method.md).

28
Read Later/Git Merge vs Rebase vs Squash ¿Qué estrategia debemos elegir-.md Normal file
View file

@ -0,0 +1,28 @@
---
id: fc51bf82-66d3-451f-8f64-17d6add50f92
title: |
Git Merge vs Rebase vs Squash ¿Qué estrategia debemos elegir?
status: ARCHIVED
tags:
- read-later
- Youtube
date_added: 2023-11-04 14:14:49
url_omnivore: |
https://omnivore.app/me/https-www-youtube-com-watch-pp-yg-ukz-2-l-0-ih-nxd-w-fza-a-253-d-18b9b548407
url_original: |
https://www.youtube.com/watch?pp=ygUKZ2l0IHNxdWFzaA%253D%253D&v=HlmZLXMOpEM
---
# Git Merge vs Rebase vs Squash ¿Qué estrategia debemos elegir?
## Notes
- Merge commit: Se crea un commit que tiene 2 padres, el último commit de main y la feature branch, se mantiene la trazabilidad hacia la feature branch pero el historial queda visualmente más complejo ^5df1b4
- Rebase: Se copian los commits de la feature branch a main como nuevos commits, se pierde la trazabilidad hacia la feature branch pero queda un historial lineal en main
- Squash commit: Se juntan todos los commits en uno solo con un squash que queda en main, se pierde la trazabilidad hacia la feature branch pero queda un historial lineal en main
---
## Original
[Git Merge vs Rebase vs Squash ¿Qué estrategia debemos elegir?](https://www.youtube.com/watch?pp=ygUKZ2l0IHNxdWFzaA%253D%253D&v=HlmZLXMOpEM)
By [CodelyTV - Redescubre la programación](https://www.youtube.com/@CodelyTV)

350
Read Later/Highlighting fold text, community fork of null-ls, leetcode integration, reduce ram usage of LSP ....md Normal file
View file

@ -0,0 +1,350 @@
---
id: 512f7bbc-6ba0-11ee-be2a-83432433f852
title: |
Highlighting fold text, community fork of null-ls, leetcode integration, reduce ram usage of LSP servers, svelte inspector integration
status: ARCHIVED
tags:
- read-later
- RSS
date_added: 2023-10-15 16:10:23
url_omnivore: |
https://omnivore.app/me/highlighting-fold-text-community-fork-of-null-ls-leetcode-integr-18b3533f57b
url_original: |
https://dotfyle.com/this-week-in-neovim/55
---
# Highlighting fold text, community fork of null-ls, leetcode integration, reduce ram usage of LSP servers, svelte inspector integration
## Highlights
> [!quote] ㅤ
> hinell/duplicate.nvim
>
> [source](https://omnivore.app/me/highlighting-fold-text-community-fork-of-null-ls-leetcode-integr-18b3533f57b#5de369b4-f406-446f-b59a-358d59dd9eb1) #Todo
>
>
>> [!info] ㅤ
>> Add to nvim config
---
## Original
## Introduction
This week we have new features in Neovim Core, new plugins and new releases. Some new Neovim features include `:fclose` to close floating windows, support spaces in in directory names, treesitter highlighting in folds and NVIM\_APPNAME supports relative paths.
We have several new plugins, e.g. you can now grind LeetCode inside Neovim, mini.pick a new fuzzy finder + selector added to the mini.nvim library, and a plugin to start/stop LSP servers upon demand to keep RAM usage low etc..
Hope you enjoy!
## Neovim core
> Updates of Neovim itself, which are available on Neovim nightly.
> * [@neovim](https://twitter.com/neovim) on Twitter
> * [Neovim news](https://neovim.io/doc/user/news.html)
> * `:h news.txt` updates in Neovim directly
> * [PR's on GitHub](https://github.com/neovim/neovim/pulls)
* [:fclose to close floating window](https://github.com/neovim/neovim/commit/fd39f5ce8c9bbda1b77ff6c03553148fadac5d57)
* [Spaces can be used to separate directory names. To have a space in a directory name, precede it with an extra backslash, and escape the space](https://github.com/neovim/neovim/commit/f5eabaa9407ae3d1ccf6592337453c423eff3d9a)
* [Ignore swapfile for running Nvim processes](https://github.com/neovim/neovim/commit/29fe883aa9166bdbcae3f935523c75a8aa56fe45)
* [vim.lsp.util.parse\_snippet() will now strictly follow the snippet grammar defined by LSP, and hence previously parsed snippets might now be considered invalid input.](https://github.com/neovim/neovim/commit/eb1f0e8fcca756a00d287e23bf87554e0e7f6dfd)
* [vim.treesitter.foldtext() applies treesitter highlighting to foldtext.](https://github.com/neovim/neovim/commit/9ce1623837a817c3f4f5deff9c8ba862578b6009)
* [Better cmdline completion for string option value](https://github.com/neovim/neovim/commit/01c51a491330bd10202c73aff92c0978984c0692)
* [Support toggling showing of float window](https://github.com/neovim/neovim/commit/4200a0f1678c06c6da4e4cfb0184c29c1174ed21)
* [NVIM\_APPNAME now supports relative paths](https://github.com/neovim/neovim/commit/a66b0fdfaa35715c832b98b8941cc5673505e0c2)
### Highlighted folds on Neovim Nightly
![](https://proxy-prod.omnivore-image-cache.app/0x0,ss9FR9nPpf2xd7VL3QE_RfLsetWTtmxbY61RRMWJImHA/https://user-images.githubusercontent.com/76068197/275348092-0703f60e-6593-46d5-9c71-a24bd2d66e0c.png)
* [PR](https://github.com/neovim/neovim/pull/25209)
* [Reddit](https://www.reddit.com/r/neovim/comments/16sqyjz/finally%5Fwe%5Fcan%5Fhave%5Fhighlighted%5Ffolds/)
## Neovim Plugin Community
> Neovim is full of active plugins. This section is about the community and what is going on.
---
### Resources & articles
#### Open Neovim From Your Browser - Integrating nvim with Svelte’s Inspector
* [Blog](https://theosteiner.de/open-neovim-from-your-browser-integrating-nvim-with-sveltes-inspector)
* [Reddit](https://www.reddit.com/r/neovim/comments/177p9fj/open%5Fneovim%5Ffrom%5Fyour%5Fbrowser%5Fintegrating%5Fnvim/)
---
### New plugins
#### none-ls.nvim is a community fork of null-ls.nvim
> null-ls.nvim reloaded / Use Neovim as a language server to inject LSP diagnostics, code actions, and more via Lua.
null-ls.nvim fork, maintained by the community. Only the repository name has changed for compatibility reasons. All the API's will stay as is.
Migrate by replacing `jose-elias-alvarez/null-ls.nvim` with `nvimtools/none-ls.nvim` in your package manager.
* [GitHub](https://github.com/nvimtools/none-ls.nvim)
* [Dotfyle](https://dotfyle.com/plugins/nvimtools/none-ls.nvim)
* [Reddit](https://www.reddit.com/r/neovim/comments/16wystn/nonelsnvim%5Fis%5Fa%5Fcommunity%5Ffork%5Fof%5Fnulllsnvim/)
#### kawre/leetcode.nvim
![](https://proxy-prod.omnivore-image-cache.app/0x0,s-nS7H-H7wHHTmPvfG-wYq6Nm4dc-d7uCDI5EGUQUPi4/https://user-images.githubusercontent.com/76068197/275347053-9da7144f-3228-458a-8b4a-d90c0697a5ad.png)
> A Neovim plugin enabling you to solve LeetCode problems within Neovim.
* [GitHub](https://github.com/kawre/leetcode.nvim)
* [Dotfyle](https://dotfyle.com/plugins/kawre/leetcode.nvim)
* [Reddit](https://www.reddit.com/r/neovim/comments/173ctlz/leetcodenvim%5Fsolve%5Fleetcode%5Fproblems%5Fwithin%5Fneovim/)
#### echasnovski/mini.pick
![](https://proxy-prod.omnivore-image-cache.app/0x0,s39XpvBv25BzmpXHxoR7A457BdtASjng52-Nraygomjo/https://user-images.githubusercontent.com/76068197/275347316-ab621b68-d2a8-4386-a78d-ca5fdac782a9.png)
> pick anything. Interactive non-blocking picker with one window design, toggleable preview, fast default matching, built-in pickers, and more
* [GitHub](https://github.com/echasnovski/mini.pick)
* [Dotfyle](https://dotfyle.com/plugins/echasnovski/mini.pick)
* [Reddit](https://www.reddit.com/r/neovim/comments/176yv8g/minipick%5Fpick%5Fanything%5Finteractive%5Fnonblocking/)
#### hinell/lsp-timeout.nvim
![](https://proxy-prod.omnivore-image-cache.app/0x0,sgj8zqD5oSQCb-ORZmumOFzudjNHrLNufD7JlTpy5urI/https://user-images.githubusercontent.com/76068197/275345414-3aa97afd-c01b-4fe8-b366-27bc0d8bfb4f.png)
> Start/stop LSP servers upon demand; keeps RAM usage low
Some LSP servers are terribly inefficient at memory management and can easily take up gigabytes of RAM MBs if left unattended (just like VS Code huh?!). This plugin prevents excessive memory usage by stopping and restarting LSP servers automatically upon gaining or loosing window focus, keeping neovim fast.
* [GitHub](https://github.com/hinell/lsp-timeout.nvim)
* [Dotfyle](https://dotfyle.com/plugins/hinell/lsp-timeout.nvim)
* [Reddit](https://www.reddit.com/r/neovim/comments/16vkkj8/lsptimeoutnvim/)
---
#### luckasRanarison/clear-action.nvim
![](https://proxy-prod.omnivore-image-cache.app/0x0,seOp3qhUyv-KN0pPWVksq0S1sQrzgNR1ebFvWYsFGHYw/https://github.com/luckasRanarison/clear-action.nvim/assets/101930730/bdf6be6c-e463-4b60-98f7-d5d2aea4450d)
> Predictable LSP code actions
A simple Neovim plugin that enhances LSP code actions with fully customizable signs, personalized actions, and server-specific mappings, making code actions more predictable.
* [GitHub](https://github.com/luckasRanarison/clear-action.nvim)
* [Dotfyle](https://dotfyle.com/plugins/luckasRanarison/clear-action.nvim)
* [Reddit](https://www.reddit.com/r/neovim/comments/16v32p5/clearactionnvim%5Fmakes%5Flsp%5Fcode%5Factions/)
---
#### JMarkin/gentags.lua
> autogenerate tags for neovim
* [GitHub](https://github.com/JMarkin/gentags.lua)
* [Dotfyle](https://dotfyle.com/plugins/JMarkin/gentags.lua)
---
#### roobert/palette.nvim
![](https://proxy-prod.omnivore-image-cache.app/0x0,s8b0Q9_Xq79ZxkXKntykjcCCimV7CZNvJCliwh7P3BWY/https://github.com/roobert/palette.nvim/assets/226654/2d7ff03c-f1d5-46b9-9359-973fcf7002ed)
> 🎨 Palette - A beautiful, versatile, systematic, Neovim theme system
Palette is a Neovim theme system to make creating and customizing themes easy.
Highlight groups are logically arranged to strike a harmonious balance between clarity and aesthetic appeal.
Caching ensures themes are performant.
Build easily distributable themes using the provided build script.
Generate application color schemes, such as for LS\_COLORS and iterm2 for matching terminal feel.
* [GitHub](https://github.com/roobert/palette.nvim)
* [Dotfyle](https://dotfyle.com/plugins/roobert/palette.nvim)
* [Reddit](https://www.reddit.com/r/neovim/comments/16smdr6/introducing%5Froobertpalettenvim%5Fa%5Fbeautiful/)
---
#### MunifTanjim/nougat.nvim
![](https://proxy-prod.omnivore-image-cache.app/0x0,sBQFkFPJmYnt_ybC-QlTLMUDHmtH1dUWINAJLYuzPkV8/https://raw.githubusercontent.com/wiki/MunifTanjim/nougat.nvim/media/bubbly-statusline.png) ![](https://proxy-prod.omnivore-image-cache.app/0x0,s8721VcLMluVw2o5zbqpq42Cou9n_DNRnQ-6EEYIaZDA/https://raw.githubusercontent.com/wiki/MunifTanjim/nougat.nvim/media/pointy-statusline.png) ![](https://proxy-prod.omnivore-image-cache.app/0x0,sdxJRzRzMam9Pp5vuY69AdXlipU1JYPRZ4t_bLOL0y_g/https://raw.githubusercontent.com/wiki/MunifTanjim/nougat.nvim/media/slanty-statusline.png)
> 🍫 Hyperextensible Statusline / Tabline / Winbar for Neovim 🚀
* [GitHub](https://github.com/MunifTanjim/nougat.nvim)
* [Dotfyle](https://dotfyle.com/plugins/MunifTanjim/nougat.nvim)
---
#### trimclain/builder.nvim
![](https://proxy-prod.omnivore-image-cache.app/0x0,ssQSPS4kiVqJmf8x8O7zqevhYjyAgS-oxuOyaaU2VRLg/https://github.com/trimclain/builder.nvim/assets/84108846/6f94dc76-b652-4ac8-b54e-c3d19aaebdaa)
> Simple building plugin for neovim
* [GitHub](https://github.com/trimclain/builder.nvim)
* [Dotfyle](https://dotfyle.com/plugins/trimclain/builder.nvim)
* [Reddit](https://www.reddit.com/r/neovim/comments/16qwcl7/buildernvim%5Fsimple%5Fbuild%5Fplugin%5Ffor%5Fneovim/)
---
#### niuiic/git-log.nvim
![](https://proxy-prod.omnivore-image-cache.app/0x0,suRdnhdGKggw0zuXb7Axpp8Ykw_8unFeoGTBiquP2o84/https://user-images.githubusercontent.com/76068197/275345480-b7d2cc41-5e59-4a13-a5b7-cadf3e5ecbdd.png)
> Check git log of the selected code.
* [GitHub](https://github.com/niuiic/git-log.nvim)
* [Dotfyle](https://dotfyle.com/plugins/niuiic/git-log.nvim)
---
#### 2KAbhishek/nerdy.nvim
![](https://proxy-prod.omnivore-image-cache.app/0x0,sO3ro_AEJRwkyAM2Zgz3qr5ZpUkndJ4K7GkSz9HLc0oQ/https://user-images.githubusercontent.com/76068197/275345538-f957e324-fbd6-408c-a0c2-810b29559a6e.png)
> Find Nerd Glyphs Easily 🤓🔭
Do you like Nerd fonts, but don't like going over to the site just to find a glyph? nerdy.nvim, is a super handy plugin that lets you easily search, preview and insert any nerd font glyph from Neovim!
* [GitHub](https://github.com/2KAbhishek/nerdy.nvim)
* [Dotfyle](https://dotfyle.com/plugins/2KAbhishek/nerdy.nvim)
* [Reddit](https://www.reddit.com/r/neovim/comments/16qr135/nerdynvim%5Feasily%5Ffind%5Fand%5Finsert%5Fnerd%5Ffont%5Fglyphs/)
---
#### David-Kunz/gen.nvim
![](https://proxy-prod.omnivore-image-cache.app/0x0,sDEgBaEypwAzP6zU-c2NJ7cP01Q09bjxV4HNeiC_XbrU/https://user-images.githubusercontent.com/1009936/273126287-7b5f2b40-c678-47c5-8f21-edf9516f6034.jpg)
> Neovim plugin to generate text using LLMs with customizable prompts
* [GitHub](https://github.com/David-Kunz/gen.nvim)
* [Dotfyle](https://dotfyle.com/plugins/David-Kunz/gen.nvim)
* [Reddit](https://www.reddit.com/r/neovim/comments/16x1zf7/local%5Fllms%5Fin%5Fneovim%5Fgennvim/)
* [Youtube](https://www.youtube.com/watch?v=FIZt7MinpMY)
---
#### VidocqH/data-viewer.nvim
![](https://proxy-prod.omnivore-image-cache.app/0x0,srNNDmEeUxRH-7_Y1wRlwYn94Oat2ouVMlUCBmdHneEI/https://github.com/VidocqH/data-viewer.nvim/assets/16725418/7b933b3a-fd4e-4758-9917-9055c35796db)
> Table view for data files, csv, tsv
Lightweight neovim plugin provides a table view for inspect data files such as csv, tsv
* [GitHub](https://github.com/VidocqH/data-viewer.nvim)
* [Dotfyle](https://dotfyle.com/plugins/VidocqH/data-viewer.nvim)
---
#### hinell/duplicate.nvim
![](https://proxy-prod.omnivore-image-cache.app/0x0,slEysMO2620IzV16kXsH9RrCm7Ei5n-k7nnKR6htL-2Q/https://user-images.githubusercontent.com/76068197/275346764-065046c6-d267-4c8f-bf52-6b9fa0683229.png)
> Duplicate visual selection, lines, and textobjects
Duplicate lines in different directions (up/down) by specified offset Duplicate visual selection & line-wise blocks
* [GitHub](https://github.com/hinell/duplicate.nvim)
* [Dotfyle](https://dotfyle.com/plugins/hinell/duplicate.nvim)
* [Reddit](https://www.reddit.com/r/neovim/comments/16vkd4x/duplicatenvim/)
---
#### niuiic/remote.nvim
![](https://proxy-prod.omnivore-image-cache.app/0x0,sltK2sIjx8vjII6g18eOoH3oI0BmzGHzVDlVE9RdUdLA/https://raw.githubusercontent.com/niuiic/assets/main/remote.nvim/usage.gif)
> Edit remote files locally.
Edit remote files with local neovim configuration.
Edit them as local directories.
No other dependencies required for remote machine except ssh.
* [GitHub](https://github.com/niuiic/remote.nvim)
* [Dotfyle](https://dotfyle.com/plugins/niuiic/remote.nvim)
---
#### niuiic/typst-preview.nvim
![](https://proxy-prod.omnivore-image-cache.app/0x0,sE0IeNg46_eRW_AAomtq470uTgYbmvFlRqfrozGff0FY/https://raw.githubusercontent.com/niuiic/assets/main/typst-preview.nvim/usage.gif)
> Neovim plugin to preview typst document.
Generate pdf files by typst compile. Respond to subsequent file changes with typst-lsp. Redirect these pdf files to a fixed path when you switch buffer. Preview this pdf by a pdf viewer with the ability to respond to the file changes.
* [GitHub](https://github.com/niuiic/typst-preview.nvim)
* [Dotfyle](https://dotfyle.com/plugins/niuiic/typst-preview.nvim)
---
#### SalOrak/whaler.nvim
![](https://proxy-prod.omnivore-image-cache.app/0x0,sFs6Ddy-8eYOlxjXwza6MvJFpi5bUL_iCLP3Ipz6DvL0/https://raw.githubusercontent.com/SalOrak/whaler.nvim/main/whaler-example.gif)
> Telescope extension to change between directories blazingly fast
Whaler is a Telescope extension to move between directories. It is based on the concept of [tmux-windowizer](https://github.com/ThePrimeagen/.dotfiles/blob/master/bin/.local/scripts/tmux-windowizer) which uses a set of directories and fzf to move to another directory whilst creating a new tmux session.
* [GitHub](https://github.com/SalOrak/whaler.nvim)
* [Dotfyle](https://dotfyle.com/plugins/SalOrak/whaler.nvim)
* [Reddit](https://www.reddit.com/r/neovim/comments/16wgw0b/whalernvim/)
---
#### gsuuon/note.nvim
![](https://proxy-prod.omnivore-image-cache.app/0x0,sBOuCCo6p72mfZPAiqP1Ivk-u3waye8dHKUsd-UNJfxY/https://github.com/gsuuon/note.nvim/assets/6422188/813e74e7-d9dc-4b5f-b433-4ef294491797)
> Notes in neovim
A simple Neovim note taking plugin with daily notes, task tracking and syntax highlighting.
note.nvim makes it easy to take working notes and track tasks. It adds commands to help manipulate task items, create daily notes, and navigate within (and between) notes.
* [GitHub](https://github.com/gsuuon/note.nvim)
* [Dotfyle](https://dotfyle.com/plugins/gsuuon/note.nvim)
---
#### A retrospective on why Nyoom is archived
* [Reddit](https://www.reddit.com/r/neovim/comments/16sk266/nyoom%5Fwhy%5Fim%5Fultimately%5Farchiving%5Fit%5Fa%5Fshort/)
#### indent-blankline.nvim v3 is released
* [GitHub](https://github.com/lukas-reineke/indent-blankline.nvim)
* [Dotfyle](https://dotfyle.com/plugins/lukas-reineke/indent-blankline.nvim)
* [Migration guide](https://github.com/lukas-reineke/indent-blankline.nvim/wiki/Migrate-to-version-3)
* [Reddit](https://www.reddit.com/r/neovim/comments/16u5abl/indent%5Fblankline%5Fv3%5Fis%5Freleased/)
#### LazyVim 10.0.0 has been released!
* [GitHub](https://github.com/LazyVim/LazyVim)
* [Dotfyle](https://dotfyle.com/plugins/LazyVim/LazyVim)
* [Changelog](https://github.com/LazyVim/LazyVim/blob/main/CHANGELOG.md)
* [Reddit](https://www.reddit.com/r/neovim/comments/1766fl1/lazyvim%5F1000%5Fhas%5Fbeen%5Freleased/)
---
## Contributing
Add your the plugin in either of the following to be featured in This Week in Neovim and Dotfyle:
* [rockerBOO/awesome-neovim](https://github.com/rockerBOO/awesome-neovim)
* [SUBMITTED\_PLUGINS.md](https://github.com/codicocodes/dotfyle/blob/main/SUBMITTED-PLUGINS.md)
Contribute to the development of Dotfyle:
* File issues and submit pull requests on [GitHub](https://github.com/codicocodes/dotfyle)
* Discuss ideas on [Discord](https://discord.gg/AMbnnN5eep)

30
Read Later/How Game Reviews Actually Affect You.md Normal file
View file

@ -0,0 +1,30 @@
---
id: f07b145f-4fc5-4acf-99a4-4e3201c009b9
title: |
How Game Reviews Actually Affect You
status: ARCHIVED
tags:
- read-later
- Youtube
date_added: 2023-10-21 16:01:08
url_omnivore: |
https://omnivore.app/me/how-game-reviews-actually-affect-you-18b539cd3a3
url_original: |
https://youtu.be/8LbLvi9llCI?si=7MMwTZTpCb-mHDH5
---
# How Game Reviews Actually Affect You
## Notes
Según estudios, los jugadores se ven afectados por reviews que leen/ven, ya sean por críticos o por otros jugadores. Destacar que en ambos casos, pero principalmente en otros jugadores hay opiniones que pueden decir lo mismo pero con una altas carga emocional, lo que amplifica su impacto.
Estas críticas tienen un impacto inconciente en el jugador en forma de _"self fulfilling prophecy"_ ó _"probar lo contrario"_.
Esto nos afecta queramos o no, por lo que es mejor evitar opiniones lo más posible y solo disfrutar el juego por lo que es, podemos validar nuestras opiniones luego de terminar el juego.
---
## Original
[How Game Reviews Actually Affect You](https://youtu.be/8LbLvi9llCI?si=7MMwTZTpCb-mHDH5)
By [Daryl Talks Games](https://www.youtube.com/@DarylTalksGames)

463
Read Later/How to Avoid Prop Drilling in React.md Normal file
View file

@ -0,0 +1,463 @@
---
id: aceac380-7e10-11ee-992a-432064e77190
title: |
How to Avoid Prop Drilling in React
status: ARCHIVED
tags:
- read-later
- RSS
- react
date_added: 2023-11-07 19:58:39
url_omnivore: |
https://omnivore.app/me/how-to-avoid-prop-drilling-in-react-18bae0b4ca2
url_original: |
https://www.freecodecamp.org/news/avoid-prop-drilling-in-react/
---
# How to Avoid Prop Drilling in React
## Highlights
> [!quote] ㅤ
> Prop drilling occurs when a parent component generates its state and passes it down as `props` to its children components that do not consume the props – instead, they only pass it down to another component that finally consumes it.
>
> [source](https://omnivore.app/me/how-to-avoid-prop-drilling-in-react-18bae0b4ca2#05db3def-4e59-4cfe-b8dd-1044ce91a9d5)
> > [!quote] ㅤ
> First of all, **grouping static elements and dependent components** together to achieve an appealing UI design is the major cause of prop drilling. You can't avoid prop drilling when your UI groups static elements and dependent components together in a parent. The parent component clearly won't use the `prop`, as everything within it is a static element – except the component that needs a prop.
>
> [source](https://omnivore.app/me/how-to-avoid-prop-drilling-in-react-18bae0b4ca2#fa2c28c0-1b7e-4416-8553-c1b5c7a59637)
> > [!quote] ㅤ
> Second of all, when a **component accepts `props` that it doesn't use but merely passes it down to its children**, this is a sign that you have prop drilling in your component:
>
> [source](https://omnivore.app/me/how-to-avoid-prop-drilling-in-react-18bae0b4ca2#6749a89e-a38c-4f4f-aa3f-c6455e6daf85)
> > [!quote] ㅤ
> Third, when a component that represents an independent section of a page is **forced to take props from its parent**, prop drilling is inevitable. It should ideally be self-contained with its state and operations.
>
> [source](https://omnivore.app/me/how-to-avoid-prop-drilling-in-react-18bae0b4ca2#751d81de-62b7-444b-a2f0-a0b374f6ce45)
> > [!quote] ㅤ
> And finally, **the presence of elongated `props`** is a sure sign of prop drilling. Since an elongated prop is a fundamental element that's consistently present in every case of prop drilling, grasping this concept allows you to instinctively avoid prop drilling.
>
> [source](https://omnivore.app/me/how-to-avoid-prop-drilling-in-react-18bae0b4ca2#90f807ca-03a3-4804-bcf1-c5df4e53a997)
> > [!quote] ㅤ
> Component composition is a good approach to fix prop drilling. If you ever find yourself in a situation where a component passes down a prop it neither creates nor consumes, you can use component composition to fix it.
>
> [source](https://omnivore.app/me/how-to-avoid-prop-drilling-in-react-18bae0b4ca2#0112181f-34b7-4ca3-b941-f1c16303c6c0)
> > [!quote] ㅤ
> To avoid prop drilling in this case, any grandchildren components that require access to the same `props`, especially when their parent don't consume the data, should be passed as children ensuring that the data remains within the `App` context.
>
> [source](https://omnivore.app/me/how-to-avoid-prop-drilling-in-react-18bae0b4ca2#c17f1d4e-8f5c-45d1-9078-fe8ab740e11e)
> > [!quote] ㅤ
> Prop drilling can also be fixed by moving state to where it is consumed. The example of prop drilling in this article has a component named `Content`. But the component is forced to receive a `prop` from its parent instead of having a state and be an independent component – and so we have prop drilling.
>
> [source](https://omnivore.app/me/how-to-avoid-prop-drilling-in-react-18bae0b4ca2#9f94fd13-9558-4bd3-a60c-60074b3495d2)
> > [!quote] ㅤ
> It's essential to highlight what to avoid when dealing with prop drilling to prevent unnecessary challenges.
>
> * **Avoid React Context, if possible, to fix prop drilling.** This approach ties your component to a specific context, restricting its usability outside of that context and hindering composition and reusability.
> * **Steer clear of redundant components by employing a children-parent replacement approach.** This approach naturally incorporates [component composition](https://www.codementor.io/@dinerismail/the-power-of-component-composition-in-react-21goassg4m) without introducing redundant components or states when resolving prop drilling.
>
> [source](https://omnivore.app/me/how-to-avoid-prop-drilling-in-react-18bae0b4ca2#8ff7b79b-5503-4e1a-b7fe-1a07a46c578c)
>
---
## Original
![How to Avoid Prop Drilling in React](https://proxy-prod.omnivore-image-cache.app/1280x720,sKh6f6Y_QlOrf22lUoux3sSuSVezHNMNwL0zz9QlJgdQ/https://www.freecodecamp.org/news/content/images/size/w2000/2023/11/Purple-Creative-Livestream-YouTube-Thumbnail.png)
In order to write scalable, reusable, and maintainable applications with React, you'll need to go beyond the surface of using React components, useEffect, useContext, useState, and the like. It involves learning in detail how React works in more depth.
And if you don't properly understand these key React concepts, you can run into various issues, like [prop drilling](https://www.quora.com/What-is-prop-drilling-in-ReactJS).
In this tutorial, you'll learn what prop drilling is. I'll also teach you how to intuitively avoid it without relying on React context. In the end, you'll understand how to identify prop drilling without thinking and fix it with precision.
If you prefer a visual guide, here's a video version of this tutorial on my [YouTube channel](https://youtu.be/KZnQ5R8Kd4I) (approximately 15 minutes).
[![Watch the video](https://proxy-prod.omnivore-image-cache.app/480x360,sEF1bGD-Lf4T-Vw-XRelb5_QXFIgGpiBvkoeFBwT8sbs/https://img.youtube.com/vi/ELZZnqHJhlw/hqdefault.jpg)](https://www.youtube.com/embed/ELZZnqHJhlw)
## What is Prop Drilling?
==Prop drilling occurs when a parent component generates its state and passes it down as== `==props==` ==to its children components that do not consume the props – instead, they only pass it down to another component that finally consumes it.==
Below is an example of prop drilling in React:
```xquery
function App() {
const [profile, setProfile] = useState({ame: 'John'});
return (
<div> <Header profile={profile} />
</div>
);
}
function Header({ profile }) {
return (
<header>
<h1>This is the header</h1>
<Content profile={profile} />
</header>
);
}
function Content({ profile }) {
return (
<main>
<h2>Content Component</h2>
<p>{profile.name}</p>
</main>
);
}
export default App;
```
If you check out the example above, you'll notice that `profile` is passed from the `App` component through the `Header` to the `Content` component, which eventually makes use of the `props`. This is commonly referred to as prop drilling as the `Header` component doesn't consume the `prop` but only passes it down to the `Content` component that finally consumes it.
Now that you understand what prop drilling is, the next challenge is to figure out how to avoid it because it's not always an intuitive process.
You'll need to start exploring methods to address it. While you can use component composition and React context to resolve it, the challenge lies in not always recognizing the issue until later.
To truly master the art of handling prop drilling intuitively, you must learn how to identify elongated props and contexts.
## What is an Elongated Prop?
![Where is the love sung by The Black Eye Peas recreated in a tunnel underpass.](https://proxy-prod.omnivore-image-cache.app/2000x1333,s26q4lqLPqkZI3s4R-g30Fqa9bmslwGSLqHbqRqvKgwc/https://images.unsplash.com/photo-1484069560501-87d72b0c3669?crop=entropy&cs=tinysrgb&fit=max&fm=jpg&ixid=M3wxMTc3M3wwfDF8c2VhcmNofDV8fHF1ZXN0aW9uaW5nfGVufDB8fHx8MTY5OTMyMzQ0MXww&ixlib=rb-4.0.3&q=80&w=2000)
Photo by [Emily Morter](https://unsplash.com/@emilymorter?utm%5Fsource=ghost&utm%5Fmedium=referral&utm%5Fcampaign=api-credit) / [Unsplash](https://unsplash.com/?utm%5Fsource=ghost&utm%5Fmedium=referral&utm%5Fcampaign=api-credit)
An elongated prop is a `prop` that is not consumed but it is only passed down to another component. When a component receives a `prop` from its parent and doesn't consume the `prop`, it passes the prop down to another component. This prop is called elongated prop because it has been extended.
Whenever you see a `prop` being passed down by components that neither creates nor consumes the `prop`, you have an an elongated prop (as well as prop drilling) in your code. The code snippet below is an example:
```javascript
function Profile({ user }) {
return (
<header>
<h1>This is the header</h1>
<Content user={user} />
</header>
);
}
```
`user`, in this example, is an elongated `prop` as it is neither created nor consumed by the `Profile` component. Instead, it is only passed down to the `Content` component. And that means we have extended `user` through a component that doesn't need it so that it can get to the one that does.
Now, let's revisit the example we used to illustrate prop drilling. Wait, are you thinking what I'm thinking? The `prop` that's being passed down in the prop drilling example is indeed an elongated prop, right? Yes, you've got it.
```xquery
function App() {
const [profile, setProfile] = useState({ame: 'John'});
return (
<div>
<Header profile={profile} />
</div>
);
}
function Header({ profile }) {
return (
<header>
<h1>This is the header</h1>
<Content profile={profile} />
</header>
);
}
function Content({ profile }) {
return (
<main>
<h2>Content Component</h2>
<p>{profile.name}</p>
</main>
);
}
export default App;
```
In the code above, you can observe that the `prop` passed to `Header` is created in the `App` component. Then, `Header` passes it down to its child component named `Content`. As a result, the `profile` being passed down can be considered elongated because it is passed through a component (`Header`) that neither creates nor consumes it down to the one that does.
The `Header` component passing down the `prop` it doesn't create or need is unnecessarily stretching the context of the `prop`.
Now, the question is, how do elongated props help to intuitively avoid prop drilling in React? They make it easy for you to spot `props` being used where they're are neither created nor consumed.
Rather than focusing on how to solve prop drilling, elongated props enable you to avoid it. This is because it's intuitive to recognize when a component neither creates nor consumes `props`, and that helps you to know the component is irrelevant.
But before you learn how to quickly avoid prop drilling with your understanding of elongated props, it is important that you know the main causes of prop drilling. Then you'll truly know how to avoid it without thinking about it.
## What Causes Prop Drilling?
![»What is your story?«](https://proxy-prod.omnivore-image-cache.app/2000x1500,sA8o6QjJC2cc6DWaXvdQrHJrsY7uC26GCnLTYhFTKN7E/https://images.unsplash.com/photo-1617575521317-d2974f3b56d2?crop=entropy&cs=tinysrgb&fit=max&fm=jpg&ixid=M3wxMTc3M3wwfDF8c2VhcmNofDF8fHRyaWdnZXJ8ZW58MHx8fHwxNjk5MzIzNTU2fDA&ixlib=rb-4.0.3&q=80&w=2000)
Photo by [Etienne Girardet](https://unsplash.com/@etiennegirardet?utm%5Fsource=ghost&utm%5Fmedium=referral&utm%5Fcampaign=api-credit) / [Unsplash](https://unsplash.com/?utm%5Fsource=ghost&utm%5Fmedium=referral&utm%5Fcampaign=api-credit)
Prop drilling doesn't occur out of thin air. It's a consequence of inadequate component organization, and it is not a React problem. It is a thinking or design problem.
You won't encounter an instance of prop drilling without observing one of the following layout mistakes:
==First of all,== **==grouping static elements and dependent components==** ==together to achieve an appealing UI design is the major cause of prop drilling. You can't avoid prop drilling when your UI groups static elements and dependent components together in a parent. The parent component clearly won't use the== `==prop==`==, as everything within it is a static element – except the component that needs a prop.==
Here's an example:
```javascript
function Header({ profile }) {
return (
<header>
<h1>This is the header</h1>
<Content profile={profile} />
</header>
);
}
```
In this case, static elements `<header> and <h1>` are grouped with a dependent component `Content` – and that's why we have prop drilling therein.
Provided that the `Content` component is independent or takes no `props`, it won't need `profile` and there won't be prop drilling in the first place. This is why forcing a component that should be independent to take `props` from its parent is a recipe for prop drilling in React.
==Second of all, when a== **==component accepts== `==props==` ==that it doesn't use but merely passes it down to its children==**==, this is a sign that you have prop drilling in your component:==
```php
function App () {
const [profile, setProfile] = useState({name: "Ayobami"})
return (
<>
<Parent profile={profile} />
</>
);
};
function Parent({ profile }) {
return (
<div>
<Hero profile={profile} />
<Features profile={profile} />
</div>
);
};
```
In this case there is prop drilling because the `Parent` component takes `profile` and it doesn't use it though it passes it down to its children.
==Third, when a component that represents an independent section of a page is== **==forced to take props from its parent==**==, prop drilling is inevitable. It should ideally be self-contained with its state and operations.==
The exception would be if it's intentionally tied to its parent for specific reasons. In such cases, prop drilling becomes a necessary trade-off.
If you revisit the example of prop drilling cited in this article, you will realize it has a prop drilling issue because the `Content` component which could have been an independent component by having a state is forced to receive props from its parent.
==And finally,== **==the presence of elongated== `==props==`** ==is a sure sign of prop drilling. Since an elongated prop is a fundamental element that's consistently present in every case of prop drilling, grasping this concept allows you to instinctively avoid prop drilling.==
When you spot an elongated prop, you can be certain that one of the other three mistakes is also in play. In short, an elongated prop is a prop that is not consumed and is also passed down to another component.
So grouping static elements with dependent components, forcing components to take props, elongated props, and receiving a prop without consuming it are the signs to recognize prop drilling in React.
## How to Fix Prop Drilling with Component Composition
==Component composition is a good approach to fix prop drilling. If you ever find yourself in a situation where a component passes down a prop it neither creates nor consumes, you can use component composition to fix it.==
But to use component composition, you need to understand a component context.
### What is a component context? ‌
The context of a component encompasses everything that is visible within it, including state, props, and children. The following code further illustrates this concept:
```javascript
function App() {
const [profile, setProfile] = useState({name: 'Ayobami'});
return (
<div>
<Header profile={profile} />
</div>
);
}
export default App;
```
In this scenario, the context of `App` refers to everything we can see within the `App` component – including the `profile` prop, the `Header`, and other `App` content. Therefore, any data created in the `App` component should ideally be utilized within the `App` component itself, either as its own data or as `props` to its children.
Prop drilling always emerges when the children receiving the `props` doesn't consume it but only passes it down to its children.
==To avoid prop drilling in this case, any grandchildren components that require access to the same== `==props==`==, especially when their parent don't consume the data, should be passed as children ensuring that the data remains within the== `==App==` ==context.==
```javascript
export function App() {
const [profile, setProfile] = useState({name: 'Ayobami'});
return (
<div>
<Header>
<Content profile={profile} />
</Header>
</div>
);
}
```
**`Or`**
```javascript
export function App() {
const [profile, setProfile] = useState({name: 'Ayobami'});
return (
<div>
<Header children={<Content profile={profile} />} >
</div>
);
}
```
As you can see, we have resolved the prop drilling issue in the previous example, even though we still have a redundant component, `<Header>`, right? We've successfully addressed prop drilling through component composition.
This process is quite straightforward because we concentrate on recognizing elongated props and repositioning them within appropriate contexts.
The concept of prop drilling is problem-focused, but prop elongation is solution-driven. When dealing with elongated props, our primary goal is to identify props that are not consumed but only passed down to another components.
## How to Fix Prop Drilling by Moving State to the Consumer
==Prop drilling can also be fixed by moving state to where it is consumed. The example of prop drilling in this article has a component named== `==Content==`==. But the component is forced to receive a== `==prop==` ==from its parent instead of having a state and be an independent component – and so we have prop drilling.==
We can fix the prop drilling in this case by moving the profile state to where it is consumed.
Let's revisit the example:
```xquery
function App() {
const [profile, setProfile] = useState({ame: 'John'});
return (
<div>
<Header profile={profile} />
<Footer profile={profile />
</div>
);
}
function Header({ profile }) {
return (
<header>
<h1>This is the header</h1>
<Content profile={profile} />
</header>
);
}
function Content({ profile }) {
return (
<main>
<h2>Content Component</h2>
<p>{profile.name}</p>
</main>
);
}
export default App;
```
We can fix prop drilling in this case by moving `profile` to where it is consumed:
```javascript
function App() {
return (
<div>
<Header />
<Footer profile={profile />
</div>
);
}
function Header() {
return (
<header>
<h1>This is the header</h1>
<Content />
</header>
);
}
function Content({ profile }) {
const [profile, setProfile] = useState({ame: 'John'});
return (
<main>
<h2>Content Component</h2>
<p>{profile.name}</p>
</main>
);
}
```
Now that we have lifted the profile to the `Content` component where it is consumed, the `App` component doesn't have a state, while the `Header` component doesn't receive a prop again as the `Content` component has its state.
But wait! There is a problem. The `Footer` component needs the state we moved away from `App`. There you are! That is the problem with lifting or moving state to where we think it is needed. In this case, if the `Footer` component doesn't need it, we won't have any issue – but `Footer` also needs the prop.
Now that `Footer` needs `profile` as a prop, we need to solve prop drilling with another method.
## How to Fix Prop Drilling with a Children-Replacing-Parent Strategy
Earlier in this article, we talked about how to use component composition and moving state to its consumer to solve prop drilling. But as you saw, they have some issues – duplicated components or states.
But using this children-replacing-parent approach fixes the problem effectively:
****Working but could be better:**
```xquery
export function App() {
const [profile, setProfile] = useState({name: 'Ayobami'});
return (
<div>
<Header>
<Content profile={profile} />
</Header>
</div>
);
}
function Header({ profile }) {
return (
<header>
<h1>This is the header</h1>
<Content profile={profile} />
</header>
);
}
```
The example above shows a solution to the prop drilling example in this article. But as you can see, it has a redundant component, as `Header` does nothing.
**Here's a better version:**
```javascript
export function App() {
const [profile, setProfile] = useState({name: 'Ayobami'});
return (
<header>
<h1>This is the header</h1>
<Content profile={profile} />
</header>
);
}
```
In the above code, we enhance the component composition solution we previously implemented for the prop drilling example by replacing the redundant `Header` component with its content in its parent (`App`).
## What to Avoid
![photo-1587065915399-8f8c714ab540?crop=entropy&cs=tinysrgb&fit=max&fm=jpg&ixid=M3wxMTc3M3wwfDF8c2VhcmNofDEwfHxkYW5nZXJ8ZW58MHx8fHwxNjk5MzIzMDgxfDA&ixlib=rb-4.0](https://proxy-prod.omnivore-image-cache.app/2000x1333,svvd90JJPHx2cRZ_A6-9SXg8LuqQJ_kGlJbtNXwk4tTc/https://images.unsplash.com/photo-1587065915399-8f8c714ab540?crop=entropy&cs=tinysrgb&fit=max&fm=jpg&ixid=M3wxMTc3M3wwfDF8c2VhcmNofDEwfHxkYW5nZXJ8ZW58MHx8fHwxNjk5MzIzMDgxfDA&ixlib=rb-4.0.3&q=80&w=2000)
Photo by [Edwin Hooper](https://unsplash.com/@edwinhooper?utm%5Fsource=ghost&utm%5Fmedium=referral&utm%5Fcampaign=api-credit) / [Unsplash](https://unsplash.com/?utm%5Fsource=ghost&utm%5Fmedium=referral&utm%5Fcampaign=api-credit)
==It's essential to highlight what to avoid when dealing with prop drilling to prevent unnecessary challenges.==
* **==Avoid React Context, if possible, to fix prop drilling.==** ==This approach ties your component to a specific context, restricting its usability outside of that context and hindering composition and reusability.==
* **==Steer clear of redundant components by employing a children-parent replacement approach.==** ==This approach naturally incorporates== ==[component composition](https://www.codementor.io/@dinerismail/the-power-of-component-composition-in-react-21goassg4m)== ==without introducing redundant components or states when resolving prop drilling.==
By avoiding elongated props, you pave the way for crafting maintainable, high-performing, reusable, and scalable React components. It simplifies the process of lifting states and components by removing the struggle of deciding where to place them.
With your understanding of elongated props, you can confidently position props and components within the right context without undue stress.
In short, you can now discover prop drilling intuitively by paying attention to any component that takes `props` it doesn't consume and only passes it down to another component.
Thanks for reading – cheers!
Hey wait! I am [Ayobami Ogundiran](https://twitter.com/codingnninja) and I am about to start showing how to build your own React, Redux, TypeScript, Zod or Ecommerce websites on my YouTube channel. [Click to subscribe](https://youtube.com/youtoocancode) to stay connected.
---
---
Learn to code for free. freeCodeCamp's open source curriculum has helped more than 40,000 people get jobs as developers. [Get started](https://www.freecodecamp.org/learn/)

23
Read Later/How to Learn Rust.md Normal file
View file

@ -0,0 +1,23 @@
---
id: 9f0419b3-2f89-4734-96b3-55aa984414ac
title: |
How to Learn Rust
status: READING
tags:
- read-later
- Youtube
date_added: 2023-10-12 17:55:48
url_omnivore: |
https://omnivore.app/me/how-to-learn-rust-18b25ac93bb
url_original: |
https://www.youtube.com/watch?v=2hXNd6x9sZs
---
# How to Learn Rust
---
## Original
[How to Learn Rust](https://www.youtube.com/watch?v=2hXNd6x9sZs)
By [No Boilerplate](https://www.youtube.com/@NoBoilerplate)

395
Read Later/How to Write Components that Work in Any Framework.md Normal file
View file

@ -0,0 +1,395 @@
---
id: 616d5d08-7d04-11ee-8eaa-9f56108b78ec
title: |
How to Write Components that Work in Any Framework
status: ARCHIVED
tags:
- read-later
- RSS
date_added: 2023-11-06 17:25:12
url_omnivore: |
https://omnivore.app/me/how-to-write-components-that-work-in-any-framework-18ba72d0079
url_original: |
https://www.freecodecamp.org/news/write-components-that-work-in-any-framework/
---
# How to Write Components that Work in Any Framework
## Highlights
> [!quote] ㅤ
> With Custom Elements you can author your own custom HTML elements that you can reuse across your site. They can be as simple as text, images, or visual decorations. You can push them further and build interactive components, complex widgets, or entire web applications.
>
> [source](https://omnivore.app/me/how-to-write-components-that-work-in-any-framework-18ba72d0079#bceef8c0-728e-422a-aed6-b047736cb395)
> > [!quote] ㅤ
> ### Writing a web component requires understanding all of its underlying technologies
>
> As we saw above, web components are made up of three technologies. You can also see in the hello world code snippet, that we explicitly need to know and understand these three technologies.
>
> 1. We’re creating a **template element** and setting its inner HTML
> 2. We’re creating a **shadow root**, and explicitly setting its mode to ‘open’.
> 3. We’re cloning our **template** and appending it to our **shadow root**
> 4. We’re registering a new **custom element** to the document
>
> [source](https://omnivore.app/me/how-to-write-components-that-work-in-any-framework-18ba72d0079#46fc130a-1549-40c8-b950-42035c227bc4)
> > [!quote] ㅤ
> As web component authors, we need to consider a lot of things:
>
> * Setting up the shadow DOM
> * Setting up the HTML templates
> * Cleaning up event listeners
> * Defining properties that we want to observe
> * Reacting to properties when they change
> * Handling type conversions for attributes
>
> [source](https://omnivore.app/me/how-to-write-components-that-work-in-any-framework-18ba72d0079#855f444c-49f1-4176-9537-aaeeb6a01355)
> > [!quote] ㅤ
> One such tool is called Lit, which is developed by a team at Google. [Lit](https://lit.dev/) is a lightweight library designed to make writing web components simple, by removing the need for the boilerplate we’ve already seen above.
>
> [source](https://omnivore.app/me/how-to-write-components-that-work-in-any-framework-18ba72d0079#385d9ef8-13fb-4799-bff5-ef767b3df67f)
> ---
## Original
![How to Write Components that Work in Any Framework](https://proxy-prod.omnivore-image-cache.app/1200x600,sbNnkMyaVUIiiSYXNfn_YVuWBIhu0N84ey_fbF6pQlVw/https://www.freecodecamp.org/news/content/images/size/w2000/2023/11/og-button.png)
The browser has a built-in way of writing reusable components in the form of **web components**. They’re an excellent choice for building interactive and reusable components that work in any frontend framework.
With that said, writing highly interactive and robust web components isn’t simple. They require a lot of boilerplate and feel much less intuitive than the components you may have written in frameworks like React, Svelte, or Vue.
In this tutorial, I’ll give you an example of an interactive component written as a web component, and then refactor it using a library that softens the edges and removes heaps of boilerplate.
Don’t sweat it if you’re not familiar with web components. In the next section, I’ll do a (brief) overview of what web components are, and what they’re made out of. If you have some basic experience with them, you can skip the next section.
## What are Web Components?
Before web components, the browser didn’t have a standard way of writing reusable components. Many libraries solve this problem, but they often run into limitations like performance, interoperability, and issues with web standards.
Web components are a technology made up of 3 different browser features:
* Custom elements
* Shadow DOM
* HTML Templates
We’ll do a quick crash course covering these technologies, but it’s by no means a comprehensive breakdown.
### What are Custom Elements?
==With Custom Elements you can author your own custom HTML elements that you can reuse across your site. They can be as simple as text, images, or visual decorations. You can push them further and build interactive components, complex widgets, or entire web applications.==
You’re not just limited to using them in your projects, but you can publish them and allow other developers to use them on their sites.
Here are some of the reusable components from my library [A2K](https://a2000-docs.netlify.app/). You can see that they come in all shapes and sizes, and have a range of different functionalities. Using them in your projects is similar to using any old HTML element.
![A small collection of web components from the A2K library](https://proxy-prod.omnivore-image-cache.app/1936x1576,sJHqJR3aX72y4hbKfS4SGGmJwoFGcBRrCJxB2ozU2rIU/https://www.freecodecamp.org/news/content/images/2023/11/web-components.png)
A small collection of web components from the A2K library
Here’s how you’d use the progress element in your project:
```xml
<!DOCTYPE html>
<html>
<head>
<title>Quick Start</title>
<meta charset="UTF-8" />
</head>
<body>
<!-- Use web components in your HTML like regular built-in elements. -->
<a2k-progress progress="50" />
<!-- a2k web components use standard JavaScript modules. -->
<script type="module">
import 'https://cdn.jsdelivr.net/npm/@a2000/progress@0.0.5/lib/src/a2k-progress.js';
</script>
</body>
</html>
```
Once you’ve imported the third-party scripts, you can start using the component, `a2k-progress` in this case, just like any other HTML element.
If you’re building your own web components, there’s virtually no limit to how complex you can make your custom elements.
I recently created a web component that renders a CodeSandbox code editor in the browser. And because it’s a web component, you can use it in any framework you like! If you’d like to learn a little more about that, [you can read more here](https://component-odyssey.com/articles/00-sandpack-lit-universal).
### What is the Shadow DOM?
If you have a working knowledge of CSS, you’ll know that vanilla CSS is scoped globally. Writing something like this in your global.css:
```css
p {
color: tomato;
}
```
will give all `p` elements a nice orange/red color, assuming that no other, more specific CSS selectors are applied to a `p` element.
Take this select menu, for example:
![A select menu component with a visual design reminiscent of the old Windows operating systems](https://proxy-prod.omnivore-image-cache.app/1034x502,s9CkMnQ9nLrjRpsbeELOUs7SesB_nfO2NrbzcalU2UFE/https://www.freecodecamp.org/news/content/images/2023/11/a2k-select-menu.png)
It has a distinct character which is driven by the visual design. You might want to use this component, but if your global styles affect things like the font family, the color, or the font size, it could cause issues with the appearance of the component:
```xml
<head>
<style>
body {
color: blue;
font-size: 12px;
font-family: system-ui;
}
</style>
</head>
<body>
<a2k-select></a2k-select>
</body>
```
![The same select menu, but with a lot of its defining characteristics overridden by global CSS.](https://proxy-prod.omnivore-image-cache.app/1904x824,s6vwLXZ-23v_oU3NRFu4pagLJRfGUCz14nw0IkGnQuPU/https://www.freecodecamp.org/news/content/images/2023/11/a2k-select-menu-2.png)
This is where the Shadow DOM comes in. The Shadow DOM is an encapsulation mechanism that prevents the rest of the DOM from interfering with your web components. It ensures that the global styles of the web application don’t interfere with any components that you consume. It also means that component library developers can author their components with the confidence that they’ll look and behave as expected across different web applications.
There’s a lot more nuance when it comes to the Shadow DOM, as well as other features that we’re not going to touch on in this article. If you’d like to learn more about web components though, I have an entire course ([Component Odyssey](https://component-odyssey.com/)) dedicated to teaching you how to build reusable components that work in any framework.
### HTML Templates
The last feature in our whistle-stop tour of web component features is HTML Templates.
What makes this HTML element different from other elements, is that the browser doesn’t render its content to the page. If you were to write the following HTML you wouldn’t see the text “I’m a header” displayed on the page:
```xml
<body>
<template>
<h1>I'm a header</h1>
</template>
</body>
```
Instead of being used to render the content directly, the content of the template is designed to be copied. The copied template can then be used to render content to the page.
You can think of the template element much like the template for a 3D print. The template isn’t a physical entity, but it’s used to create real-life clones.
You would then reference the template element in your web component, clone it, and render the clone as the markup for your component.
I won’t spend any more time on these web component features, but you’ve probably already noticed that to write vanilla web components, there are a lot of new browser features that you need to know and understand.
You’ll see in the next section that the mental model for building web components doesn’t feel as streamlined as it does for other component frameworks.
## How to Build a Basic Web Component
Now that we’ve briefly covered the fundamental technologies powering a web component, here’s how to build a _hello world_ component:
```scala
const template = document.createElement('template');
template.innerHTML = `<p>Hello World</p>`;
class HelloWorld extends HTMLElement {
constructor() {
super();
this.attachShadow({ mode: 'open' });
this.shadowRoot.append(template.content.cloneNode(true));
}
}
customElements.define('hello-world', HelloWorld);
```
This is the most simple component you can write, but there’s already so much going on. For someone completely new to web components, and without the background knowledge I provided above, they’re going to be left with a lot of questions, and a lot of confusion.
For me, there are at least two key reasons why web components can be challenging to write, at least within the context of the hello world examples.
### The markup is decoupled from the component logic
In many frameworks, the markup of the component is often treated as a first-class citizen. It’s often the content that gets returned from the component function, or has direct access to the component’s state, or has built-in utilities to help manipulate markup (like loops, conditionals, and so on).
This isn’t the case for web components. In fact, the markup is often defined outside of the component’s class. There’s also no built-in way for the template to reference the current state of the component. This becomes a cumbersome limitation as the complexity of a component grows.
In the world of frontend, components are designed to help developers reuse markup in several pages. As a result, the markup and the component logic are inextricably linked, and so they should be colocated with one another.
### ==Writing a web component requires understanding all of its underlying technologies==
==As we saw above, web components are made up of three technologies. You can also see in the hello world code snippet, that we explicitly need to know and understand these three technologies.==
1. ==We’re creating a== **==template element==** ==and setting its inner HTML==
2. ==We’re creating a== **==shadow root==**==, and explicitly setting its mode to ‘open’.==
3. ==We’re cloning our== **==template==** ==and appending it to our== **==shadow root==**
4. ==We’re registering a new== **==custom element==** ==to the document==
There’s nothing inherently wrong with this, since web components are supposed to be a “lower-level” browser API, making them prime for building abstractions on top of. But for a developer coming from a React or a Svelte background, having to understand these new browser features, and then having to write components with them can feel like too much friction.
## More Advanced Web Components
Let’s take a look at a more advanced web component, a counter button.
![A simple counter button. There's a clickable button, and some text showing how many times the button has been clicked](https://proxy-prod.omnivore-image-cache.app/388x228,sHWCz4gELDISUuDwuoPIHQHGqCm0zEx5YHunEIzF9BE0/https://www.freecodecamp.org/news/content/images/2023/11/counter-button.png)
You click the button, and the counter increments.
The following example contains a few extra web component concepts, like lifecycle functions and observable attributes. You don’t need to understand everything going on in the code snippet. This example is really only used to illustrate how much boilerplate is required for the most basic of interactive interfaces, a counter button:
```kotlin
const templateEl = document.createElement("template");
templateEl.innerHTML = `
<button>Press me!</button>
<p>You pressed me 0 times.</p>
`;
export class OdysseyButton extends HTMLElement {
constructor() {
super();
this.attachShadow({ mode: "open" });
this.shadowRoot.appendChild(templateEl.content.cloneNode(true));
this.button = this.shadowRoot.querySelector("button");
this.p = this.shadowRoot.querySelector("p");
this.setAttribute("count", "0");
}
// Note: Web components have lifecycle methods,
// If we're setting event listeners when the component is added to the DOM, it's our job to clean
// them up when it gets removed from the DOM
connectedCallback() {
this.button.addEventListener("click", this.handleClick);
}
disconnectedCallback() {
this.button.removeEventListener("click", this.handleClick);
}
// Unlike frameworks like React, Web Components don't automatically rerender when a prop (or attribute)
// changes. Instead, we need to explicitly define which attributes we want to observe.
static get observedAttributes() {
return ["disabled", "count"];
}
// When one of the above attributes changes, this lifecycle method runs, and we can
// react to the new attribute's value accordingly.
attributeChangedCallback(name, _, newVal) {
if (name === "count") {
this.p.innerHTML = `You pressed me ${newVal} times.`;
}
if (name === "disabled") {
this.button.disabled = true;
}
}
// In HTML, attribute values are always strings. This means that it's our job to
// convert types. You can see below that we're converting a string -> number, and then back to a string
handleClick = () => {
const counter = Number(this.getAttribute("count"));
this.setAttribute("count", `${counter + 1}`);
};
```
==As web component authors, we need to consider a lot of things:==
* ==Setting up the shadow DOM==
* ==Setting up the HTML templates==
* ==Cleaning up event listeners==
* ==Defining properties that we want to observe==
* ==Reacting to properties when they change==
* ==Handling type conversions for attributes==
And there are still so many other things to consider that I haven’t touched on in this article.
That isn’t to say that web components are bad and that you shouldn’t write them. In fact, I’d argue that you learn so much about the browser platform by building with them.
But I feel that there are better ways to write components if your priority is to write interoperable components in a much more streamlined and ergonomic way.
## How to Write Web Components with Less Boilerplate
As I mentioned earlier, there are a lot of tools out there to help make writing web components much easier.
==One such tool is called Lit, which is developed by a team at Google.== ==[Lit](https://lit.dev/)== ==is a lightweight library designed to make writing web components simple, by removing the need for the boilerplate we’ve already seen above.==
As we’ll see, Lit does a lot of heavy lifting under-the-hood to help cut down the total lines of code by nearly half! And because Lit is a wrapper around web components and other native browser features, all your existing knowledge about web components is transferable.
To start seeing how Lit simplifies your web components. Here’s the **hello world** example from earlier, but refactored to use Lit instead of a vanilla web component:
```scala
import { LitElement, html } from "lit";
export class HelloWorld extends LitElement {
render() {
return html`<p>Hello World!</p>`;
}
}`
customElements.define('hello-world', HelloWorld);
```
There’s a lot less boilerplate with the Lit component, and Lit handles the two problems I mentioned earlier, a little bit differently. Let’s see how:
1. The markup is directly defined from within the component class. While you can define your templates outside of the class, it’s common practice to return the template from the `render` function. This is more in line with the mental model presented in other UI frameworks, where the UI is a function of the state.
2. Lit also doesn’t require developers to attach the shadow DOM, or create templates and clone template elements. While having an understanding of the underlying web component features will help when developing Lit components, they’re not required for getting started, so the barrier for entry is much lower.
So now for the big finale, what does the counter component look like once we’ve migrated it over to Lit?
```typescript
import { LitElement, html } from "lit";
export class OdysseyCounter extends LitElement {
static properties = {
// We define the component's properties as well as their type.
// These properties will trigger the component to re-render when their values change.
// While they're not the same, you can think of these "properties" as being
// Lit's alternatives to "observed attributes"
// If the value is passed down as an attribute, Lit converts the value
// to the correct type
count: { type: Number },
disabled: { type: Boolean },
};
constructor() {
super();
// There's no need to create a shadow DOM, clone the template,
// or store references to our DOM nodes.
this.count = 0;
}
onCount() {
this.count = this.count + 1;
}
render() {
// Instead of using the attributeChangedCallback lifecycle, the
// render function has access to all of the component's properties,
// which simplifies the process of manipulating our templates.
return html`
<button ?disabled=${this.disabled} @click=${this.onCount}>
Press me!
</button>
<p>You pressed me ${this.count} times.</p>
`;
}
}`
```
The amount of code we’re writing is cut down by almost half! And this difference becomes more noticeable when creating more complex user interfaces.
## Why am I going on about Lit?
I’m a big believer in web components, but I recognise that the barrier to entry is high for many developers. Writing complex web components requires understanding heaps of browser features and the education around web components isn’t as comprehensive as other technologies, like React or Vue.
This is why I think it’s important to use tools like Lit can make writing performant and interoperable web components much easier. This is great if you want your components to work within any frontend framework.
If you’d like to learn even more, this is the approach I teach in my upcoming course [Component Odyssey](https://component-odyssey.com/). This course is excellent for anyone who wants to understand how to write components that work in any framework.
I do this by covering the absolute basics of web components, before moving on to tools like Lit that simplify the process of writing web components without complicating your development environment. By the end, you’ll learn how to build and publish a component library that works across any frontend framework.
If you want early-bird discount codes for Component Odyssey, then head on [over to the site to get notified](https://component-odyssey.com/subscribe).
---
---
Learn to code for free. freeCodeCamp's open source curriculum has helped more than 40,000 people get jobs as developers. [Get started](https://www.freecodecamp.org/learn/)

68
Read Later/Let's Get Webby! 🦀 🕸️.md Normal file
View file

@ -0,0 +1,68 @@
---
id: 46eadaec-733a-11ee-aae2-4b1c5b8d8405
title: |
Let's Get Webby! 🦀 🕸️
status: ARCHIVED
tags:
- read-later
- Newsletter
date_added: 2023-10-25 10:27:43
url_omnivore: |
https://omnivore.app/me/let-s-get-webby-18b6705008a
url_original: |
https://omnivore.app/no_url?q=bec70357-3199-44e0-9c84-40dd5a7bf774
---
# Let's Get Webby! 🦀 🕸️
## Highlights
> [!quote] ㅤ
> ...and front-end frameworks like [Yew](https://letsgetrusty.krtra.com/c/y9r3LFJzeRCp/OQKy) and [Seed](https://letsgetrusty.krtra.com/c/mN30voJhWLXc/OQKy) letting you write web apps in Rust!
>
> [source](https://omnivore.app/me/let-s-get-webby-18b6705008a#7065ade5-765c-4d60-bd89-1ecb0d919389)
>
>
>> [!info] ㅤ
>> I can create front end web apps with this libraries
---
## Original
![](https://proxy-prod.omnivore-image-cache.app/0x0,s4bBfm-ltnUNFUa4ETTgSxP2wMeHZVVuOj5N9oi2Ba2I/https://kartrausers.s3.amazonaws.com/letsgetrusty/25597207_1643064007NFuWebsite_Header.png)
Hey Alexander,
JavaScript isn't the fastest language out there.
In fact, it's **pretty dang slow** compared to C/C++!
Unfortunately, this limits the type of web apps we could build.
How great would it be if we could write code that runs **at native speeds** in the browser?
This would allow computationally intensive apps like video editors, AAA games, and IDEs to be run in the browser!
Great news... **this is possible today** with the help of WebAssembly.
WebAssembly or WASM for short, is a technology that allows code written in languages such as C/C++, Java, Swift, and Rust to run in the browser at native speeds!
**And Rust has first-class support for WASM!**
With crates such as [wasm-bindgen ](https://letsgetrusty.krtra.com/c/Fv1n9JiwhxdT/OQKy)facilitating high-level interactions between Rust and JavaScript...
==...and front-end frameworks like== ==[Yew](https://letsgetrusty.krtra.com/c/y9r3LFJzeRCp/OQKy)== ==and== ==[Seed](https://letsgetrusty.krtra.com/c/mN30voJhWLXc/OQKy)== ==letting you write web apps in Rust!==
Are you ready to give Rust + WASM a try?
Check out this video I made: **[\>> Building a Rust App with Yew! <<](https://letsgetrusty.krtra.com/c/6AUVThScIsa4/OQKy)**
Have you built any WASM projects in Rust? Let me know!
Stay Rusty my friend!
Bogdan, Let's Get Rusty
**[Website](https://letsgetrusty.krtra.com/c/FBKvcPOtTzlF/OQKy)** | **[YouTube](https://letsgetrusty.krtra.com/c/4KIGD3ocszdT/OQKy)**
© Copyrights by Let's Get Rusty. All Rights Reserved.

72
Read Later/Study shows stronger brain activity after writing on paper than on tablet or smartphone - Science....md Normal file
View file

@ -0,0 +1,72 @@
---
id: bcb6f4ba-cb8e-4e8d-847f-911cda184b83
title: |
Study shows stronger brain activity after writing on paper than on tablet or smartphone | ScienceDaily
status: ARCHIVED
tags:
- read-later
date_added: 2023-10-23 10:56:32
url_omnivore: |
https://omnivore.app/me/study-shows-stronger-brain-activity-after-writing-on-paper-than--18b5cd2abed
url_original: |
https://www.sciencedaily.com/releases/2021/03/210319080820.htm
---
# Study shows stronger brain activity after writing on paper than on tablet or smartphone | ScienceDaily
## Highlights
> [!quote] ㅤ
> "Our take-home message is to use paper notebooks for information we need to learn or memorize," said Sakai.
>
> [source](https://omnivore.app/me/study-shows-stronger-brain-activity-after-writing-on-paper-than--18b5cd2abed#1c9a0a5a-c3a9-40d8-a6de-9e986dd27aec)
> > [!quote] ㅤ
> Researchers say that personalizing digital documents by highlighting, underlining, circling, drawing arrows, handwriting color-coded notes in the margins, adding virtual sticky notes, or other types of unique mark-ups can mimic analog-style spatial enrichment that may enhance memory.
>
> [source](https://omnivore.app/me/study-shows-stronger-brain-activity-after-writing-on-paper-than--18b5cd2abed#85a6ad74-1b87-4f32-95b3-f0a549d32089)
> > [!quote] ㅤ
> Although the current research focused on learning and memorization, the researchers encourage using paper for creative pursuits as well.
>
> "It is reasonable that one's creativity will likely become more fruitful if prior knowledge is stored with stronger learning and more precisely retrieved from memory. For art, composing music, or other creative works, I would emphasize the use of paper instead of digital methods," said Sakai.
>
> [source](https://omnivore.app/me/study-shows-stronger-brain-activity-after-writing-on-paper-than--18b5cd2abed#aeb79efa-7582-4493-94e1-6a7004b5ed80)
> ---
## Original
FULL STORY
---
A study of Japanese university students and recent graduates has revealed that writing on physical paper can lead to more brain activity when remembering the information an hour later. Researchers say that the unique, complex, spatial and tactile information associated with writing by hand on physical paper is likely what leads to improved memory.
"Actually, paper is more advanced and useful compared to electronic documents because paper contains more one-of-a-kind information for stronger memory recall," said Professor Kuniyoshi L. Sakai, a neuroscientist at the University of Tokyo and corresponding author of the research recently published in _Frontiers in Behavioral Neuroscience_. The research was completed with collaborators from the NTT Data Institute of Management Consulting.
Contrary to the popular belief that digital tools increase efficiency, volunteers who used paper completed the note-taking task about 25% faster than those who used digital tablets or smartphones.
Although volunteers wrote by hand both with pen and paper or stylus and digital tablet, researchers say paper notebooks contain more complex spatial information than digital paper. Physical paper allows for tangible permanence, irregular strokes, and uneven shape, like folded corners. In contrast, digital paper is uniform, has no fixed position when scrolling, and disappears when you close the app.
"Our take-home message is to use paper notebooks for information we need to learn or memorize," said Sakai.
In the study, a total of 48 volunteers read a fictional conversation between characters discussing their plans for two months in the near future, including 14 different class times, assignment due dates and personal appointments. Researchers performed pre-test analyses to ensure that the volunteers, all 18-29 years old and recruited from university campuses or NTT offices, were equally sorted into three groups based on memory skills, personal preference for digital or analog methods, gender, age and other aspects.
Volunteers then recorded the fictional schedule using a paper datebook and pen, a calendar app on a digital tablet and a stylus, or a calendar app on a large smartphone and a touch-screen keyboard. There was no time limit and volunteers were asked to record the fictional events in the same way as they would for their real-life schedules, without spending extra time to memorize the schedule.
After one hour, including a break and an interference task to distract them from thinking about the calendar, volunteers answered a range of simple (When is the assignment due?) and complex (Which is the earlier due date for the assignments?) multiple choice questions to test their memory of the schedule. While they completed the test, volunteers were inside a magnetic resonance imaging (MRI) scanner, which measures blood flow around the brain. This is a technique called functional MRI (fMRI), and increased blood flow observed in a specific region of the brain is a sign of increased neuronal activity in that area.
Participants who used a paper datebook filled in the calendar within about 11 minutes. Tablet users took 14 minutes and smartphone users took about 16 minutes. Volunteers who used analog methods in their personal life were just as slow at using the devices as volunteers who regularly use digital tools, so researchers are confident that the difference in speed was related to memorization or associated encoding in the brain, not just differences in the habitual use of the tools.
Volunteers who used analog methods scored better than other volunteers only on simple test questions. However, researchers say that the brain activation data revealed significant differences.
Volunteers who used paper had more brain activity in areas associated with language, imaginary visualization, and in the hippocampus -- an area known to be important for memory and navigation. Researchers say that the activation of the hippocampus indicates that analog methods contain richer spatial details that can be recalled and navigated in the mind's eye.
"Digital tools have uniform scrolling up and down and standardized arrangement of text and picture size, like on a webpage. But if you remember a physical textbook printed on paper, you can close your eyes and visualize the photo one-third of the way down on the left-side page, as well as the notes you added in the bottom margin," Sakai explained.
Researchers say that personalizing digital documents by highlighting, underlining, circling, drawing arrows, handwriting color-coded notes in the margins, adding virtual sticky notes, or other types of unique mark-ups can mimic analog-style spatial enrichment that may enhance memory.
Although they have no data from younger volunteers, researchers suspect that the difference in brain activation between analog and digital methods is likely to be stronger in younger people.
"High school students' brains are still developing and are so much more sensitive than adult brains," said Sakai.
Although the current research focused on learning and memorization, the researchers encourage using paper for creative pursuits as well.
"It is reasonable that one's creativity will likely become more fruitful if prior knowledge is stored with stronger learning and more precisely retrieved from memory. For art, composing music, or other creative works, I would emphasize the use of paper instead of digital methods," said Sakai.

286
Read Later/The Complete Guide to Time Blocking.md Normal file
View file

@ -0,0 +1,286 @@
---
id: 04745848-2b0d-482d-802c-8872ac9043dd
title: |
The Complete Guide to Time Blocking
status: ARCHIVED
tags:
- read-later
date_added: 2023-11-10 23:43:20
url_omnivore: |
https://omnivore.app/me/https-todoist-com-productivity-methods-time-blocking-18bbc432143
url_original: |
https://todoist.com/productivity-methods/time-blocking
---
# The Complete Guide to Time Blocking
## Highlights
> [!quote] ㅤ
> Time blocking is a time management method that asks you to divide your day into blocks of time. Each block is dedicated to accomplishing a specific task or group of tasks, and only those specific tasks. Instead of keeping an open-ended to-do list of things you’ll get to as you can, you’ll start each day with a concrete schedule outlining what you’ll work on and when.
>
> [source](https://omnivore.app/me/https-todoist-com-productivity-methods-time-blocking-18bbc432143#6ca022ff-400a-4f70-8031-1a3caa0e7246)
> > [!quote] ㅤ
> With days that are time blocked in advance, you won’t have to constantly make choices about what to focus on.
>
> [source](https://omnivore.app/me/https-todoist-com-productivity-methods-time-blocking-18bbc432143#21fb5ecc-b00e-4f14-8d60-84eec666e8a9)
> > [!quote] ㅤ
> Task batching is when you group similar (usually smaller) tasks together and schedule specific time blocks to complete all at once. By tackling similar tasks in a group, you’ll limit the amount of context switching you have to do throughout your day, saving precious time and mental energy.
>
> [source](https://omnivore.app/me/https-todoist-com-productivity-methods-time-blocking-18bbc432143#ce3acd05-a296-4204-acfe-e0822f8a83d2)
> > [!quote] ㅤ
> Instead of setting aside time blocks for each area of responsibility each day, day theming dedicates a full day each week to each responsibility.
>
> [source](https://omnivore.app/me/https-todoist-com-productivity-methods-time-blocking-18bbc432143#5d5543a9-0d8d-42ed-aa24-4ecfeb07d6ac)
> > [!quote] ㅤ
> time boxing asks you to limit how much time you'll dedicate to a specific task.
>
> [source](https://omnivore.app/me/https-todoist-com-productivity-methods-time-blocking-18bbc432143#e342c6ce-607b-4482-af54-4ffbf81ab7ab)
>
>
>> [!info] ㅤ
>> Is _"I'm gonna finish this in X time"_, instead of _"I'm gonna work on this for X time"_
---
## Original
...and its cousins task batching and day theming. Control your schedule so it doesn't control you
![Reclaim your time for what's really important](https://proxy-prod.omnivore-image-cache.app/1767x594,sevTrAHV9fJImNQEbnGn-K5DXDzxCWsIVQpJMxn27ujU/https://res.cloudinary.com/imagist/image/fetch/q_auto/f_auto/c_scale,w_2624/https%3A%2F%2Fimages.ctfassets.net%2Fdm4oa8qtogq0%2F6AFP2nxT96WMwhBqWkPxgk%2F7ba4da3fd238b309a92741ffd430d0b7%2FTimeboxing.png)
1. [What is time blocking?](#what-is-time-blocking)
2. [Time blocking variations](#time-blocking-variations)
3. [Why is time blocking so effective?](#why-is-time-blocking-so-effective)
4. [But will time blocking work with my job?](#but-will-time-blocking-work-with-my-job)
5. [Some common time blocking missteps and how to avoid them](#some-common-time-blocking-missteps-and-how-to-avoid-them)
6. [Time blocking with Todoist](#time-blocking-with-todoist)
---
> "A 40 hour time-blocked work week, I estimate, produces the same amount of output as a 60+ hour work week pursued without structure."
>
> — Cal Newport, Author of _Deep Work_
If there's one thing that can be said about the modern workplace, it's this: If you don't control your schedule, it will control you.
How do you balance the necessary evils of meetings, email, team chat, and "busy work" with focused time for the things you truly care about? Since becoming a digital hermit isn’t an option for most of us, we need concrete strategies to help us focus in a world designed to distract us.
That’s where time blocking comes in.
Time blocking (and its close cousins, time boxing, task batching, and day theming) is a simple yet effective way to take back control of your time.
Try time blocking if you...
* Juggle many different projects/responsibilities (Jack Dorsey used day theming to run two major companies at the same time)
* Spend too much time in “reactive mode,” responding to emails and messages
* Find their day chopped up by meetings
* Battle constant interruptions throughout the day
* Struggle to find the time and mental space for big-picture thinking
This guide will give you an overview of what time blocking, task batching, and day theming are; how a combination of these strategies can help you reclaim your schedule, and the best way to use your calendar and task manager to start time blocking yourself.
==Time blocking is a time management method that asks you to divide your day into blocks of time. Each block is dedicated to accomplishing a specific task or group of tasks, and only those specific tasks. Instead of keeping an open-ended to-do list of things you’ll get to as you can, you’ll start each day with a concrete schedule outlining what you’ll work on and when.==
The key to this method is prioritizing your task list in advance — a dedicated weekly review is a must. Take stock of what’s coming up for the week ahead, and make a rough sketch of your time blocks for each day. At the [end of every workday](https://doist.com/blog/end-work-day/?itm%5Fcampaign=time%5Fblocking&itm%5Fmedium=referral&itm%5Fsource=productivity%5Fmethods%5Fguides), review any tasks you didn’t finish — as well as any new tasks that have come in — and adjust your time blocks for the rest of the week accordingly.
==With days that are time blocked in advance, you won’t have to constantly make choices about what to focus on.== All you need to do is follow your time blocked schedule. If you get off-task or distracted, simply look at your schedule and get back to whichever task you blocked off time for.
### Dig deeper
We've written a separate, comprehensive [guide to weekly reviews](https://todoist.com/productivity-methods/weekly-review) that will walk you through how to create a routine that works for you.
## Time blocking variations
Time blocking has a few close but distinct cousins that are worth considering: task batching, day theming, and time boxing.
| **Method** | **What is it?** | **Example** |
| ------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------ |
| Time Blocking | Dividing the day into blocks of time with each block dedicated to accomplishing a specific task or activity and only that specific task or activity. | "I will write every day from 9am to 11am." |
| Task Batching | "I will answer all of my emails at 3pm." | |
| Day Theming | "Every Monday, I will focus on content creation. Every Tuesday, I will focus on content promotion. Every Wednesday, I will focus on research and ideation. Etc." | |
| Time Boxing | "I will write 1,000 words between 9am and 11am tomorrow." | |
### Task batching
==Task batching is when you group similar (usually smaller) tasks together and schedule specific time blocks to complete all at once. By tackling similar tasks in a group, you’ll limit the amount of context switching you have to do throughout your day, saving precious time and mental energy.== For example, scheduling two 20-minute blocks to process email during the day is more efficient than checking your inbox every 15 minutes.
Time blocking pairs well with task batching because it saves you from scheduling every individual task on your calendar. Just block off chunks of time each day or week for when you want to complete a certain batch of activities, e.g., email, invoicing, workouts, meetings, writing, coding, deep work, errands, meal prep.
### Day theming
Day theming is a more extreme version of task batching for people who have a lot of areas of responsibility competing for their attention. For example, an entrepreneur often has to pay attention to marketing, sales, product development, customer support, and HR all at the same time. ==Instead of setting aside time blocks for each area of responsibility each day, day theming dedicates a full day each week to each responsibility.==
Mike Vardy, founder of [Productivityist](https://productivityist.com/theming-days-made-better-dad/), uses day theming to set his overarching focus for each day. Here's how he themes his week:
Dedicating each day to a single theme creates a reliable work pattern and further limits the cognitive load of context switching. Vardy explains that theming offers mental clarity that allows him to focus on his family:
> “Knowing what the day ‘means’ to me allows me to get the things I need and want to accomplish without seeing undetermined ‘ought to do’ items on a to do list. As a result, I have less decision fatigue and even have more energy when I spend time with my kids.”
### Time boxing
Time blocking and time boxing are often confused as being synonymous, but there's an important difference. Time blocking asks you to set aside certain chunks of time to focus on a given task or activity. For example, "I will work on a first draft of my blog post from 9am to 11 am tomorrow."
In contrast, ==time boxing asks you to limit how much time you'll dedicate to a specific task.== Here's a time boxed version of the time blocking example above: "I will finish a first draft of my blog post tomorrow between 9am and 11am."
This self-imposed "time box" forces you to work efficiently because you have a limited amount of time in which to complete the task. It can be a fun way to challenge yourself and gamify your productivity.
## Why is time blocking so effective?
This technique seems simple on the surface, but has profound impacts on your capacity to get things done:
### It promotes focused “deep work”
Cal Newport, author of [Deep Work: Rules for Focused Success in a Distracted World](https://www.amazon.com/Deep-Work-Focused-Success-Distracted/dp/1455586692/ref=asc%5Fdf%5F1455586692/?tag=hyprod-20&linkCode=df0&hvadid=312741934517&hvpos=1o1&hvnetw=g&hvrand=7753978193869239626&hvpone=&hvptwo=&hvqmt=&hvdev=c&hvdvcmdl=&hvlocint=&hvlocphy=9019660&hvtargid=pla-421604508630&psc=1&tag=&ref=&adgrpid=64940825031&hvpone=&hvptwo=&hvadid=312741934517&hvpos=1o1&hvnetw=g&hvrand=7753978193869239626&hvqmt=&hvdev=c&hvdvcmdl=&hvlocint=&hvlocphy=9019660&hvtargid=pla-421604508630), is a [big proponent of time blocking](http://www.calnewport.com/blog/2013/12/21/deep-habits-the-importance-of-planning-every-minute-of-your-work-day/). He dedicates 20 minutes every evening to scheduling out the next work day:
> “Sometimes people ask why I bother with such a detailed level of planning. My answer is simple: it generates a massive amount of productivity. A 40 hour time-blocked work week, I estimate, produces the same amount of output as a 60+ hour work week pursued without structure.”
When you schedule a chunk of time to work on a single project, problem, or task, you bring all of your mental resources to bear on one thing rather than spreading your attention thin across several tasks. The more you “single task”, the more you build the mental muscles required for deep work, and the easier it becomes to stay focused.
### Dig deeper
Learn more about Newport’s approach to meaningful productivity and how to incorporate more focus into your life with [The Complete Guide to Deep Work](https://doist.com/blog/deep-work/?itm%5Fcampaign=time%5Fblocking&itm%5Fmedium=referral&itm%5Fsource=productivity%5Fmethods%5Fguides).
### It helps you knock out “shallow work” more efficiently
Shallow work is the busy work that’s [urgent but not important](https://todoist.com/productivity-methods/eisenhower-matrix) to achieving your long-term goals — think paperwork or responding to (most) emails. When you time box shallow work, you’re setting clear limits on how much time you’ll dedicate to it. Plus, grouping similar tasks together reduces the cost of context switching. By batching all of your shallow tasks together in a dedicated time block or two, you’ll be able to power through them more efficiently and protect the rest of your workday for higher-impact work.
### It makes you aware of how you spend your time
Most people are bad at time management. We are [terrible at estimating](https://en.wikipedia.org/wiki/Planning%5Ffallacy) how much time tasks will take, and we have a tendency to [overcommit our future selves](https://doist.com/blog/neuroscience-achieving-long-term-goals/?itm%5Fcampaign=time%5Fblocking&itm%5Fmedium=referral&itm%5Fsource=productivity%5Fmethods%5Fguides). Time blocking forces you to confront your current priorities and commitments and get intentional about how you spend your finite time. For each new commitment you let into your life, you’re forced to find physical space on your calendar. As a result, the opportunity cost of saying “yes” becomes more concrete, and it becomes much easier to [say “no](https://doist.com/blog/how-to-say-no/?itm%5Fcampaign=time%5Fblocking&itm%5Fmedium=referral&itm%5Fsource=productivity%5Fmethods%5Fguides).”
### It counteracts perfectionism
Fuzzy timelines are a perfectionist’s worst enemy. There’s always something to be tweaked and improved. It can be difficult to know when an open-ended project is finished, especially if you are aiming for perfection. At some point, you need to be able to say “good enough” and move on. Time boxing can help by imposing time limits on your projects. If you often prolong tasks by trying to get everything just right, set a strict time box for finishing the task and stick to it.
### It helps you follow through on your goals
In the article “[Beyond good intentions: Prompting people to make plans improves follow-through on important tasks](https://scholar.harvard.edu/files/todd%5Frogers/files/beyond%5Fgood%5Fintentions%5F-%5Fprompting%5Fpeople.pdf)” researchers Dr. Todd Rogers and Dr. Katherine L. Milkman review several studies supporting the idea that “concrete plans help people follow through on their intentions.”
From following an exercise regimen to scheduling a flu shot, people were more likely to act on their intentions when they wrote down a specific place, date, and time for the activity. Yet most people rely on vague intentions rather than concrete plans:
> “Paradoxically, people frequently underplan when they begin with strong intentions. They mistakenly believe that their strong intentions are enough to propel them to perform desired behaviors, and that belief keeps them from using strategies that could help translate intentions into actions.”
The takeaway: When you schedule your tasks and goals, you’re more likely to follow through. Time blocking forces you to make concrete plans that ensure you’re working toward your goals every day. As William Faulkner famously quipped:
> “I only write when inspiration strikes. Fortunately, it strikes at nine every morning.”
## But will time blocking work with my job?
One of the biggest criticisms of time blocking is that it doesn’t account for reactive jobs where it’s impossible to anticipate what will come in at any given moment. Is time blocking really a realistic strategy for a customer support specialist whose job is to respond to tickets? Or an account manager who needs to be available to respond to client requests?
We’d argue yes — asserting even a small amount of control over your schedule can be helpful no matter your job. Cal Newport put it this way:
> “Periods of open-ended reactivity can be blocked off like any other type of obligation. Even if you’re blocking most of your day for reactive work, for example, the fact that you’re controlling your schedule will allow you to dedicate some small blocks (perhaps at the schedule periphery) to deeper pursuits.”
When your workday is run by external forces, it’s easy to lose sight of your own goals. Time blocking can help you gain a greater sense of control over even the most unpredictable of schedules.
## Some common time blocking missteps and how to avoid them
While time blocking is pretty straightforward in theory, it can be hard to stick to in practice. Here are some tips to help you apply the method successfully (and not become a slave to your calendar in the process):
### Underestimating your time
You’ll get better at estimating how long tasks take over time, but until you’ve honed your instincts, err on the side of blocking off too much time for tasks rather than too little. Pad your schedule with extra time to complete and transition between tasks. You can even create “conditional blocks” of time you can tap into if you fall behind.
### Try these tools
Improve your sense of how long you actually spend on tasks with time trackers like [RescueTime](https://www.rescuetime.com/ref/1403570) or [Toggl](https://toggl.com/).
### Being too rigid
Things will come up and ruin your plans. But remember that your plan is a guide to help focus your attention on what’s important, not a binding contract.
Even productivity expert Cal Newport edits his plans throughout the day by crossing out original time blocks and filling them with updated plans as circumstances demand:
Newport deals with changes in his schedule by seeing it as a game:
> “This type of planning, to me, is like a chess game, with blocks of work getting spread and sorted in such a way that projects big and small all seem to click into completion with (just enough) time to spare.”
See your time blocks as a flexible way to challenge yourself, not strict tools to punish yourself when you fall short.
### Overscheduling your leisure time
Though [Elon Musk and Bill Gates](https://www.businessinsider.com/bill-gates-elon-musk-scheduling-habit-2017-8) have been said to schedule their days down to 5-minute increments, overscheduling your leisure time can be a self-defeating exercise. [Studies](https://www.washingtonpost.com/news/inspired-life/wp/2018/07/31/want-to-be-happier-stop-scheduling-your-free-time/?noredirect=on&utm%5Fterm=.c7b6c4e1f8d1) have shown that scheduling leisure activities has a “unique dampening effect” on the overall enjoyment of the activity.
Instead, you can block out time to disconnect and relax without a set plan for how you’ll spend that time. It will give you the flexibility to decide more spontaneously what you want to do-- call friends to grab a drink? Check out that new Xbox game? Read? Whatever you decide, just remember to keep at least some of your free time free.
## Time blocking with Todoist
You can implement time blocking with any tool, but in this section, we'll focus on how to use Todoist alongside your favorite calendar app — or even good, old-fashioned pen and paper. We'll cover how to implement three different time blocking variations: task batching, day theming, and scheduling individual tasks.
### Task batching variation
Strict time blocking — dedicating a time block to each individual task — can be tedious and hard to maintain over time. We recommend combining time blocking and task batching for a more streamlined system. Instead of one time block per individual task, you’ll assign a time block for each category of task you batch together. Here’s how that looks in practice:
First, decide on which broad categories of work need to be reflected in your daily or weekly schedule. For example, a freelance writer might have the following category list:
* Email
* Work admin
* Sales
* Meetings
* Research
* Writing
* Professional Development
* Yoga
* Meal prep
* Personal admin
* Reading
* Free time
Now, sit down with your favorite calendar app or paper planner and create time blocks for the coming week that reflect the times you’ll work on each category. Make sure all of your priorities and commitments are given enough space on your calendar. If you struggle to find room, you may need to start cutting down on your commitments. The end result will look something like this:
If you find it difficult to stick to your digital schedule, we recommend planning your day out on paper. A paper schedule forces you to start fresh each day and makes it easy to scribble things out and adapt as the day goes on. Plus, it's also easier to keep your paper schedule open on your desk as a visible reminder of what you had planned to focus on.
If you work at a company with shared calendars, you may find it helpful to publicly block off time for “Deep Work” to keep a sufficient chunk of the day meeting free. Khoi Vinh, a [Principal Designer at Adobe](https://doist.com/blog/how-khoi-vinh-gets-things-done/?itm%5Fcampaign=time%5Fblocking&itm%5Fmedium=referral&itm%5Fsource=productivity%5Fmethods%5Fguides), uses this strategy at his office:
> “I look for blocks of time on my calendar that I can cordon off for “deep work”. Sometimes I’ll move around meetings to create longer contiguous blocks, and then I’ll create a meeting called “Do Not Book” or, if I suspect someone will ignore that, I’ll name it something like “Collaboration Session” or “Research Review.” You have to get crafty.”
You now have time blocks for each category, but you still need to know which specific task — or group of tasks — to work on when the time comes. That’s where a task manager like Todoist comes in.
[Create a Todoist label](https://get.todoist.help/hc/en-us/articles/360000029000-How-to-best-use-labels?utm%5Fsource=dots%5Fblog&utm%5Fmedium=referral&utm%5Fcampaign=time%5Fblocking) for each batched category you came up with in step one, then review all of your current tasks and assign the appropriate label to each one.
Now, when you come to a time block, all you have to do is pull up the corresponding label list and choose from the relevant tasks. Tasks with dates will automatically be sorted at the top so you’ll know when something is due soon and needs your attention first.
### Todoist Tip
You can also [create a new filter](https://get.todoist.help/hc/en-us/articles/205248842-Filters?itm%5Fcampaign=time%5Fblocking&itm%5Fmedium=referral&itm%5Fsource=productivity%5Fmethods%5Fguides) with a query like “@personal\_admin & next 7 days” to see just the tasks due in the upcoming week with that specific label.
To make sure nothing slips through the cracks, every task should have a label. However, you’ll likely find that not every category needs to be tracked in Todoist. For example, you may want to keep track of your meetings or exercise classes in your calendar rather than in your task manager. And as we said before, you don’t want to overprogram your free time. Experiment with your setup to figure out what makes sense for your specific circumstances.
### Day theming variation
If you try time blocking and still feel too scattered and unfocused, you may want to try out day theming. We recommend this [free Skillshare course](https://www.skillshare.com/classes/Productivity-Habits-That-Stick-Using-Time-Theming/1216959000) by Mike Vardy. He walks you through setting up a day theming system, including detailed examples using both paper and Todoist.
### Scheduling time blocks for individual tasks
Of course, if you want to keep a more granular schedule, you can always create separate time blocks for each task. The easiest way to do that with Todoist is via the [2-way integration with Google Calendar](https://get.todoist.help/hc/en-us/articles/115003128085-How-can-I-use-Todoist-with-Google-Calendar?itm%5Fcampaign=time%5Fblocking&itm%5Fmedium=referral&itm%5Fsource=productivity%5Fmethods%5Fguides).
When setting up the integration:
* Create a new calendar for just your Todoist tasks so you can toggle them on and off inside your calendar as you need.
* Choose to sync your entire Todoist account or create separate calendars for each of your Todoist projects.
* Choose to sync tasks with just a due date in addition to tasks with a due date and time.
Any Todoist task with a date and time will automatically appear as an event in your new Todoist calendar. Any task with a date but no time will appear as a day-long event.
During your [weekly review](https://todoist.com/productivity-methods/weekly-review), give each task you want to accomplish a date and/or start time by typing something like “Monday at noon” or “Every Friday at 9am” into the task field. Todoist will automatically recognize and highlight the date and set it when you save the task.
Now, when you open your daily or weekly view in your calendar, you’ll see each of your tasks scheduled as separate events (aka your time blocks). You can extend, shorten, edit, and move your time blocks inside your calendar. Any changes you make in Google Calendar will automatically sync back to your Todoist (and vice versa).
---
Scheduling your days and weeks in advance can seem like a waste of precious time you could be using to actually get things done. But when you aren’t controlling your calendar, it’s easy to let distractions take over. By front-loading your decision-making on what to work on for the day or week, you’ll be saving time and mental energy when it comes to actually getting to work.
Give time blocking and task batching a try for a week and see how it feels to take back control over your time and attention.
### Todoist Tip
If you have a Pro or Business plan, you can supercharge your time blocking with [task durations](https://todoist.com/help/articles/whats-new#reclaim-your-schedule-with-task-durations-aug-30). Simply:
* Select your Due Date, then Time, to set the start time and duration of your task. This forms your time block.
* You can also add a task’s duration via Todoist’s natural language recognition by typing “for” followed by the length of time you think the task will take. (e.g., “Team meeting today 4pm for 45min” or “Write first draft 9am for 2 hours 30 minutes”.)
* If you’ve connected your Todoist to a calendar app, the task duration will sync to your calendar automatically (and, on Google Calendar, vice versa with 2-way sync so you can update your tasks from your calendar).
#### Laura Scroggs
[Laura](https://laurascroggs.wordpress.com/) is a freelance writer, PhD candidate, and pug mom living in Minneapolis, MN.

43
Read Later/The First Rule of Comments in Code.md Normal file
View file

@ -0,0 +1,43 @@
---
id: 24bd8d1e-b118-4930-a86d-3929f2dad34c
title: |
The First Rule of Comments in Code
status: ARCHIVED
tags:
- read-later
date_added: 2023-11-02 23:25:19
url_omnivore: |
https://omnivore.app/me/https-youtu-be-hxsx-3-vbf-qq-si-c-5-qy-m-mg-8-j-yhc-bbq-18b92ffccf6
url_original: |
https://youtu.be/hxsx3vbf-QQ?si=-C5QyMMg8JYhcBBQ
---
# The First Rule of Comments in Code
## Notes
Comments are bad by nature:
- They get outdated pretty quickly, and you don't know if the comments is updated with the code.
- A comments is most probably noise, because it's not gonna provide more information than the code itself.
- Commented code is broken code, because it's probably outdated compared to it's context.
Some rules to evade writing comments:
**Code that needs a comment, needs to be rewritten**. Always try to put the information in the code. if it needs a comment, it's not good enough.
**Move information somewhere else**. this is similar to the previous, move to a variable name, or to a documentation file in the worst case.
**How quickly the information will goes out of date**. It's so simple that a comments goes out of sync with the code, to prevent that transform the comment in code.
**If a comment gives no more information than the code, delete it**.
**"I need to explain the complexity"**. No, you need to fix the complexity. If the complexity is so big, put in the documentation instead. A comment cannot fix complexity, and will require hard work to change that code.
**Don't comment out code, delete it**. Commented code goes quickly out of sync with it's context, is not tested in any way and the effort of updating it is almost the same if not higher that writing it over with better knowledge, so it's better to just delete it. If we need this code back, we can recover it with git.
---
## Original
[The First Rule of Comments in Code](https://youtu.be/hxsx3vbf-QQ?si=-C5QyMMg8JYhcBBQ)
By [Bran van der Meer](https://www.youtube.com/@branvandermeer)

316
Read Later/The Secret Power of ‘Read It Later’ Apps.md Normal file
View file

@ -0,0 +1,316 @@
---
id: 85f31880-6935-11ee-86f4-f7cb87ce263e
title: |
The Secret Power of ‘Read It Later’ Apps
status: COMPLETED
tags:
- read-later
date_added: 2023-10-12 16:28:29
url_omnivore: |
https://omnivore.app/me/the-secret-power-of-read-it-later-apps-18b255ca194
url_original: |
https://fortelabs.co/blog/the-secret-power-of-read-it-later-apps
---
# The Secret Power of ‘Read It Later’ Apps
## Highlights
> [!quote] ㅤ
> > People who cling to paradigms (which means just about all of us) take one look at the spacious possibility that everything they think is guaranteed to be nonsense and pedal rapidly in the opposite direction. Surely there is no power, no control, no understanding, not even a reason for being, much less acting, in the notion or experience that there is no certainty in any worldview. But, in fact, everyone who has managed to entertain that idea, for a moment or for a lifetime, has found it to be the basis for radical empowerment. **If no paradigm is right, you can choose whatever one will help to achieve your purpose.**
>
> > It is in this space of mastery over paradigms that people throw off addictions, live in constant joy, bring down empires, get locked up or burned at the stake or crucified or shot, and **have impacts that last for millennia**.
>
> > In the end, it seems that mastery has less to do with pushing leverage points than it does with **strategically, profoundly, madly letting go.**
>
> [source](https://omnivore.app/me/the-secret-power-of-read-it-later-apps-18b255ca194#42edb9e2-3799-430e-bbff-db1170ebbad1)
>
>
>> [!info] ㅤ
>> Read again and understand it better
---
## Original
![](https://proxy-prod.omnivore-image-cache.app/900x380,sXXV7f9Au3y4tF2zoOnAQ1G8Xnf3Uh8IRqZcfVY3HoSY/https://i0.wp.com/cdn-images-1.medium.com/max/2000/1*rPXwIczUJRCE54v8FfAHGw.jpeg?resize=900%2C380&ssl=1)
Image via Nuno Cruz
_By Tiago Forte of_ [_Forte Labs_](http://fortelabs.co/)
At the end of 2014 I received an email informing me that I had read over a million words in the ‘read it later’ app Pocket over the course of the year.
![](https://proxy-prod.omnivore-image-cache.app/358x377,ssfZXhGmomcxzcD-VkrtnzD-6vk-rI8GUuXk4JlRMX2s/https://i0.wp.com/cdn-images-1.medium.com/max/600/1*Hd7YIhMrS5lldl1gDU8iWQ.png?resize=358%2C377&ssl=1)
This number by itself isn’t impressive, considering our daily intake of information is equivalent to [34 gigabytes](http://bits.blogs.nytimes.com/2009/12/09/the-american-diet-34-gigabytes-a-day/), 100,000 words, or [174 newspapers](http://www.nytimes.com/2014/08/10/opinion/sunday/hit-the-reset-button-in-your-brain.html?smprod=nytcore-iphone&smid=nytcore-iphone-share), depending on who you ask.
What makes this number significant (in my view) is that it represents 22 books’-worth of long-form reading that would not have happened without a system in place.
We’ve made a habit of filling those hundred random spaces in our day with glances at Twitter, Instagram, and Facebook. But those glances have slowly become stares, and those stares have grown to encompass a major portion of our waking hours.
The end result is the same person who spends 127 hours per year on Instagram (the [global average](http://www.businessinsider.com/people-spend-21-minutes-per-day-on-instagram-2014-10)) complains that she has “no time” for reading.
The fact is, **the ability to read is becoming a source of competitive advantage in the world**.
I’m not talking about basic literacy. What has become exceedingly scarce (and therefore, valuable) is the physical, emotional, attentional, and mental capability to sit quietly and direct focused attention for sustained periods of time.
A [recent article](https://hbr.org/2005/01/overloaded-circuits-why-smart-people-underperform) in the Harvard Business Review puts a name to this new neurological phenomenon: Attention Deficit Trait. Basically, the terms ADD and ADHD are falling out of use because effectively the entire population fits the diagnostic criteria. It’s not a condition anymore, it’s a _trait_ — the inherent and unavoidable experience of modern life characterized by “distractibility, inner frenzy, and impatience.”
![](https://proxy-prod.omnivore-image-cache.app/0x0,sCKKsi_KsyhXjSRvn7hvFRJEjLKQkBiJU0agepFckkI4/https://embed.filekitcdn.com/e/oP2q5jihy5hj474ZFtvPjw/3edWskTMDwFhuVEtauLv5X)
Start Building Your Second Brain
Subscribe below to learn more about the next cohort of the Building a Second Brain course
### Read It. Later.
Before I explain the massive, under-appreciated benefits these apps provide, and how to use them most effectively, a quick primer in case you’re unfamiliar.
So-called “Read It Later” apps give you the ability to “save” content on the web for later consumption. They are essentially advanced bookmarking apps, pulling in the content from a page to be read or viewed in a cleaner, simpler visual layout.
On top of that core function they add features like favoriting, tags, search, cross-platform syncing, recommended content, offline viewing, and archiving. The most popular options are:
* [Instapaper](https://www.instapaper.com/)
* [Pocket](https://getpocket.com/a/)
* [Send to Kindle](https://chrome.google.com/webstore/detail/send-to-kindle-for-google/cgdjpilhipecahhcilnafpblkieebhea?hl=en) (for sending articles to your Kindle)
* [Feedly](https://feedly.com/i/welcome) (for those RSS fans)
* and [Safari’s built-in “Add to Reading List” feature](https://support.apple.com/en-us/HT200294).
The app I use, Pocket, adds a button to the Chrome toolbar that looks like this:
![](https://proxy-prod.omnivore-image-cache.app/130x58,syYiQlMJ3hP3JyGS_AYz8D5Oq9FZ1QxR2ef29Fia7Ht0/https://i0.wp.com/cdn-images-1.medium.com/max/800/1*Lk-DPDFjLslM4h2GAv8KIA.png?resize=130%2C58&ssl=1)
Chrome toolbar
_Note: at time of writing, I was using Pocket, but have recently switched to Instapaper because of Pocket’s “Share to Evernote” bug mentioned below._
Clicking the button while viewing a webpage turns the button pink, and saves the page to your “list.” Navigating to getpocket.com, or opening the Pocket app on your computer or mobile device shows you a list of everything you’ve saved:
![](https://proxy-prod.omnivore-image-cache.app/800x507,smjUUrOduWv7T0bCSx9oh_Ag0Yasq_HyFfgAoDXryOcM/https://i0.wp.com/cdn-images-1.medium.com/max/800/1*wkKD4oP3-kWJERxmBBI2cA.png?resize=800%2C507&ssl=1)
Mac desktop client
You can also view your list in a “tile” layout on the web, making it into essentially a personalized magazine. Personalized, in this case, not by a cold, unfeeling algorithm, but by your past self:
![](https://proxy-prod.omnivore-image-cache.app/800x478,sFjAZnzFiVzsVRlXF9QyD5dq_jzT69dsyyp3Bb-k5ZGU/https://i0.wp.com/cdn-images-1.medium.com/max/800/1*ug06oorCHGFpEzMyl9kfhg.png?resize=800%2C478&ssl=1)
Web browser “tile” view
Marking an item as read in one version of the app will quickly sync across all platforms. It will also save your current progress on one device, so you can continue where you left off on a different device (for those longer pieces).
### The highest leverage point in a system is in the intake — the initial assumptions and paradigms that inform its development
I’ve [written previously](https://medium.com/forte-labs/how-to-use-evernote-for-your-creative-workflow-f048f0aa3ed1) about how to use Evernote as a general reference filing system, not only to stay organized but to inspire creativity.
But I didn’t address a key question when creating any workflow: how and from where does information enter the system? The quality of a workflow’s outputs is fundamentally limited by the quality of its inputs. Garbage in, garbage out.
There are A LOT of ways we could talk about to improve the quality of the information you consume. But I want to focus now on the two that Read It Later apps can help with:
1. Increasing consumption of long-form content (which is presumably more substantive)
2. Better filtering
### #1 | Increasing Consumption of Long-Form Content
In order to consume good ideas, first you have to consume many ideas.
This is the fundamental flaw in the “information diet” advice from Tim Ferriss and others: strong filters work best on a larger initial flow. Using your friends as your primary filter for new ideas ensures you remain the dumbest person in the room, and contribute nothing to the conversation.
The problem is that our entire digital world is geared toward snackable chunks of low-grade information — photos, tweets, statuses, snaps, feeds, cards, etc. To fight the tide you have to redesign your environment — you have to create affordances.
> Affordance (n.): a relation between an object and an organism that, through a collection of stimuli, **affords the opportunity for that organism to perform an action.**
Let’s look at the 4 main barriers to consuming long-form content, and the affordances that Read It Later apps use to overcome them:
#### 1\. App performance
We know that the most infinitesimal delays in the loading time of a webpage will dramatically impact how many people stay on the page. [Google found](https://blog.kissmetrics.com/speed-is-a-killer/) that increasing the number of results per page from 10 to 30 took only half a second longer, but **caused 20% of people to drop off**.
If you think your behavior is not affected by such trivialities, think again. Even on a subconscious level, you will resist even opening apps that don’t reward you with snappy response times. Which is a problem because the apps most people turn to for reading are either ebook apps like iBooks and Kindle, or web browsers like Chrome and Safari. I’m not sure which category is slower, but they’re both abysmal.
Meanwhile, your snaps and instas refresh at precog-like speeds.
Read It Later apps, by slurping in content (articles, videos, slideshows) into a clean interface, eliminate the culprits — ads, site analytics, popups — all the stuff you don’t care about.
A [recent analysis](http://www.nytimes.com/2015/10/01/technology/personaltech/ad-blockers-mobile-iphone-browsers.html) by The New York Times of 3 leading ad-blockers (which have the same effect) measured a **21% increase in battery life**, and in the most egregious case of Boston.com, a drop in loading time **from 33 seconds to 7 seconds**. Many other leading sites were not that far off.
![](https://proxy-prod.omnivore-image-cache.app/563x365,sFABKoLfIzSHIwYCEllG7t2i-uxewZOlI9ALe6-KJLSs/https://i0.wp.com/cdn-images-1.medium.com/max/800/1*vfmR5LKEjfx-0Lx-kWb4bw.png?resize=563%2C365&ssl=1)
Effect of ad-blocker on loading times of Boston.com, via [NYT](http://www.nytimes.com/2015/10/01/technology/personaltech/ad-blockers-mobile-iphone-browsers.html)
Yeah that’s pretty much an eternity in mobile behavior land.
#### 2\. Matching content with your context
![](https://proxy-prod.omnivore-image-cache.app/507x676,sxG7LpsFKxnoEDDIOpwI06zJ3e8CoE30WZseOtRT8u6s/https://i0.wp.com/cdn-images-1.medium.com/max/600/1*N15BlTDGq8kTc7HdGUmShA.png?resize=507%2C676&ssl=1)
My Pocket list on iPad
Much of the time when we pull out our phone, we’re looking for something to match our mood (or energy, or time available, or other context). We use our constellation of shiny apps as mood regulators and self-soothers, as time-fillers and boredom-suppressors, for better or worse.
So you need a little entertainment, and you open…an ebook? Yeah right. Monochrome pages don’t attract you. They don’t draw you in.
Pocket gives reading some of this stimulatory pleasure by laying out your list in a pleasing, magazine-style layout (at left). Not only is it generally attractive, but it gives you that same magazine-flipping pleasure of engaging with something that interests you _right in that moment_.
David Allen puts it this way:
> “It’s practical to have organized reading material at hand when you’re on your way to a meeting that may be starting late, a seminar that may have a window of time when nothing is going on, a dentist appointment that may keep you waiting, or, of course, if you’re going to have some time on a train or plane. Those are all great opportunities to browse and work through that kind of reading. People who don’t have their Read/Review material organized can waste a lot of time, since **life is full of weird little windows when it could be used.**”
You’re not fighting your impulses forcing yourself to read a dense tome after a long work day. Willpower preserved ✓
#### 3\. Asynchronous reading
This is one of the least understood barriers to reading in our fragmented timescape.
There is something deeply, deeply unsatisfying about repeatedly starting something and not finishing it. This is what we experience all day at work, being continuously interrupted by a stream of “emergencies.” The last thing we want after a stressful day starved of wins is to fail even at reading an article.
The [2015 revised edition (affiliate link)](https://www.amazon.com/Getting-Things-Done-Stress-Free-Productivity-ebook/dp/B00KWG9M2E/ref=as%5Fli%5Fss%5Ftl?ie=UTF8&linkCode=ll1&tag=fortelabs07-20&linkId=fe6db72d8e5bbb38b1ea43241924f7e9&language=en%5FUS) of _Getting Things Done_ [cites the work](http://users.wfu.edu/masicaej/MasicampoBaumeister2011JPSP.pdf) of Dr. Roy Baumeister, who has shown that “uncompleted tasks take up room in the mind, which then limits clarity and focus.” The risk of cognitive dissonance at not being able to finish a long article (much less a book) keep us from even beginning it.
Read It Later apps address this by simply saving your progress in a given article, allowing you to pick back up at a different time, or on a different device, and clearly marking items as “read” once you’re finished.
#### 4\. Focus
A common response when I recommend people adopt _yet another_ category of apps is “Why don’t I just use Evernote?” Or whatever app they’re using for general reference or task management. Evernote even makes a Chrome extension called [Clearly](https://evernote.com/clearly/) for reading online content and [Web Clipper](https://evernote.com/webclipper/?downloaded) for saving it.
It is a question of focus. Why don’t you use your task manager to keep track of content (i.e. “Read this article”)? Because the last thing you want to see when you cuddle up with your hot cocoa for some light reading is the hundreds of tasks you’re not doing.
Likewise, the last thing you want to see when you (finally!) have time to read is the thousands of notes you’ve collected from every corner of the universe, only some of which you haven’t read, only some of which you _want_ to read, only some of which are _meant_ to be read.
> Actionable info ≠ Reference info ≠ To Read pile
Ergo,
> Task manager ≠ Evernote ≠ Pocket
### #2 | Better filtering
Now you’ve got the funnel filled. It’s time to narrow it.
Most advice on this topic focuses on being more selective about your sources. Cutting out the email digests that just throw you off track, unfollowing people posting crap, or even [directly replacing ads with quality sources](https://chrome.google.com/webstore/detail/ad-replacer-turn-spammy-a/eckeeomlpacfhejaameopnmgipghaoam).
The problem is that this assumes you are always at your best, always at 100% self-discipline, totally aligned with your life values, priorities ship shape.
Yeah.
In the moment, with your blood sugar at a negative value and every fiber of your being screaming for a dopamine hit, _of course_ that Buzzfeed article seems like the best conceivable use of your time. If you think you can permanently seal off your life from the celebrity news, content marketing, and spammy friends that dominate the web, the NSA has a job for you.
Procrastination is the most powerful force in the universe. _It will find a way._
I have a different approach: **waiting periods**. Every time I come across something I may want to read/watch, I’m totally allowed to. No limits! The only requirement is I have to save it to Pocket, and then choose to consume it at a later time.
I’ve found that even just clicking a link to open the URL, in order to save it to Pocket, is too much of a temptation. The first glimpse of a cute GIF and I’m off to Reddit, completely forgetting my morning email session.
So instead I just **command-click** every link I’m interested in (or **right-click > Open link in new tab**), which opens each link in a separate tab _without taking me to that tab_.
Here’s what a typical Monday morning link-fest looks like, just from email:
![](https://proxy-prod.omnivore-image-cache.app/0x0,s6KkWg-OdGcQNuvOShcztrmaslDz3Cm5o9rD1eDOxxRc/https://i0.wp.com/cdn-images-1.medium.com/max/2000/1*cLy09F0SPJJmi0WfazXi3Q.png?w=900&ssl=1)
Then, because I’m still in **collection mode**, not in read mode, I cycle through each tab one at a time (**shift-command-}** or **control-tab**), saving each one to Pocket using the shortcut I set up: **command-p** (chosen for irony and to avoid inadvertent printing).
There’s only one rule: **NO READING OR WATCHING!**
Bringing this back to filtering, not only am I saving time and preserving focus by batch processing both the collection and the consumption of new content, I’m **time-shifting the curation process** to a time better suited for reading, and (most critically) removed from the temptations, stresses, and biopsychosocial hooks that first lured me in.
I am always amazed by what happens: no matter how stringent I was in the original collecting, no matter how certain I was that this thing was worthwhile, I **regularly eliminate 1/3 of my list before reading**. The post that looked SO INTERESTING when compared to that one task I’d been procrastinating on, in retrospect isn’t even something I care about.
What I’m essentially doing is creating a buffer. Instead of pushing a new piece of info through from intake to processing to consumption without any scrutiny, I’m creating a pool of options drawn from a longer time period, which allows me to make decisions from a higher perspective, where those decisions are much better aligned with what truly matters to me.
> Remove any feature, process, or effort that does not directly contribute to the learning you seek. — Eric Ries, The Leader’s Guide
Here’s a visual of how this works, from my Pocket analytics:
![](https://proxy-prod.omnivore-image-cache.app/0x0,stGbUueP6GB86OSUIreA-v1CvD10SF4A-ecLznSBpGQc/https://i0.wp.com/cdn-images-1.medium.com/max/800/1*YRExWXbhPma8-AcWP_KSrw.png?w=900&ssl=1)
You can see that I save more things toward the beginning of the week and the weekend, and then draw down the buffer more towards the end of the week.
**_/sidebar_**
Imagine for a second if we could do this with everything. On Saturday morning, well-rested and wise, you retroactively decide everything you _want to have done_ during the previous week. Anything you decide was not worthwhile, you _get that time back_.
I experienced this recently with email — after returning from a 10-day meditation course during which I was completely off the grid, I was surprised to notice it took only 1.9 hours to process almost 2 weeks’ worth of email (I track these things). I normally spend on average 2.19 hours on email **per week** — _what happened to those extra 2.48 hours?!_ Besides the gains from batch processing such a large quantity of emails at once, I believe the main factor was that I evaluated my emails from a longer time horizon and higher perspective, more correctly judging whether something was worth responding to or acting on.
If only this method would scale.
**/end\_sidebar**
### Mo’ apps, mo’ problems
There are drawbacks, which I’ve glossed over until now. The two main ones:
#### 1\. Formatting issues
Many sites, including popular ones, aren’t presented correctly within the Pocket app (and I imagine others). There’s always the option of opening the link in a web browser, but this eliminates all the positive affordances and then some. If there wasn’t so much value provided otherwise, this would be a deal breaker.
The worst part is that, sometimes, the article is cut off or links don’t appear _without any indication that something is amiss_. On Tim Ferriss’ blog, for example, links (of which there are many) are simply removed.
One solution is to tag problematic items with “desktop” so you know that these need to be read/viewed on your computer.
#### 2\. Dependence
Every productivity tool eventually becomes a victim of its own success. In this case, I’ve become so dependent on Pocket that bugs really affect me.
For example, the Share to Evernote feature, which I use to highlight and save key passages, has been broken for at least a month. My hysterical tweets to Pocket Support have been answered but not resolved.
You wouldn’t think such a minor feature within one app could be so disruptive, but it has been massively so. This simple workflow:
_Highlight > Share > Share to Evernote > Save_
…has been replaced with this:
_Highlight > Copy > Switch to Evernote > New note > Paste > Switch back to Pocket > Share > More > Copy URL > Switch back to Evernote > Paste URL > Switch back to Pocket_
Worse, I often forget to go back and grab the URL, so I have to hunt it down at some later date.
**/rant\_over**
### Progress Traps and Paradigms
The amount of information in the world is a [progress trap](https://en.wikipedia.org/wiki/Progress%5Ftrap). Too much stuff to read is just as limiting as too little.
As the inimitable Venkatesh Rao [has written](http://breakingsmart.com/season-1/), we’re moving from a world of **containers** (companies, departments, semesters, packages, silos) to a world of **streams** (social networks, info feeds, main streets of thriving cities, Twitter). Problems and opportunities alike resist having neat little boxes drawn around them. There’s way too much to absorb. Way too much to even guess what you don’t know.
As the pace of change in the world accelerates, we double down on all the methods that created the problems in the first place — more planning, more forecasting, more control and risk management. We’re left with massive institutions that nobody trusts, that are simultaneously brittle and too-big-to-fail, creating precarity at every level of the socioeconomic pyramid.
What would it look like instead to solve problems (and explore opportunities) in a way that gets better the faster we go?
I can’t do justice to Rao’s blog series linked above (it’s in 20 parts — may want to save it for later ;), but the first step he proposes is “exposing yourself to as many different diverse streams as possible.”
When you’re immersed in a stream, the faster it goes, the more novel perspectives and ideas you’re exposed to. You develop an [opposable mind](http://rogerlmartin.com/lets-read/the-opposable-mind) — the ability to juggle and play around with different perspectives on any issue, instead of seeing it through one lens.
Increasingly, the only metric that will matter in your journey of personal growth will be **ROL: Rate-of-Learning**. We’ve heard a lot in recent years about the importance of hands-on learning and practical experimentation. We get it. Burying your head in a book by itself gets you nowhere.
But the pendulum is swinging too far in that direction. Yes, you can be _too_ action-oriented. Ideas, while cheap when compared to effective execution, are still more valuable than many of the other things we spend time on.
There’s another way to learn faster: assimilate and build on the ideas of others. Sure, you won’t understand every tacit lesson their experience gave them, but you can incorporate many of them, and in a fraction of the time it would take you to make every mistake yourself.
Ideas are high leverage agents. They become more so when arranged in highly cross-referenced networks. The only tool we have available that is capable of both creating and accessing these networks on demand is the human brain.
I lied before. There is one form of leverage even more powerful than the initial assumptions and paradigms that inform a system’s development: the **ability to transcend paradigms**.
I can’t put it any better than Donella Meadows, in her [seminal piece](http://www.donellameadows.org/archives/leverage-points-places-to-intervene-in-a-system/) on complex systems:
> People who cling to paradigms (which means just about all of us) take one look at the spacious possibility that everything they think is guaranteed to be nonsense and pedal rapidly in the opposite direction. Surely there is no power, no control, no understanding, not even a reason for being, much less acting, in the notion or experience that there is no certainty in any worldview. But, in fact, everyone who has managed to entertain that idea, for a moment or for a lifetime, has found it to be the basis for radical empowerment. **If no paradigm is right, you can choose whatever one will help to achieve your purpose.**
> It is in this space of mastery over paradigms that people throw off addictions, live in constant joy, bring down empires, get locked up or burned at the stake or crucified or shot, and **have impacts that last for millennia**.
> In the end, it seems that mastery has less to do with pushing leverage points than it does with **strategically, profoundly, madly letting go.**
Reading is the closest thing we have to thinking another’s thoughts. It’s long and sometimes ponderous, but that work is required to wrap yourself in another person’s paradigm. Which is the first step in madly letting go of your own.
The amazing thing about ideas is that it takes zero time for one to change your paradigm. It happens in time, but takes no time, like an inter-dimensional wormhole, one entangled particle in your brain mirroring its twin across a chasm even more vast than the universe — the chasm between two minds.
And that is the secret power of Read It Later apps.
**P.S.** _My latest setup has 2 parts: 1) using_ [_this IFTTT recipe_](https://ifttt.com/recipes/182352-instpaper-to-evernote) _to automatically send “liked” articles in Instapaper to an Evernotebook called “Instapaper favorites” (for things I want to save in general but don’t have any particular notes on), and 2)_ [_this recipe_](https://ifttt.com/recipes/368728-send-instapaper-highlights-to-evernote-default-notebook) _that saves anything I highlight in Instapaper to a new note, and sends it to the Evernote default notebook where I can decide where it belongs later (for when I have specific passages I want to extract)_
---
_**Subscribe below to receive free weekly emails with our best new content, or follow us on [Twitter](https://twitter.com/fortelabs/), [Facebook](https://www.facebook.com/fortelabs/), [Instagram](https://www.instagram.com/fortelabsco/), [LinkedIn](https://www.linkedin.com/in/tiagoforte/), or [YouTube](https://www.youtube.com/user/simulacrumsquared/). Or become a [Praxis member](https://fortelabs.co/about-praxis/) to receive instant access to our full collection of members-only posts.**_
![](https://proxy-prod.omnivore-image-cache.app/0x0,sqWznQTJOu8MLbN_KvWQgeSkhwNPdvLRWTom32MHspAE/https://embed.filekitcdn.com/e/oP2q5jihy5hj474ZFtvPjw/pkwszL6w2hsV41vY6MLfdR)
Join the Forte Labs Newsletter
Join 50,000+ people receiving my best ideas on learning, productivity & knowledge management every Tuesday. I'll send you my Top 10 All-Time Articles right away as a thank you.
* POSTED IN: [Building a Second Brain](https://fortelabs.co/blog/category/topics/building-a-second-brain/), [Curation](https://fortelabs.co/blog/category/topics/curation/), [Free](https://fortelabs.co/blog/category/types/free/), [Note-taking](https://fortelabs.co/blog/category/topics/note-taking/), [Technology](https://fortelabs.co/blog/category/topics/technology/), [Workflow](https://fortelabs.co/blog/category/topics/workflow/)

591
Read Later/The Unreasonable Effectiveness Of Plain Text.md Normal file
View file

@ -0,0 +1,591 @@
---
id: 07f91eda-1940-4aaa-8e27-78b0bf176193
title: |
The Unreasonable Effectiveness Of Plain Text
status: ARCHIVED
tags:
- read-later
date_added: 2023-10-18 10:01:51
url_omnivore: |
https://omnivore.app/me/noboilerplate-scripts-34-plain-text-team-md-at-main-0-atman-nobo-18b42e0d185
url_original: |
https://github.com/0atman/noboilerplate/blob/main/scripts/34-Plain-Text-Team.md
---
# The Unreasonable Effectiveness Of Plain Text
## Highlights
> [!quote] ㅤ
> ## [Tie Yourself to the Mast](#tie-yourself-to-the-mast)
>
> %%pron. oh diss e us%% In the Odyssey, Odysseus (confusingly called Ulysses in English literature) had to travel through siren-infested waters.
>
> This was a well-understood problem in his world. Sailors would simply solve this by putting wax in their ears, so the sirens' tempting song wouldn't lure them to their deaths.
>
> But Odysseus had a challenge: He WANTED to hear the Sirens' beautiful song. He certainly didn't want to drown, so he ordered his crew to tie him to the mast of the ship, and to ignore any of his pleas to let him go, until safety.
>
> This way, he was able to guard against future bad decisions he knew he would make by setting up a framework to control his future self.
>
> This is the Ulysses pact, and it's a very common trick:
>
> * Leaving your credit card or car keys at home when going out drinking is a Ulysses pact.
> * Publishing a warrant canary on your company's website is a Ulysses pact,
> * and standardising all your tools on plain text is a Ulysses pact.
>
> [source](https://omnivore.app/me/noboilerplate-scripts-34-plain-text-team-md-at-main-0-atman-nobo-18b42e0d185#7466a699-a115-4b9f-99fc-416852b5aef2) #frameworks
>
>
>> [!info] ㅤ
>> El pacto de Ulysses es una estrategia (o framework) en donde tomamos medidas tempranamente para prevenir malas desiciones en un futuro.
> [!quote] ㅤ
> "The difference between science and screwing around is _writing it down_."
>
> ## [— Adam Savage](#-adam-savage)
>
> [source](https://omnivore.app/me/noboilerplate-scripts-34-plain-text-team-md-at-main-0-atman-nobo-18b42e0d185#9a030eb7-6269-4863-8e5e-61b59a1704b6) #quotes
>
>
>> [!info] ㅤ
>> This was just a cool quote...
---
## Original
<style> :root {--r-code-font: "FiraCode Nerd Font";} .reveal .hljs {min-height: 50%;} </style>
!\[\[git-logo.png|500\]\]
## [Plain-Text Team](#plain-text-team)
notes: %%
* Tell them what you're going to tell them
* Tell them
* Tell them what you told them %% Hi friends my name is Tris and this is No Boilerplate, focusing on fast, technical videos.
All good teams are alike; each bad team is bad in its own way. %% to paraphrase Tolstoy %%
Software is an incredible thing, isn't it? Combined with the internet, a small team of friends can change the world overnight.
Every company, no matter what their industry, must now run a tech team, even if only to maintain their website.
So why are they all so bad at it?
---
!\[\[cc-logo.png\]\]
## [Public Domain Videos](#public-domain-videos)
<https://github.com/0atman/noboilerplate/>
notes: Everything you see in this video: script, links, and images are part of a plain-text markdown document available freely on GitHub under a public domain licence.
---
## [First World Problems](#first-world-problems)
notes: If you've worked in a web team, tech team or any digital creative team, you've likely felt the pain.
* Bad software,
* constantly changing processes,
* and lots and lots of meetings.
I discussed some of these problems in my Agile video that made me a lot of friends. But today, I want to go bigger. You can solve all these problems in a single blow.
The secret is, in order to do more, you must have the discipline to do LESS.
---
!\[\[rework-book.png|400\]\]
!\[\[remote-book.png|400\]\]
notes:
A lot of the ideas that I will mention today are not new. They've been well-understood in the startup and digital world for a long time.
But regression to the mean is prevalent.
It's not just enough to argue for good tools today, you must stop the future churn of new apps and processes that solve the same things in different, but equivalent ways.
And you do this with a Ulysses pact.
---
!\[\[ulysses-and-the-sirens-waterhouse.jpg\]\]
_"Ulysses and the Sirens"_ [John William Waterhouse](https://en.wikipedia.org/wiki/John%5FWilliam%5FWaterhouse)
notes:
## [Tie Yourself to the Mast](#tie-yourself-to-the-mast)
%%pron. oh diss e us%% In the Odyssey, Odysseus (confusingly called Ulysses in English literature) had to travel through siren-infested waters.
This was a well-understood problem in his world. Sailors would simply solve this by putting wax in their ears, so the sirens' tempting song wouldn't lure them to their deaths.
But Odysseus had a challenge: He WANTED to hear the Sirens' beautiful song. He certainly didn't want to drown, so he ordered his crew to tie him to the mast of the ship, and to ignore any of his pleas to let him go, until safety.
This way, he was able to guard against future bad decisions he knew he would make by setting up a framework to control his future self.
This is the Ulysses pact, and it's a very common trick:
* Leaving your credit card or car keys at home when going out drinking is a Ulysses pact.
* Publishing a warrant canary on your company's website is a Ulysses pact,
* and standardising all your tools on plain text is a Ulysses pact.
---
!\[\[the-fbi-has-not-been-here.png\]\]
An example of a warrant canary
notes:
In the future, you, or your successor, or your team might well be tempted to try the latest hot project management software, or documentation tool or scrum system.
While it might be good for a while, the act of changing tools constantly is an enormous overhead for your team, and one that gives the lasting impression that anything we write is likely to be legacy very soon, trapped in a deprecated app that "we just don't use any more", so why bother writing anything down.
Tying yourself to the mast by standardising on one tool, and not only that, but a plain text tool, means your data will live forever, and the network effect can make it more and more valuable over time, instead of less and less.
---
"The greatest problem in communication is the _illusion_ that it has been achieved."
## [— William H. Whyte](#-william-h-whyte)
[(not George Bernard Shaw, apparently)](https://quoteinvestigator.com/2014/08/31/illusion/)
notes:
## [Decoupled Organisation Through Plain Text](#decoupled-organisation-through-plain-text)
Teams of people need to be on the same page. Both literally and figuratively.
The natural way to do this is by talking to one another. But talking does not scale, and is extremely impermanent. After the sound waves have bounced off the walls and reverberated for a second... the words are gone, and what is left is our memory of them.
---
"The difference between science and screwing around is _writing it down_."
## [— Adam Savage](#-adam-savage)
notes:
Human memory is extremely unreliable, subjective, and the root cause of many problems.
After a discussion, it is not apparent that everyone has agreed upon exactly the same thing. And you now need another meeting to double-check that.
The solution is documentation.
---
## [Documentation-First Teams](#documentation-first-teams)
notes: Communication is most reliable when it is in black and white.
Everyone understands this, from 10,000-page government specifications to an email sign-off from the client you're making a 3-minute track for.
Yes, have more immediate conversations, by video, or chat, but write down what you concluded, and get the other person to confirm it.
---
## [](#documenting-architecture-decisions)["Documenting Architecture Decisions"](https://cognitect.com/blog/2011/11/15/documenting-architecture-decisions)
(aka the _ADR_ process)
— [Michael Nygard](https://cognitect.com/authors/MichaelNygard.html)
notes: You can improve every part of your team, business, or organisation by recording what decisions you have made, and WHY, in a system that allows for asynchronous discussion and improvements.
The ADR process is excellent for this, for example.
There are a thousand competing apps that claim to solve these problems for you.
---
!\[\[gdocs-screenshot.png|200\]\]
!\[\[jamboard-photo.png|200\]\]
!\[\[confluence-screenshot.png|200\]\]
!\[\[pivotal-tracker-screenshot.png|200\]\]
!\[\[notion-screenshot.png|200\]\]
!\[\[trello-screenshot.png|200\]\]
notes: These apps all re-invent the wheel in their own way, and new ones are being released every week. I've used most of them, perhaps you have too, and they're all rubbish.
But there is a group of people who are extremely practised at managing enormous distributed, concurrent, text projects:
_Programmers!_
As an example, if you use Google Docs, your small team can collaborate on a few files a day, in a drive of perhaps a hundred or two hundred. And just like in most other documentation systems, that won't scale.
Programmers simultaneously edit thousands of files a day, across repositories of data so numerous that we don't keep count.
What are programmers using, and can non-programmers use it too?
---
## [Enter Git](#enter-git)
* GitHub
* GitLab
* Bitbucket
* SourceForge
* Etc.
notes:
The answer is yes, yes we can.
I recommend you use the most popular distributed version control system on the planet: Git.
You'll use this through one of the many git web hosts, the largest of which is GitHub, which I recommend for most people.
---
## [Popularity Matters](#popularity-matters)
notes:
Though I mention GitHub primarily in this video, I'm not sponsored by them, or anything like that, I just acknowledge that popularity matters. Support, experience, and integrations with other services will all be far, far easier if you use the standard.
All these tools started as a web interface around the incredible tool: Git.
---
## [Aside:](#aside)
## [Linux & Git](#linux--git)
notes: By the way, the creator of Linux, Linus Torvalds, also later created git, to solve the problem that he created: that the Linux project had become SO LARGE that existing plain text collaboration tools were not scaling.
He jokes that he named his first project, Linux, after himself, and so it was natural to name the second one after himself too!
---
## [Github Et Al. Are Greater Than the Sum of Their Parts](#github-et-al-are-greater-than-the-sum-of-their-parts)
notes: From simple code-hosting beginnings, these git services have grown to be so much more than that, trusted by the largest projects in the world, built by the largest companies in the world.
The foundation of my ideal team uses the raw materials that GitHub has given us.
What are the raw materials?
I'll show you this with a demo: We're going to build a GitHub organisation for No Boilerplate.
This video is not sponsored by GitHub, my work is possible, thanks to viewers like you.
---
!\[\[nb-patreon-aug-23.png|700\]\]
<https://www.patreon.com/noboilerplate>
notes:
If you'd like to see and give feedback on my videos up to a week early, as well as get discord perks, and even your name in the credits, it would be very kind of you to check my Patreon.
I'm also offering a limited number of mentoring slots. If you'd like 1:1 tuition on Rust, Python, Web tech, Personal organisation, or anything that I talk about in my videos, do sign up and let's chat!
It's just me running this channel, and I'm so grateful to everyone for supporting me on this wild adventure.
Let's make our plain text team:
---
!\[\[repo.png\]\]
## [Repos](#repos)
notes: The foundational unit with any git host is the repo. This doesn't just correspond with one git repository, but one logical project or subproject. Organisational tools like the Wiki (for documentation), Projects (for project management) and more can sit here, right next to your project's files, right where you need them.
---
!\[\[wiki2.png\]\]
## [Wikis](#wikis)
notes: Each GitHub repository has a wiki, a folder of linked markdown files that anyone with access can edit, either in the friendly web editor, or, by cloning the wiki with git, on their own computer with whatever editor they like.
This is the minimum viable documentation tool, and it's useful for when git's full collaboration system isn't needed, and you just want to throw some linked markdown files together quickly.
---
## [\# This is a Heading](#-this-is-a-heading)
### [\### This is a Sub Heading](#-this-is-a-sub-heading)
_\_this is italic text\__
**\*\*this is bold\*\***
\[[this is a link](https://github.com/0atman/noboilerplate/blob/main/scripts)\]([http://example.com](http://example.com/))
_(learn more: [markdownguide.org/basic-syntax/](https://www.markdownguide.org/basic-syntax/))_
notes:
## [Aside: Markdown is Great](#aside-markdown-is-great)
Github, GitLab, and most of the Internet have standardised on Markdown. Just like Slack, Discord, many websites, and sometimes Facebook depending on the phase of the moon, they all format text using this lightweight standard called Markdown.
Markdown is my favourite text format, it's really simple to use, and is designed to look good both in plain text and rendered as rich text, unlike HTML, which is unreadable by most people unless rendered in a browser.
Here we've got a heading, denoted by the hash symbol, italic with underscores, bold with double asterisks, and links using this bracket pairing syntax.
There are a few more options available, which you can look up at markdownguide.org, but this is the overwhelming majority of formatting you'll need on a day-to-day basis.
---
!\[\[obsidian-kanban-paint.png\]\]
notes:
The genius of storing your data in this universal plain-text format is that should you wish to migrate from GitHub to another similar platform, your data is portable and under your control.
GitHub formats Markdown very nicely, but you can export it in any format you like, and edit it with any tool you like, present and future.
Including my favourite tool here, Obsidian.
Markdown keeps your team focussed on what is important by allowing you just enough formatting, but no rich customisation options. You're not making a beautiful client brochure, so you shouldn't use 90s desktop publishing tools to make your company's critical documentation.
Back to GitHub's features:
---
!\[\[issues.png\]\]
## [Issues](#issues)
notes:
Though not part of the git system, Issues are a natural addition that all git hosts have implemented: A simple task system for capturing work that needs doing. These could be new features, customer requests, bug reports, or ideas. They have a rich comment thread for discussion, can be assigned to team members, and tagged with custom tags.
This minimum viable project management system could be all you need. Certainly, for a solo or small team, capturing requirements in Issues might be enough.
But if you need more, you need Milestones.
---
!\[\[milestones.png\]\]
## [Milestones](#milestones)
notes: GH milestones are a grouping of issues with a deadline.
They typically represent a target, a release, or something the team is working towards. Milestones just have a title, a description, and a date. No burndown charts, no swim lanes, no complex statistics, just a progress bar.
This might be enough project management for you. If not, it is time for GH Projects.
---
!\[\[projects.png\]\]
## [Projects](#projects)
notes:
Each GitHub repo, team, and organisation can have a project board, a lightweight kanban board with customisable columns, allowing you to group your issues together, and observe their progress through your current iteration.
This represents the information radiator for your team, a bird's-eye view of what is happening with the project, and something you might gather around for your morning catchup meeting.
You don't need all the features of Trello, JIRA, or anything like that. You need the minimum viable board.
This bare-bones tool completely side-steps 'the JIRA effect', which is if you have a tool that is packed full of time tracking, velocity points, and so on, the temptation is to use all these features, even if they give no value, and complicate your processes.
---
## [Aside:](#aside-1)
## [Standups Are Great](#standups-are-great)
notes:
If you have one meeting a day, it should be a standup. Good standups replace other meetings and accelerate your project dramatically.
The way I like to do standups is not by asking everyone what they did yesterday and what they intend to do today.
That's a great way to find out at length what Dave did on his day off, but not a good way to find out what's happening with the project specifically.
I recommend walking your board, backwards, from right to left. Everyone is timeboxed, keeping the meeting tight. If you don't have an issue on the board, you don't speak yet. Perhaps you could write or pick up a task from the backlog and talk about it tomorrow.
At the end, the team member who is facilitating the meeting asks if anyone has any blockers, and we're done.
The most important part of this most important meeting is asking if you have any blockers. A good standup means that no-one can get lost or delayed by more than 24 hours.
Note I didn't say the PM or DM or scrum master or whoever facilitates. That person doesn't exist in my team. These are not roles, they are hats.
I don't know if your team needs any other meetings, but it is vital that you do a standup.
Back to GitHub.
---
!\[\[org-public.png\]\]
## [Organisations](#organisations)
notes: GitHub provides an umbrella group of users called an organisation. This is your company, and if you're building your products in the open, as I recommend you do, you won't pay GitHub a thing. Most git hosts provide their services for free for open-source companies. If you have too much money, you can pay GitHub for a plan to make your data closed.
If you require more subdivision, Organisations are divided into Teams.
---
!\[\[teams.png\]\]
## [Teams](#teams)
notes:
Teams on GitHub allow you to granularly scope repo, project, wiki, and other permissions to the different teams in your organisation.
I recommend allowing everyone to write and contribute to all projects, you want the network effect and low admin overhead. This pattern is called "internal open source".
But if you wish, perhaps for regulatory reasons, read and write access to repos can be restricted by team.
---
!\[\[PR.png\]\]
## [Pull Requests](#pull-requests)
notes:
Now we're getting into the detail of GitHub. I adore pull requests, sometimes called merge requests in other systems. PRs represent a change to the files in a repo, with an explanation of what you did, some links, and a discussion.
---
!\[\[PR diff.png\]\]
## [Pull Requests (diffs)](#pull-requests-diffs)
notes:
After the discussion is satisfied, perhaps as simply as a colleague saying "LGTM" or as heavy weight as a full change review with an audit trail that would satisfy a bank, the changes are merged into the repo.
PRs can have powerful automation, called Actions
---
!\[\[action.png\]\]
## [Github Actions](#github-actions)
notes:
PRs and actions can run your company for you if you let them. Though Actions were built for running tests on source code, with a little imagination, they can be used for anything:
* If you're uploading vector images, an action can build all the rasterised resolutions the client wants.
* If you're uploading video or audio clips, an action can run them through plugins to remove noise, add a music track, and upload the draft to YouTube.
* If you're checking in company documents, an action can simply spellcheck it.
Actions can run hundreds of times an hour, always adhere to best practice, and never make mistakes.
Automating your company gives you an enormous competitive speed and quality advantage.
---
!\[\[language-tool-on-premise.png\]\]
notes: You could also, for example, set up style guide enforcement, blocking the PR if the phrase "on premise" has been found.
---
!\[\[nvme.png\]\] notes:
## [Offline Work](#offline-work)
When your company's code, visual assets, and administration, are all in git repositories, you gain another huge superpower.
All of this becomes accessible offline. Every file, every photo, every design, and document can be on your computer. The magic of offline isn't necessarily that you don't need the internet (though that is a handy feature on a plane) But that it's FAST, the data is RIGHT HERE on your computer, and you can do ANYTHING with it. If you need to change the company's name across 10,000 files, it's trivial. It's find and replace.
If you, instead, had 5-15 different web services that you scattered all your team's data across, you'd have to log in to each one, and hope they had the feature to find and replace within their own walled garden.
Most, somehow, don't have this basic feature.
---
## [Who is flying this thing?](#who-is-flying-this-thing)
notes:
GOOGLE DOCS doesn't have this basic feature: you can't find and replace across a drive of files!?
And the reason for this, I suspect, is that would be TERRIFYING, wouldn't it? What if a new hire accidentally did that, you'd have to roll back all those files manually, that could take days!
But with git, it would be a PR, clearly showing what was happening, and mistakes are trivial to fix.
Plain-text files, with just enough Markdown syntax to convey meaning, allow you and your team to work with this data in the way that they want, not the way that google or Atlassian or WHOEVER thinks is best.
Doesn't this take up a lot of space on your disk? Not plain text. But even if you're storing large files, storage is cheap if you're smart. A topic for another video, perhaps.
---
## [Future-Proofing](#future-proofing)
notes: The benefits of git, especially for teams already using it for code and text collaboration, are that
1. you're already paying for it, and
2. It's never going away.
It is impossible to imagine a management reshuffle that might decide on another tool just because it is the flavour of the month. Git and GitHub dominate the coding world, and I recommend GitHub not only because it is the biggest but also the most featureful.
---
!\[\[killed-by-google-10-23.png\]\]
[https://killedbygoogle.com](https://killedbygoogle.com/)
notes:
Even if you don't think git and plain text are the best option, I still suggest you use them because stability is far, far better than a constantly churning tool choice, as staff come, and go and fashions change, and Google decommission ANOTHER product.
RIP Jamboard :-(
---
## [Conclusion](#conclusion)
Click around my demo organisation for yourself:<https://github.com/noboilerplate>
notes:
You can't do all these utopian things in most companies, I'm painfully aware.
But you CAN do SOME of these things, even just in your immediate team, or only for yourself.
I'd be interested to know what other ways good teams buck the hype cycle in favour of sane, evidence-based improvements.
Thank you.
---
!\[\[tri-hex-moon-white-transparent.png|300\]\]
## [Thank You](#thank-you)
## [](#patreoncomnoboilerplate)[Patreon.com/NoBoilerplate](http://www.patreon.com/noboilerplate)
notes:
## [OUTRO](#outro)
If you would like to support my channel, get early ad-free and tracking-free videos, vip discord access or 1:1 mentoring, head to patreon.com/noboilerplate.
If you're interested in transhumanism and hopepunk stories, please check out my weekly sci-fi podcast, Lost Terminal.
Or if urban fantasy is more your bag, do listen to a strange and beautiful podcast I produce every full moon called Modem Prometheus.
Transcripts and compile-checked markdown source code are available on GitHub, links in the description, and corrections are in the pinned ERRATA comment.
Thank you so much for watching, talk to you on Discord.
%% NOW READ THE INTRO AGAIN %%

106
Read Later/Train Your Brain to Be More Creative.md Normal file
View file

@ -0,0 +1,106 @@
---
id: 6f1925bb-b86c-40d2-9363-6784aa2d402f
title: |
Train Your Brain to Be More Creative
status: ARCHIVED
tags:
- read-later
date_added: 2023-10-23 10:56:30
url_omnivore: |
https://omnivore.app/me/train-your-brain-to-be-more-creative-18b5cd2a390
url_original: |
https://hbr.org/2021/06/train-your-brain-to-be-more-creative
---
# Train Your Brain to Be More Creative
## Highlights
> [!quote] ㅤ
> ## **Engage with nature**
>
> It’s been proven that [spending time in nature](https://greatergood.berkeley.edu/article/item/how%5Fnature%5Fmakes%5Fyou%5Fkinder%5Fhappier%5Fmore%5Fcreative) makes us more creative. Looking at trees and leaves — instead of our electronic devices — reduces our anxiety, lowers our heart rates, soothes us, and allows our brains to make [connections more easily](https://bjsm.bmj.com/content/49/4/272.abstract?sid=56b97a4c-0e75-46d0-a6ba-41c7f41a089c).
>
> By spending time in nature, I’m not referring to a trek in the wilderness either. Walking in an urban green space for just 25 minutes can quiet our brains and help us switch into autopilot node. According to the [_British Journal of Sports Medicine_](https://bjsm.bmj.com/content/49/4/272?sid=56b97a4c-0e75-46d0-a6ba-41c7f41a089c), this state sparks our present awareness and fuels imagination. We are more easily able to connect existing notions, thoughts, and images to form a new, relevant, and useable concept.
>
> [source](https://omnivore.app/me/train-your-brain-to-be-more-creative-18b5cd2a390#9190b653-c9fe-4438-b02d-10ac2095ecd1)
> > [!quote] ㅤ
> You may have heard that creativity uses your right brain while your left brain is triggered during more analytical tasks. Well, [neuroscientists have found](https://www.livescience.com/39671-roots-of-creativity-found-in-brain.html) that creativity actually draws on your _entire_ brain — and meditation can you give you access to it.
>
> [source](https://omnivore.app/me/train-your-brain-to-be-more-creative-18b5cd2a390#6b9b547e-2d87-4b4e-8fb5-76c0fe82be37)
> > [!quote] ㅤ
> Try to add workout time on your calendar and make sure not to skip it. If you feel you don’t have time for a dedicated workout, block 20 minutes on your calendar and spend that time doing stretches at your desk.
>
> [source](https://omnivore.app/me/train-your-brain-to-be-more-creative-18b5cd2a390#339a25cd-d9b8-4c5c-90bb-34f31965dea8)
> ---
## Original
[ ![](https://proxy-prod.omnivore-image-cache.app/0x0,soxosZVFQZnXwxzP9rgu_9TRZBUG3bjD3lZNejHcEJZc/https://hbr.org/resources/css/images/ascend/Ascend-Landing-FINAL.png) ](https://hbr.org/ascend)
Where your work meets your life.
![](https://proxy-prod.omnivore-image-cache.app/0x0,sMVn7kBr4jEHmNBxbTdR1-qfuR5jP7cDJsmkVG0w5jRY/https://hbr.org/resources/images/article_assets/2021/06/A_Jun21_16_1255250589.jpg)
Anastasia Usenko/Getty Images
Creativity isn’t inherent. You have to hone it. Here are a few ways to do that, based on neuroscience. Engage with nature: Looking at trees and leaves, instead of our electronic devices, reduces our anxiety, lowers our heart rates, soothes us, and allows our brains to...
[![Ascend logo](https://proxy-prod.omnivore-image-cache.app/105x20,sdbRjRBiTtM89dGr0O-MZ2bZF4PuOMPYm7J_ky4ZT0M4/https://hbr.org/resources/images/article_assets/2020/10/Ascend_Logo_2020_2x.png)](https://hbr.org/insight-center/ascend)
Where your work meets your life. See more from Ascend [here](https://hbr.org/insight-center/ascend).
I don’t do ruts.
Not because I’m some brilliant creative, but because I’ve learned how my brain works. Your brain needs fuel, and it needs to be stretched to create those “OMG!” moments on demand.
Think about it. Great athletes train their bodies for days, weeks, and years to whip them into peak performance. Why, then, wouldn’t a creator do the same with their brain?
I’ve spent more than two decades (and counting) in the advertising industry, and contrary to popular belief, creativity isn’t inherent. You have to hone it. Over time, I’ve figured out what I need to do to get ideas flowing freely, and a lot of that insight comes from my interest in neuroscience. The more we learn about the workings of our gray matter, the better we can train it, control it, and make it do what we want.
Here a few things that have worked for me over the years.
## **Engage with nature**
It’s been proven that [spending time in nature](https://greatergood.berkeley.edu/article/item/how%5Fnature%5Fmakes%5Fyou%5Fkinder%5Fhappier%5Fmore%5Fcreative) makes us more creative. Looking at trees and leaves — instead of our electronic devices — reduces our anxiety, lowers our heart rates, soothes us, and allows our brains to make [connections more easily](https://bjsm.bmj.com/content/49/4/272.abstract?sid=56b97a4c-0e75-46d0-a6ba-41c7f41a089c).
By spending time in nature, I’m not referring to a trek in the wilderness either. Walking in an urban green space for just 25 minutes can quiet our brains and help us switch into autopilot node. According to the [_British Journal of Sports Medicine_](https://bjsm.bmj.com/content/49/4/272?sid=56b97a4c-0e75-46d0-a6ba-41c7f41a089c), this state sparks our present awareness and fuels imagination. We are more easily able to connect existing notions, thoughts, and images to form a new, relevant, and useable concept.
So make disconnecting a priority. Take a walk in your neighborhood park, stroll along the beach, or just add plants to your balcony and spend some time out there. For me, walking my dog — even when my name is not on the family schedule — works. You’ll feel the benefits of moving away from screens almost immediately.
## **Meditate**
I know, I know, you’ve heard this a million times: [Meditation](https://www.frontiersin.org/articles/10.3389/fpsyg.2013.01020/full) clears our minds of jumbled thoughts, and gives our brains the space to observe and reflect, improving task concentration and enhancing our ability to make smart decisions.
But did you know that meditation also puts the entire brain to work?
You may have heard that creativity uses your right brain while your left brain is triggered during more analytical tasks. Well, [neuroscientists have found](https://www.livescience.com/39671-roots-of-creativity-found-in-brain.html) that creativity actually draws on your _entire_ brain — and meditation can you give you access to it.
This intentional practice can be as simple as closing your eyes and focusing on your breath. Headspace, the popular meditation app, even has guided meditations for inspiring creativity. The idea is that when we intentionally pause in awareness, [we allow our minds the freedom and space to be still and creative](https://www.headspace.com/meditation/creativity). I practice this between meetings. I find a quiet space, focus on my breathing, and get my brain into an alpha state, or a wakeful state of relaxation. This allows me to disconnect from my initial ideas (after all, the human brain is hardwired to take the path of least resistance) and create new pathways in my mind.
## **Get moving**
[Steve Jobs](https://financialpost.com/executive/c-suite/steve-jobs-was-right-about-walking) was a big advocate for walking meetings for a reason. Moving around [has been linked to increased performance](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC1332529/pdf/brjsmed00003-0076.pdf) on creative tests. Exercising releases endorphins — chemicals our bodies produce to relieve stress and pain. When we are less stressed, our brains venture into more fruitful territory.
In fact, [a recent article](https://www.irishexaminer.com/lifestyle/healthandwellbeing/arid-40251431.html) compared the chemical that our brain releases during physical activity to Miracle-Gro, the water-soluble plant food that helps grow bigger, healthier plants. The good part is moving around is super simple to do, especially when you’re working at home. I often attend meetings while cycling on a stationary bike or plan short walks in between (and this can be done in an office too).
Try to add workout time on your calendar and make sure not to skip it. If you feel you don’t have time for a dedicated workout, block 20 minutes on your calendar and spend that time doing stretches at your desk.
Find a routine that works for you.
Ascend
Career and life advice for young professionals.
## **Connect with different kinds of people**
When consciously seeking inspiration, not enough can be said about diversity. Remember the brain and its predisposition to take the lazy way out? Diversity makes the brain work harder [by challenging stereotypes.](https://www.theguardian.com/lifeandstyle/2015/nov/01/diversity-good-for-your-brain-mind-multicultural) In addition, researchers at Johns Hopkins University [found](https://muse.jhu.edu/article/536530/summary) that “exposure to diversity experiences might foster the development of more complex forms of thought, including the ability to think critically.”
I make it a point to surround myself with people who come from different backgrounds than I do because their perspectives are a catalyst for creative thinking. Contrasting opinions sparks new possibilities, and allow us to make connections we hadn’t seen before, leading to better decisions. There was something to be said about Abraham Lincoln filling his cabinet with [a “team of rivals.”](https://bigthink.com/in-their-own-words/you-can-be-your-own-team-of-rivals) Productive discussions, brainstorms, and debates often result in wiser outcomes. At my agency, we’ve set up an “inspiration council,” which brings together our people from various regions, cultures, genders, and more, to initiate these kind of discussions.
Today, the distributed working model born out of the pandemic has made it even easier to bring people together. I recommend using social media channels like LinkedIn and Instagram to follow and connect with people who have backgrounds and experiences that diverge from your own. Don’t limit yourself by geography when you’re reaching out to someone or expanding your network. We are much better at creative problem-solving when we don’t have the comfort of knowing what to expect, which can happen if we only surround ourselves with people just like us.
Use these principles of neuroscience to give your brain the exercise that it needs. It will get you out of any rut. Or prevent you from getting into one in the first place.
#### Readers Also Viewed These Items
* [Bas Korsten](https://hbr.org/search?term=bas%20korsten&search%5Ftype=search-all) is the Global Chief Creative Officer at Wunderman Thompson.

75
Read Later/Use cases for Rust.md Normal file
View file

@ -0,0 +1,75 @@
---
id: 7b7ae540-77ef-11ee-9aed-e318464fef5a
title: |
Use cases for Rust
status: ARCHIVED
tags:
- read-later
- Newsletter
date_added: 2023-10-31 10:14:54
url_omnivore: |
https://omnivore.app/me/use-cases-for-rust-18b85df6f3a
url_original: |
https://omnivore.app/no_url?q=9e2f3a10-e4fd-4c33-85a3-ff3609f3c4d6
---
# Use cases for Rust
## Highlights
> [!quote] ㅤ
> Some popular server-side web frameworks written in Rust include Actix Web, Warp, and Axum.
>
> [source](https://omnivore.app/me/use-cases-for-rust-18b85df6f3a#64793bd7-d3bd-4597-9f2c-9b4697217661)
> ---
## Original
![](https://proxy-prod.omnivore-image-cache.app/374x0,sWwbkQPNcQS05Cyma-JsPnEwyj7_G5D8tak-9k2Pm7g8/https://kartrausers.s3.amazonaws.com/letsgetrusty/25597207_1643064007NFuWebsite_Header.png)
Hi Rustaceans,
Rust is fast, safe and hip.
But, what can you actually build with Rust?
…whether you want to use Rust professionally or as a hobbyist.
Here are a few common types of applications built using Rust:
**Blockchain**
* Rust is a great choice for blockchain applications because it is fast and secure.
* You can write both smart contracts and entire blockchains using Rust.
* Some popular blockchain projects written in Rust include Solana, Polkadot, and Near.
**Embedded programs**
* Rust is also well-suited for embedded programs, such as those used in cars, airplanes, and other devices.
* This is because Rust is memory-safe, memory-efficient and can be compiled to run on a variety of platforms.
**Server-side applications / Microservices**
* Rust is a great choice for server-side applications and microservices because it is fast and efficient.
* ==Some popular server-side web frameworks written in Rust include Actix Web, Warp, and Axum.==
* Many companies are migrating their critical microservices to Rust because of its safety and performance guarantees.
**WebAssembly**
* Rust can be compiled to WebAssembly, which means that you can use Rust to build web applications.
* Rust’s small runtime and first-class support for WebAssembly often make it the first contender for any WebAssembly projects.
This is only a small sample of what you can build in Rust.
In general, Rust is a great choice if you are looking for speed, safety and versatility.
If you want more details, here’s a YouTube video I made on the same topic.
**[\>>> What can you build in Rust?!](https://letsgetrusty.krtra.com/c/BgXaOx7YGua4/OQKy)**
Have fun building!
Bogdan
\---
PS - Looking for a Rust job? Apply here - [https://letsgetrusty.com/jobs](https://letsgetrusty.krtra.com/c/ysWbInNFr59c/OQKy)

47
Read Later/Using CSS custom properties like this is a waste - YouTube.md Normal file
View file

@ -0,0 +1,47 @@
---
id: 23360258-5e55-4f51-ae84-83f073539aef
title: |
Using CSS custom properties like this is a waste - YouTube
status: ARCHIVED
tags:
- read-later
- Youtube
date_added: 2023-10-14 20:11:15
url_omnivore: |
https://omnivore.app/me/using-css-custom-properties-like-this-is-a-waste-you-tube-18b30754bdc
url_original: |
https://m.youtube.com/watch?index=12&list=WL&pp=gAQBiAQB&v=_2LwjfYc1x8
---
# Using CSS custom properties like this is a waste - YouTube
## Notes
Definir _"variables locales"_ en la clase más alta de un _componente_ (Ej: ˋ.cardˋ), esta variable se puede utilizar para hacer variantes del componente de manera más rápida y limpia y se puede utilizar en los decendientes de la clase.
Esto tiene la ventaja de:
1. Para crear una variante de nuestro componente solo debemos crear una nueva clase y añadirla junto a la clase más alta (ˋ.card-successˋ), y ya solo debemos sobre escribir las variables en vez de tener que actualizar cada parte del componente (ˋ.card.card-success .buttonˋ & ˋ.card.card-success .card-header h3ˋ).
2. Si tenemos propiedades complejas o animaciones donde solo varia una parte de ellas (Ej: ˋdrop-shadowˋ) no tenemos que re-escribir en cada variante la propiedad completa.
---
## Original
![](https://proxy-prod.omnivore-image-cache.app/0x0,sQQWw6iRP7foFYzYmrRdXk9An2XA-R-aURCV45HDFUPA/data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIyMjE2IiBoZWlnaHQ9IjQyNSIgdmlld0JveD0iMCAwIDIyMTYgNDI1IiBmaWxsPSJub25lIj48cGF0aCBkPSJNMjg3LjYyIDQxNi4yNUMzNzcuNzQgNDE2LjA1IDQ4Mi4wNyA0MTIuODAgNTEzLjc0IDQwNC4wN0M1MzguMDkgMzk3LjU4IDU1Ni45NyAzNzguNzAgNTYzLjQ3IDM1NC4xNEM1NzIuMTkgMzIyLjQ4IDU3NS42NCAyNjIuMzkgNTc1Ljg1IDIxNC45MEM1NzUuNjQgMTY3LjgxIDU3Mi4xOSAxMDcuOTMgNTYzLjQ3IDc2LjY3QzU1Ni45NyA1MS45MCA1MzguMyAzMy4yMyA1MTMuNzQgMjYuNzNDNDgyLjA3IDE4LjAxIDM3Ny43NCAxNC41NiAyODcuNjIgMTQuMzVDMTk3LjcwIDE0LjU2IDkzLjU3IDE4LjAxIDYyLjExIDI2LjczQzM3Ljc1IDMzLjIzIDE4Ljg3IDUyLjExIDExLjk3IDc2LjY3QzMuNDUgMTA3LjkzIC4yMCAxNjcuODEgMCAyMTQuOTBDMC4yMCAyNjIuMzkgMy40NSAzMjIuNDggMTEuOTcgMzU0LjE0QzE4Ljg3IDM3OC41MCAzNy45NSAzOTcuNTggNjIuMTEgNDA0LjA3QzkzLjU3IDQxMi44MCAxOTcuNzAgNDE2LjA1IDI4Ny42MiA0MTYuMjVaTTIzMi4wMCAxMzEuNjdMMzc2LjMyIDIxNC45MEwyMzIuMDAgMjk4LjczVjEzMS42N1oiIGZpbGw9IndoaXRlIiAvPjxwYXRoIGQ9Ik03MzEuNTUgNDI1VjBIODYyLjYxVjcxLjg3SDgxNC45NVYxNzVIODU2LjMzVjI0Ni4yNUg4MTQuOTVWNDI1SDczMS41NVpNODc4LjczIDQyNVYwSDk2MS41MVY0MjVIODc4LjczWk05ODAuNjEgNDI1VjBIMTExMS42N1Y3MS44N0gxMDY0LjAyVjE3NUgxMTA1LjRWMjQ2LjI1SDEwNjQuMDJWNDI1SDk4MC42MVpNMTE1NS40MSA0MjVWNzEuODdIMTEyNC42N1YwSDEyNjkuNTNWNzEuODdIMTIzOC43OVY0MjVIMTE1NS40MVpNMTMzMC41NiA0MjVWMjc3LjUwTDEyODEuMDMgMEgxMzYyLjU2TDEzNzIuNTkgMTczLjc0SDEzNzMuODRMMTM4NS43NSAwSDE0NjUuMzlMMTQxNC42IDI3Ni4yNFY0MjQuOThIMTMzMC41NlY0MjVaTTE1NTcuMTUgNDI1VjBIMTY0My42OEMxNzAwLjEzIDAgMTczMy4zNiAzNC4zNyAxNzMzLjM2IDg5LjM3VjMzNi4yNEMxNzMzLjM2IDM5MS4yNCAxNjk5LjUgNDI1IDE2NDMuNjggNDI1SDE1NTcuMTVaTTE3NTEuNDkgNDI1VjBIMTg3OS40MlY3MS44N0gxODM0LjkxVjE3NUgxODc0LjRWMjQ2LjI1SDE4MzQuODlWMzUzLjc0SDE4NzkuNDFWNDI1SDE3NTEuNDlaTTE4OTYuMjQgNDI1VjBIMjAyNC4xN1Y3MS44N0gxOTc5LjY1VjE3NUgyMDE5LjE0VjI0Ni4yNUgxOTc5LjY1VjM1My43NEgyMDI0LjE3VjQyNUgxODk2LjI0Wk0yMDQwLjk4IDQyNVYwSDIxMzAuNjVDMjE5Ny4xMyAwIDIyMTUuOTQgMjkuOTkgMjIxNS45NCA4OS45OVYxNjkuMzdDMjIxNS45NCAyMzEuMjQgMjE5Mi4xMSAyNjEuODcgMjEyNy41MyAyNjEuODdIMjEyNC4zOVY0MjVIMjA0MC45OFoiIGZpbGw9IndoaXRlIiAvPjwvc3ZnPg==)
0:02 / 16:11•Watch full video
[![](https://proxy-prod.omnivore-image-cache.app/40x0,sUOpLNtzeeUoCYwskk1a5QzW3BGsoVGnMK_ykZEtZE5c/https://yt3.ggpht.com/ytc/APkrFKa6XiLa13mMVPzkmmTBcgNPjjqCGPrY86KfJFmf5w=s48-c-k-c0x00ffffff-no-rj)](https://m.youtube.com/@KevinPowell)
45K views 2 days ago [#css](https://m.youtube.com/hashtag/css)
If you're interested in checking out ICodeThis, you can find it here: [https://icodethis.com/?ref=kevin](https://www.youtube.com/redirect?event=video%5Fdescription&redir%5Ftoken=QUFFLUhqbVZsbWpVZ3M1NUdacFdJSVZha3BFQ0ZIaTNoZ3xBQ3Jtc0ttWG5nU0ltOTdzSE9YSDQ3aWlsUVFGcEVoMlRFaVhLb0hrczRKRVgta3N0bXBIeC1Sc1ZtTWJHY2MycUpfdVN6OE5pWDlfTG9WQlhTMlRzcW1YX2p1MTY4bjVybTd1ZG02RV9zM1l0QkFWeTNybjBtcw&q=https%3A%2F%2Ficodethis.com%2F%3Fref%3Dkevin&v=%5F2LwjfYc1x8) and if you want to sign up for one of their premium plans, use KEVIN at checkout for an extra 10% off. Custom properties are amazing, but a lot of people don’t take advantage of how awesome they are. They set them up in the :root and that’s it, but they can be so much more useful than that! So, in this …
...more
...more
45,645 views • Oct 12, 2023 • #css
#### License
Shop the Kevin Powell store

96
Read Later/What the Rust Book didn't tell you about testing....md Normal file
View file

@ -0,0 +1,96 @@
---
id: ad8a0732-733a-11ee-b2ab-13f1d6012322
title: |
What the Rust Book didn't tell you about testing...
status: ARCHIVED
tags:
- read-later
- Newsletter
date_added: 2023-10-25 10:30:35
url_omnivore: |
https://omnivore.app/me/what-the-rust-book-didn-t-tell-you-about-testing-18b6707a120
url_original: |
https://omnivore.app/no_url?q=1fed5fd7-7706-46cf-9947-927b26a77112
---
# What the Rust Book didn't tell you about testing...
## Highlights
> [!quote] ㅤ
> We want to test _get\_user_ without making real database queries.
>
> The solution is to mock the _Database_ trait and assert _execute\_query_ is called with the correct query. But how?
>
> We can use the [mockall crate](https://letsgetrusty.us6.list-manage.com/track/click?u=9f28b35c1658c447f3b962a54&id=00a07042b3&e=d0eb971086)!
>
> [source](https://omnivore.app/me/what-the-rust-book-didn-t-tell-you-about-testing-18b6707a120#f9650419-c778-4974-9da2-aabce209609f)
> ---
## Original
The Rust Book has an [entire chapter dedicated to testing](https://letsgetrusty.us6.list-manage.com/track/click?u=9f28b35c1658c447f3b962a54&id=a95a715235&e=d0eb971086), but it's missing a critical piece…
What happens when your code needs to make API calls or database queries?
Unit tests should be be fast, reliable, and deterministic.
We don't want to make expensive calls that might fail for various reasons.
Well here is some good news… we don't have to!
We can use mocking to substitute real objects for mock objects and assert certain expectations…
What's that? You want an example? Consider the following code…
trait Database {
fn execute_query(&self, query: String);
}
fn get_user(db: impl Database, id: i32) {
let query = format!("SELECT * from Users where id={}", id);
db.execute_query(query);
}
We want to test _get\_user_ without making real database queries.
The solution is to mock the _Database_ trait and assert _execute\_query_ is called with the correct query. But how?
We can use the [mockall crate](https://letsgetrusty.us6.list-manage.com/track/click?u=9f28b35c1658c447f3b962a54&id=00a07042b3&e=d0eb971086)!
Here is how we would test _get\_user_…
#[cfg(test)]
use mockall::{automock, predicate::*};
#[cfg_attr(test, automock)]
trait Database {
fn execute_query(&self, query: String);
}
fn get_user(db: impl Database, id: i32) {
let query = format!("SELECT * from Users where id={}", id);
db.execute_query(query);
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn get_user_executes_correct_query() {
let mut mock_database = MockDatabase::new();
mock_database.expect_execute_query()
.with(eq("SELECT * from Users where id=22".to_owned()))
.once()
.returning(|_x| ());
get_user(mock_database, 22);
}
}
Boom! Now we have a unit test that's fast, reliable, and deterministic!
If you haven't seen my [intro to testing in Rust video](https://letsgetrusty.us6.list-manage.com/track/click?u=9f28b35c1658c447f3b962a54&id=90d4167901&e=d0eb971086) make sure to check it out!
Happy testing, and stay Rusty!

31
Read Later/Why Signals Are Better Than React Hooks.md Normal file
View file

@ -0,0 +1,31 @@
---
id: e41b4086-963e-45e7-9ef7-2cfee7061047
title: |
Why Signals Are Better Than React Hooks
status: ARCHIVED
tags:
- read-later
date_added: 2023-11-01 14:16:42
url_omnivore: |
https://omnivore.app/me/https-youtu-be-so-8-l-bvwf-2-y-8-si-zy-gl-ie-hl-ai-pg-w-5-xo-18b8be328e5
url_original: |
https://youtu.be/SO8lBVWF2Y8?si=zyGlIeHlAiPgW5Xo
---
# Why Signals Are Better Than React Hooks
## Notes
Signals ayuda a la performance y legibilidad de una aplicación haciendo que la funcionalidades que normalmente se realizarían con los hooks `useState` y `useEffect` se realizen dentro de `signals`.
Esto permite compartir este _"estado"_ entre componentes pero solo actualizar los involucrados y no todos los desendientes del componente mayor.
Además, podemos extraer toda la lógica del estado a un archivo aparte que solo tenga código relevante, y en los componentes se mantiene solo la implementación.
Es obviamente más rápido de implementar y más limpio que hacer custom hooks, pero es añadir otra dependencia, habrá otras ventajas y desventajas??
---
## Original
[Why Signals Are Better Than React Hooks](https://youtu.be/SO8lBVWF2Y8?si=zyGlIeHlAiPgW5Xo)
By [Web Dev Simplified](https://www.youtube.com/@WebDevSimplified)

73
Read Later/You Don’t Actually Want Open World Games - YouTube.md Normal file
View file

File diff suppressed because one or more lines are too long

29
notes/Git.md Normal file
View file

@ -0,0 +1,29 @@
---
created: 2024-02-20 12:23
updated: 2024-02-20 12:23
---
## Merge strategies
![Notes](Git%20Merge%20vs%20Rebase%20vs%20Squash%20¿Qué%20estrategia%20debemos%20elegir-.md#Notes)
## Buscar cuando un bug se introdujo
Utilizar `git bisect`
## Fix messy commits
Ya que estas opciones sobre escriben el historial de git, solo deben aplicarse en local y no commits publicados a un remote.
### Last commit
Si solo necesitamos agregar un cambio pequeño al ultimo commit (typo o correr el formatter), podemos aplicarlo con `git commit --ammend`, se puede sobre escribir el mensaje con `-m`.
### Mutiple commits
Se pueden arreglar el historial de commits con un `git rebase -i [since commit or branch]` y utilizar las estratégias de pick, squash, reword y drop.
En caso de que sepamos que haremos un commit que luego no necesitaremos, podemos hacer:
- `git commit --fixup [commit hash]` -> descarta el commit message de este commit y mantiene el del commit de referencia
- `git commit --squash [commit hash]` -> git juntará los mensajes de todos los commits a hacer squash y el commit de referencia.
Finalmente podemos hacer `git rebase -i --autosquash` y git eligirá las opciones necesarias a tomar en vez de tener que hacerlo de manera manual.

4
notes/Good Enough.md
View file

@ -0,0 +1,4 @@
---
type: Checklist
---