diff --git a/.zk/notebook.db b/.zk/notebook.db
index 097aa6f..f72c123 100644
Binary files a/.zk/notebook.db and b/.zk/notebook.db differ
diff --git a/Notes/journaling-prompts.md b/Notes/journaling-prompts.md
new file mode 100644
index 0000000..50a25c8
--- /dev/null
+++ b/Notes/journaling-prompts.md
@@ -0,0 +1,7 @@
+---
+title: "Journaling ~rompts"
+tags:
+created: 2024-09-22 21:23
+---
+
+# Journaling Prompts
diff --git a/Omnivore/17-Year-Old Student Exposes Germany's 'Secret' Pirate Site Blocklist.md b/Omnivore/17-Year-Old Student Exposes Germany's 'Secret' Pirate Site Blocklist.md
new file mode 100644
index 0000000..2ef6ea4
--- /dev/null
+++ b/Omnivore/17-Year-Old Student Exposes Germany's 'Secret' Pirate Site Blocklist.md
@@ -0,0 +1,18 @@
+# 17-Year-Old Student Exposes Germany's 'Secret' Pirate Site Blocklist
+
+
+
+## Metadata
+- Author: [[isaacfrond]]
+- Full Title: 17-Year-Old Student Exposes Germany's 'Secret' Pirate Site Blocklist
+- Category: #articles
+- URL: https://torrentfreak.com/17-year-old-student-exposes-germanys-secret-pirate-site-blocklist-240822/
+> [!tldr]
+> A 17-year-old student in Germany has created a website to reveal the blocked pirate sites that major internet providers do not disclose. This initiative aims to increase transparency and address concerns about censorship related to copyright enforcement. The site, CUIIliste.de, lists 275 blocked domains, allowing users to see which sites are restricted.
+
+## Highlights
+watchdog - ([View Highlight](https://read.readwise.io/read/01j64wj1fy8b0dyhcdsjgv4vta))
+> [!note]
+> Watchdog: A term used to describe an individual or organization that monitors and oversees the actions of others, often to ensure accountability, transparency, and adherence to laws or regulations. Watchdogs play a critical role in various fields, including journalism, government, and environmental protection, by investigating misconduct, exposing corruption, and advocating for the public interest. Their function is essential in promoting ethical standards and fostering public trust in institutions.
+> In the context of Isaac Frond's article, the term "watchdog" refers to individuals or organizations that monitor and ensure accountability regarding governmental or institutional actions, particularly in relation to transparency and rights. The lack of public knowledge about the blocked pirate sites in Germany has led to frustration among journalists and advocates, highlighting the need for oversight. The 17-year-old student, along with his friends, embodies this watchdog role by exposing the secretive blocklist, thereby promoting transparency and challenging potential overreach in copyright enforcement.
+
diff --git a/Omnivore/2023-10-12 - How to Learn Rust.md b/Omnivore/2023-10-12 - How to Learn Rust.md
new file mode 100644
index 0000000..2281fe0
--- /dev/null
+++ b/Omnivore/2023-10-12 - How to Learn Rust.md
@@ -0,0 +1,25 @@
+---
+id: 9f0419b3-2f89-4734-96b3-55aa984414ac
+title: |
+ How to Learn Rust
+status: ARCHIVED
+tags:
+ - read-later
+ - Youtube
+ - 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
+
+
\ No newline at end of file
diff --git a/Omnivore/2023-10-12 - The Secret Power of ‘Read It Later’ Apps.md b/Omnivore/2023-10-12 - The Secret Power of ‘Read It Later’ Apps.md
new file mode 100644
index 0000000..5914eaa
--- /dev/null
+++ b/Omnivore/2023-10-12 - The Secret Power of ‘Read It Later’ Apps.md
@@ -0,0 +1,272 @@
+---
+id: 85f31880-6935-11ee-86f4-f7cb87ce263e
+title: |
+ The Secret Power of ‘Read It Later’ Apps
+status: ARCHIVED
+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
+
+> 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.**
+
+> [!note]
+> Read again and understand it better
+
+[source](https://omnivore.app/me/the-secret-power-of-read-it-later-apps-18b255ca194#42edb9e2-3799-430e-bbff-db1170ebbad1)
+
+---
+
+## Original
+
+
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.
+
+
+
+
This number by itself isn’t impressive, considering our daily intake of information is equivalent to 34 gigabytes, 100,000 words, or 174 newspapers, 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) 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 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.”
+
+
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:
The app I use, Pocket, adds a button to the Chrome toolbar that looks like this:
+
+
+ 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:
+
+
+
+ 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:
+
+
+
+ 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 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:
+
+
Increasing consumption of long-form content (which is presumably more substantive)
+
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 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 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.
+
+
+ Effect of ad-blocker on loading times of Boston.com, via NYT
+
+
+
Yeah that’s pretty much an eternity in mobile behavior land.
+
2. Matching content with your context
+
+
+
+ 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) of Getting Things Donecites the work 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 for reading online content and Web Clipper 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.
+
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:
+
+
+
+
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:
+
+
+
+
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. Too much stuff to read is just as limiting as too little.
+
As the inimitable Venkatesh Rao has written, 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 — 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 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) usingthis IFTTT recipeto 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 recipethat 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, Facebook, Instagram, LinkedIn, or YouTube. Or become a Praxis member to receive instant access to our full collection of members-only posts.
+
+
+
+```
+
+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 = `
Hello World
`;
+
+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.
+
+
+
+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 = `
+
+
You pressed me 0 times.
+`;
+
+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`
Hello World!
`;
+ }
+}`
+
+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`
+
+
You pressed me ${this.count} times.
+ `;
+ }
+}`
+
+```
+
+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/)
\ No newline at end of file
diff --git a/Omnivore/2023-11-07 - How to Avoid Prop Drilling in React.md b/Omnivore/2023-11-07 - How to Avoid Prop Drilling in React.md
new file mode 100644
index 0000000..52236fb
--- /dev/null
+++ b/Omnivore/2023-11-07 - How to Avoid Prop Drilling in React.md
@@ -0,0 +1,479 @@
+---
+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
+
+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)
+
+---
+
+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)
+
+---
+
+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)
+
+---
+
+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)
+
+---
+
+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)
+
+---
+
+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)
+
+---
+
+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)
+
+---
+
+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)
+
+---
+
+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
+
+
+
+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).
+
+[](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 (
+
+
+ );
+}
+
+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?
+
+
+
+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 (
+
+
This is the 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 (
+
+
+ );
+}
+
+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?
+
+
+
+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 (
+
+
This is the header
+
+
+ );
+}
+```
+
+In this case, static elements ` and
` 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 (
+ <>
+
+
+ );
+};
+
+function Parent({ profile }) {
+ return (
+
+
+
+
+ );
+};
+```
+
+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 (
+
+
+
+ );
+}
+
+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 (
+
+ );
+}
+```
+
+As you can see, we have resolved the prop drilling issue in the previous example, even though we still have a redundant component, ``, 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 (
+
+
+ );
+}
+
+export default App;
+```
+
+We can fix prop drilling in this case by moving `profile` to where it is consumed:
+
+```javascript
+function App() {
+ return (
+
+
+ );
+}
+```
+
+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 (
+
+
+
+ );
+}
+```
+
+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 (
+
+
This is the 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 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/)
\ No newline at end of file
diff --git a/Omnivore/2023-11-14 - The one thing you need to finish your game.md b/Omnivore/2023-11-14 - The one thing you need to finish your game.md
new file mode 100644
index 0000000..064de0b
--- /dev/null
+++ b/Omnivore/2023-11-14 - The one thing you need to finish your game.md
@@ -0,0 +1,31 @@
+---
+id: b453f3fe-d74e-4a3a-b778-8e4f6450da30
+title: |
+ The one thing you need to finish your game
+status: ARCHIVED
+tags:
+ - read-later
+date_added: 2023-11-14 22:58:47
+url_omnivore: |
+ https://omnivore.app/me/https-youtu-be-b-6-au-n-gi-ue-m-si-ixu-ds-nh-t-2-k-5-b-3-jf-s-18bd0b3d045
+url_original: |
+ https://youtu.be/B6auN-GIUeM?si=ixuDsNhT2k5b3JfS
+---
+
+# The one thing you need to finish your game
+
+## Notes
+
+What you need... is a **plan**...
+
+Because it makes the game feasible, realizable and gives it a scope, to see how "big" it's going to be. Also prevents burn out by all the stuff you _"need to do"_.
+
+A plan is not a immovable wall, you can tweak it if you need to adjust to new discoveries or new inputs, this is better than wandering without a goal. But try to not increment the scope so you don't end up with an interminable project.
+
+> The code is more of a guide than law...
+> Jack Sparrow
+## Original
+
+[The one thing you need to finish your game](https://youtu.be/B6auN-GIUeM?si=ixuDsNhT2k5b3JfS)
+
+By [Game Maker's Toolkit](https://www.youtube.com/@GMTK)
\ No newline at end of file
diff --git a/Omnivore/2023-11-21 - Career Mistakes to Avoid as a Developer.md b/Omnivore/2023-11-21 - Career Mistakes to Avoid as a Developer.md
new file mode 100644
index 0000000..ad8104b
--- /dev/null
+++ b/Omnivore/2023-11-21 - Career Mistakes to Avoid as a Developer.md
@@ -0,0 +1,313 @@
+---
+id: 49d7bfb2-8911-11ee-9b49-a315c7dbc2d7
+title: |
+ Career Mistakes to Avoid as a Developer
+status: ARCHIVED
+tags:
+ - read-later
+ - RSS
+date_added: 2023-11-21 21:04:22
+url_omnivore: |
+ https://omnivore.app/me/career-mistakes-to-avoid-as-a-developer-18bf626412f
+url_original: |
+ https://www.freecodecamp.org/news/career-mistakes-to-avoid-as-a-dev/
+---
+
+# Career Mistakes to Avoid as a Developer
+
+## Highlights
+
+Build authentic connections to get the best out of it. Then once you're connected, here are a few things you can do:
+
+* Show interest in their posts.
+* Engage with discussions by commenting or sharing posts.
+* Repost with your thoughts
+* Exchange ideas, or even build things together!
+
+A strong social connection may help you in getting information faster. You may learn about a new release of a library/framework/product, how an industry is moving, how certain technologies might impact your work, and so on.
+
+[source](https://omnivore.app/me/career-mistakes-to-avoid-as-a-developer-18bf626412f#3d561a03-61e0-4ca6-8e70-81651abe90c1)
+
+---
+
+## Original
+
+
+
+What does the word `career` mean to you? To me, it is a roller coaster journey during which we find opportunities, progress, and growth in life. The journey involves learning objectives, work, and other personal and professional aspects.
+
+A promising career is one where you enjoy most (if not all) of your daily work. You see your personal, professional, and financial growth and gradually define what success means to you.
+
+A lousy career is just the opposite. It may pay your bills, but you need more work satisfaction, and measuring your progress and growth becomes hard.
+
+Several factors define a career: promising versus lousy, good versus bad, and successful versus failed. A few of them we can not control – but, we can avoid some career mistakes to build a better career path.
+
+I have spent more than 18 years in Software Engineering and have seen a lot of ups and downs, including in my own career and those of my colleagues. In this article, I will discuss ten career mistakes you should avoid.
+
+Usually, I [share knowledge](https://www.freecodecamp.org/news/author/tapas/) on technical topics like JavaScript, web development, React, Node, Next.js, and so on. But this time, let's connect on essential tips for our Career Development.
+
+If you like to learn from video content as well, this article is also available as a video tutorial here: 🙂
+
+## A Few Things Before We Start
+
+You may or may not agree with all the points. That's fine with me, because what I'm planning to share here is based on my own experiences.
+
+You may strongly agree or disagree with my conclusions, but if there are any additional points that you think I still need to include, please let me know. You can contact me on the social handles I mention at the end of this article.
+
+Also, this article is not only meant for working professionals. All these mistakes we will discuss are relevant for everyone, including students, people seeking jobs, or anyone getting ready for tomorrow in the software industry or any industry.
+
+All set? Let's get started.
+
+## 1\. You Don't Set Realistic Goals
+
+
+
+One of the biggest mistakes most of us make in our careers is not having a goal. What exactly is a goal? It is something like a target.
+
+Let's take an example. Let's say you're going shopping to buy something. You usually have a list of items that you want to get. You don't randomly pick things and come home and feel like, "Oh, it was a complete waste of time and money". So, if that list is your shopping goal, why not have something like this for your career?
+
+Usually, we have a lot of short-term goals, for example,
+
+* I have to fix this bug today.
+* I have to build this project this week.
+* I have to get a promotion this year.
+
+These are great goals to have. But we need to have long-term goals as well. Like, what do you want to be in the long-term in your career. How do you plan every steps to achieve that goal?
+
+Say you are in mechanical engineering, but your heart is in software engineering (mechanical engineering is excellent – I'm just taking this as an example). In that case, you should have a goal for the next few years to translate yourself into a software developer and try to seek more roles more opportunities in the software industry.
+
+I can tell you my story, as I think it'll help give you some perspective. I set myself a long term career goal to transition from my regular multi-national corporation job and start my career full time as an independent teacher and content creator. It took me four years to realize it, but without that goal it would have been impossible for me to chase my passion.
+
+You may ask, will I be able to fulfill all the goals in my life? Well, maybe not. Still, it's important to have some and prioritize the most important ones. That way, even if you can't achieve some, you may identify a few more new goals along the way.
+
+You may have a different way of going about it. But, if you don't have a starting point, you do not have anything to work toward and chase. Your career may become stagnant.
+
+If you don't have any career goals for yourself right now, take some time to come up with a couple realistic goals. Here's some advice on [how to set SMART goals you can actually achieve](https://www.freecodecamp.org/news/how-to-set-smart-goals-you-can-achieve/).
+
+## 2\. You Fail to Recognize Your Potential
+
+
+
+> **Human potential** is the capacity for humans to **improve** themselves through **studying**, **training**, and **practice**, to reach the limit of their ability to develop **aptitudes** and **skills**. – Definition of Human Potential from Wikipedia.
+
+For us, the software developers, is about improving ourselves through practice, training, and study to reach the heights of our ability. But many of us do not know our potential at the start our careers. We figure it out gradually, and when we become aware of it, this helps us improve our careers.
+
+When you know your potential, someone else will not dictate how to shape your career. Instead, you will be able to identify what would be good for you based on your strengths and where you need to bridge the gaps.
+
+But you may ask, "How do I know my potential?". That's where having a goal and working towards it helps. Say you have a goal of mastering machine learning and data science to have a career as a data scientist. As you work towards this goal, you will find the areas where you excel, and other areas where you need to work especially hard. You figure out your potential as you work towards this goal.
+
+Also, try not to settle for unimportant things. Constantly challenge yourself to produce better and more significant outcomes. When you do so, you discover your true potential in a much better way.
+
+## 3\. You Don't Take the Time to Network
+
+
+
+Hey, we're gonna talk about something other than computer networking here. We will focus on human-to-human networking. We are going to talk about socializing. But why?
+
+Networking or socializing with like-minded people, talking to them, and getting inspired by their work are as important as learning to code in programming. You might be a great programmer and fantastic coder. But suppose you do it in a silo. In that case, no one knows you or what you're capable of, so you will most likely lose out on more significant opportunities in your career.
+
+When you socialize and network with others in the tech space, you may find a meaningful community to join. You'll be able to discuss important topics with like-minded people who have interests similar to yours – and this can help you multiply your growth by many times.
+
+This is one mistake I made in my career for several years, as I was unaware of its vast potential. Be active on platforms like LinkedIn, follow people you'd like to connect with on tech Twitter (now X), and make authentic connections with them. Spending mindful time on these platforms, and at in-person events as you're able, can really help boost your career.
+
+Check out the `You Miss Out on Learning Opportunities` section below for some real-life tips on how to reach out and connect with people.
+
+## 4\. You Waste Your Precious Time
+
+
+
+"Wasting time" means not effectively utilizing your time. Would you agree that time is precious? Using and managing your time properly will help your career and life in general.
+
+To clarify, watching a movie, going out with your friends and family, participating in festive activities, and so are not wasting time. You need these to balance out the time you spend working.
+
+Rather, I'm more concerned about the tasks you may have to perform that take away from your "focus time" at work.
+
+Let me walk you through a few situations:
+
+You are working on a task, and here comes some notifications on your phone. You pause whatever you are doing and jump on your phone to see what's happening on that side of the world. The notification may take you 10-15 seconds to read, but you then spend 10 minutes browsing the phone.
+
+This is a habit many of us have built in recent times. And then when you get back to your work, your brain has to recalculate and bring you back to the topic at hand – where you were, and what you were doing – and get you started with the task gain. This context switching is costly, and the same amount of focus may not be possible.
+
+The best way of tackle a situation like this is,
+
+* Switch off the phone's internet while you're working if you do not need it. You can switch it on when you take breaks, maybe at lunch time.
+* You can also set your phone in "Do Not Disturb" mode while your work needs your utmost attention. Just make sure you add some of your family and friend's contacts as emergency contacts so that only a limited set of people can reach out to you during those times in case of any emergencies.
+
+Let's talk about another situation. Suppose you need to prepare and send a design doc to a senior dev for review. But instead, you spend time on something low priority or some little luxury that delayed preparing the doc. You keep postponing until it's become an urgent thing that you'll have to do within a limited time.
+
+This act of delaying something knowingly is called `procrastination`, an ultimate way to kill time. There are some well-known and proven methods to tackle procrastination.
+
+* The first step is to realize and admit to yourself that you procrastinate.
+* Then list out your distractors. This list may vary from person to person. Remove these distractors. It could be your phone, TV, novels, anything.
+* Break down your deliverables into smaller tasks. Achieve them one by one and give yourself a pat on your back once you've finished each small task.
+* Take small breaks and come back to the point where you left off on your task to continue with a fresh brain.
+
+Instead of finding yourself in these types of situations, use your time wisely. If you have to get something done, get it done. When you're procrastinating, something that depends on one task may also get delayed, creating a cycle of time waste, frustrations, and complicated situations.
+
+## 5\. You Neglect Upskilling
+
+
+
+`Upskilling` means getting better at your current skill or acquiring relevant new skills. It is essential to upskill at any and all stages of your career.
+
+One of the common mistakes we make is that we stop upskilling after a few years in our professional life. We get used to the projects, domains, technologies, and environments that create a comfort zone around us. Upskilling is always about coming out of that comfort zone.
+
+Here are a few common excuses we give to ourselves when it comes to upskilling:
+
+* I already have a lot of work at the office or assignments in university.
+* I need to have a personal life.
+* I am happy with whatever I know now, and my work only demands so much.
+* There is so much to learn and it is never ending (sigh!).
+
+But you really don't need that much time in a week to up-skill. You just need to have a plan and to stay consistent in executing it. Set just 1 hour aside in your day. Fork it out from any non-urgent activities and plan your learning schedule in that one hour.
+
+In this one hour, here are some things you can do:
+
+* Assess the gaps, weaknesses, and strengths in your technical and non technical abilities.
+* List them out in a place where you can easily get back to them and make modifications.
+* Prioritize them based on your current needs and near future goals.
+* Time-box each of the items so that you can get something tangible within a specified duration. For example, you want to do a certification on cloud computing within a month, or the Responsive Web Design course from freeCodeCamp over the next few weeks, and so on.
+* Start working on these defined tasks. You may find many resources on internet. Glance over them to create an index of resources that you can understand easily and relate to well.
+* Read and watch tutorials, but also practice hard.
+* Finally, recognize your progress.
+
+You may ask, is that one hour really enough? And I will tell you – it works like magic if you keep it up. Upskilling is not a race or sprint. It needs time, consistency, and perseverance to get from the one end to other.
+
+Have you heard about the power of tiny gains?
+
+
+
+Credit: James Clear
+
+It is a strategy of being just 1% better every day. If you continue to do that for a year, you get almost 38% better at the end of the year. Being 1% worse does the opposite. The strategy was represented in mathematical graphs by James Clear in explanation of [Continuous improvements and how it works](https://jamesclear.com/continuous-improvement).
+
+Upskilling can also help you out a lot if you're preparing for the job search. The way the tech industry is moving, we may not be able to avoid layoffs – but we can be better prepared to get our next job faster. And that becomes much more attainable when you stay relevant and continue learning new things.
+
+## 6\. You Don't Ask for What You Want
+
+
+
+Let me start by sharing an experience of mine. Back in the early 2000s when I was a fresher, I had to attend a meeting with some of the project leads and the manager. We were discussing how to modernize our product with HTML5 features.
+
+I was aware of HTML5, and every time a discussion point was raised, I thought of adding to it, but I didn't. I thought of asking some valuable questions, but I didn't. I felt that in order to ask something in a meeting, I needed a lot of guts! I was wrong.
+
+Oftentimes in your career journey, if you do not ask, you simply won't get what you want or deserve. If someone has some knowledge and you lack it, ask about it. If you have a questiona bout something, ask before you commit to the work. Ask about your promotion, a salary hike, career growth, and anything that is related to your career. There is no such thing as a silly question when it comes to your career growth.
+
+## 7\. You Only Focus on the Money
+
+
+
+Come on, money is important. But is it the only important thing, especially in the context of switching jobs or working towards your career goals? No, certainly not.
+
+When you plan to switch jobs, you also need to look into other factors like work culture, the amount of time you need to spend at the office working, whether it's going to be more stressful compared to the compensation you'll be getting, and so on.
+
+I would certainly look into the following factors along with the compensation (the money part) to make an informed decision about my job switching:
+
+* What will be my technical growth and learning opportunities?
+* What will the work environment be like? Remote/Work From Office/Hybrid? How will that impact me?
+* What skills (both tech and soft) will I be able to learn in the new position?
+* What kind of employee benefits will I get compared to my current organization?
+* Will my work-life balance be impacted positively?
+* What are the company's vision, culture, and values?
+
+Then when you're considering the salary, be careful and make sure you understand the breakdown. What percentage of the CTC comes from any bonus? Is it inclusive or exclusive of CTC? How does the bonus payout happen? If the company doesn't do well in a fiscal year, will you get paid less? Are there stock options or other benefits they pay out instead of cash? All this matters.
+
+The mistake people often make is that they see only the `money` figure as the most important part of a job offer. Make sure you talk to someone from the company, do your research, and learn about what else they're offering as we mentioned above.
+
+## 8\. You Neglect Work-Life Balance
+
+
+
+Another mistake you might make is not balancing your work and life. The last thing you want is to `burn out` at the cost of things you love the most, like your friends, family, and long-term career.
+
+We must learn to prioritize things, and this includes both work and personal life. Your priority list for the day should not have only work related items. While it's important to ship a bug fix, it is also essential to accompany your kids to their soccer games or school plays, or make time to go on a date with your partner, or do something nice for yourself.
+
+Do not be afraid to say "No". At the same time, don't be arrogant when you accept or decline tasks. This is important to keep a healthy work-life balance. When you already have plenty on your plate, trying to accommodate more or do more will only spill over and negatively affect your work-life balance.
+
+So say no when you need to, communicate your intentions ahead of time when possible, and proactively ask for what tasks you'd like to work on when your plate has room for more.
+
+For a long time in my career, I attended meetings late at night to match the timezones of my customers and other colleagues. Then, slowly, it started affecting my health and productivity.
+
+When I thought about it more carefully, I discovered a couple of things. First, I realized that I didn't have to attend all the meetings, and that I could request that they take place in my clients' evenings sometimes. That way we'd both be taking turns compromising. And it worked.
+
+At times, our habits drive us towards the work-life imbalance. For example, staying late at office while the same work can wait till the next morning is a classic example of a habit that may lead to health issues and frustrations in a long run.
+
+We all need to find a way to sustain both work and life. So plan ahead, and stick to your schedule as much as possible. There might be exceptions where you have to give one thing priority above another – but do not allow the exception to become the norm.
+
+## 9\. You Miss Out on Learning Opportunities
+
+
+
+If you have the opportunity to learn from a person who specializes in a particular field, grab it. If you use social media platforms like LinkedIn and X/Twitter wisely, it can lead you to the people who share great insights about subjects you're interested in.
+
+A quick tip for you:
+
+When you send someone a connection request on LinkedIn/X, take some time to introduce yourself. Things that you can mention briefly:
+
+* What did you find unique about the person you want to connect to?
+* A bit about yourself, introducing some of your uniqueness, too.
+* Why do you want to connect?
+
+==Build authentic connections to get the best out of it. Then once you're connected, here are a few things you can do:==
+
+* ==Show interest in their posts.==
+* ==Engage with discussions by commenting or sharing posts.==
+* ==Repost with your thoughts==
+* ==Exchange ideas, or even build things together!==
+
+==A strong social connection may help you in getting information faster. You may learn about a new release of a library/framework/product, how an industry is moving, how certain technologies might impact your work, and so on.==
+
+Apart from learning a lot, you may also get to know about job openings, hirings, and references. After all, companies have also started recruiting talent from social media pages.
+
+Also, being part of a forum like the [freeCodeCamp forum](https://forum.freecodecamp.org/) can be helpful for networking and learning as well. It is also a place for you to share solutions to a problem, talk about what you've learned, and make yourself visible gradually.
+
+When we learn from someone, we not only come to understand what they've achieved or how they did it, but we also learn about the struggles, failures, and how they made the turnaround. Learning from someone else's experience can help accelerate your career journey. Don't make the mistake of living in a silo and missing out on these opportunities.
+
+## 10\. You Can't See the Bigger Picture
+
+
+
+By `Big Picture`(or Bigger Picture), I mean understanding and developing a wider perspective on your career as a whole. It is about your ability to consider and assess many different aspects of a situation, rather than focusing on just the minute details.
+
+As developers, we're supposed to implement features, do bug fixes, maintain code, and deliver quality software to our end-users. That's great!
+
+But, we need to think beyond the individual tasks assigned to us. Our understanding of the overall project goals, the user acceptance criteria, delivery mechanisms, and perspectives of other engineers is key. And so is judging the impact of our work, as it will help us get the big picture of a project.
+
+Suppose your product manager wants your team to build user interfaces that also cater to the needs of specially-abled and visually challenged users. In this case, you and your team members must see the bigger picture around `Accessibility`.
+
+If your designer doesn't define the site's colors accordingly, or the developers do not implement keyboard accessibility along with ARIA roles and attributes, then they're missing the bigger picture.
+
+Another example could be over-optimizing performance while your users do not care about it. Your users may be waiting to get a feature ASAP so it can help them achieve their business goals. But by addressing unnecessary optimizations, you may be delaying that release and missing crucial deadlines.
+
+Missing the bigger picture may lead to a lack of synergy in your organization. It can also result in software products that need multiple iterations to meet customer needs because those needs weren't understood at the beginning. This can cause you to miss deadlines and do more work, and can greatly increase the cost to your client.
+
+Along with understanding "what" tasks you need to perform, also ask "why" your tasks are important and how they will impact the rest of the project or other people's work.
+
+Irrespective of what you build, how big or small it is, how glorified or dull is the outcome, you need to know the impact of it on end users and your internal customers (like product/project managers, quality assurance team, documentation team, whoever).
+
+Once you look at the bigger picture and act accordingly, your margin of error reduces automatically.
+
+## Some More Advice and Wrapping Up
+
+I wanted to share all this career advice with you because I have been on the other side and learned the hard way. Before I move on to write my next article or record my next video, one more quick tip for you: make sure you work to build up your finances.
+
+Financial independence brings peace and the mental stability to think wildly about things you want to pursue in your career. But getting to the point of financial stability is not an overnight thing. You need to plan, save, and invest wisely such that your money grows faster than your age.
+
+I am not a finance expert, but I relied on some good ones and took their suggestions early on. If you have the opportunity and mindset to build your finances for the future, the time is now.
+
+That's all for now. I hope you found this article informative and insightful. I regularly publish meaningful posts on my [GreenRoots Blog](https://blog.greenroots.info/), you may find them helpful, too.
+
+Let's connect.
+
+* I am an educator on my YouTube channel, `tapaScript`. Please [SUBSCRIBE](https://www.youtube.com/tapasadhikary?sub%5Fconfirmation=1) to the channel if you want to learn JavaScript, ReactJS, Next.js, Node.js, Git, and all about Web Development in the fundamental way.
+* [Follow me on X (Twitter](https://twitter.com/tapasadhikary)) or [LinkedIn](https://www.linkedin.com/in/tapasadhikary/) if you don't want to miss the daily dose of Web Development and Programming Tips.
+* Find all my public speaking talks [here](https://www.tapasadhikary.com/talks).
+* Check out and follow my Open Source work on [GitHub](https://github.com/atapas).
+
+See you soon with my next article. Until then, please take care of yourself, and stay happy.
+
+---
+
+---
+
+ 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/)
\ No newline at end of file
diff --git a/Omnivore/2023-11-21 - Conventional Commits.md b/Omnivore/2023-11-21 - Conventional Commits.md
new file mode 100644
index 0000000..049e2db
--- /dev/null
+++ b/Omnivore/2023-11-21 - Conventional Commits.md
@@ -0,0 +1,265 @@
+---
+id: 2a685647-d920-4ba6-b837-3ee29a2f7f10
+title: |
+ Conventional Commits
+status: ARCHIVED
+tags:
+ - read-later
+date_added: 2023-11-21 16:36:37
+url_omnivore: |
+ https://omnivore.app/me/https-www-conventionalcommits-org-en-v-1-0-0-18bf36268eb
+url_original: |
+ https://www.conventionalcommits.org/en/v1.0.0/
+---
+
+# Conventional Commits
+
+## Highlights
+
+The commit message should be structured as follows:
+
+---
+
+```fortran
+[optional scope]:
+
+[optional body]
+
+[optional footer(s)]
+```
+
+[source](https://omnivore.app/me/https-www-conventionalcommits-org-en-v-1-0-0-18bf36268eb#0a71a3f4-0b81-4ccf-849b-f45c65951d5b)
+
+---
+
+## Specification
+
+The key words “MUST”, “MUST NOT”, “REQUIRED”, “SHALL”, “SHALL NOT”, “SHOULD”, “SHOULD NOT”, “RECOMMENDED”, “MAY”, and “OPTIONAL” in this document are to be interpreted as described in [RFC 2119](https://www.ietf.org/rfc/rfc2119.txt).
+
+1. Commits MUST be prefixed with a type, which consists of a noun, `feat`, `fix`, etc., followed by the OPTIONAL scope, OPTIONAL `!`, and REQUIRED terminal colon and space.
+2. The type `feat` MUST be used when a commit adds a new feature to your application or library.
+3. The type `fix` MUST be used when a commit represents a bug fix for your application.
+4. A scope MAY be provided after a type. A scope MUST consist of a noun describing a section of the codebase surrounded by parenthesis, e.g., `fix(parser):`
+5. A description MUST immediately follow the colon and space after the type/scope prefix. The description is a short summary of the code changes, e.g., _fix: array parsing issue when multiple spaces were contained in string_.
+6. A longer commit body MAY be provided after the short description, providing additional contextual information about the code changes. The body MUST begin one blank line after the description.
+7. A commit body is free-form and MAY consist of any number of newline separated paragraphs.
+8. One or more footers MAY be provided one blank line after the body. Each footer MUST consist of a word token, followed by either a `:` or `#` separator, followed by a string value (this is inspired by the[git trailer convention](https://git-scm.com/docs/git-interpret-trailers)).
+9. A footer’s token MUST use `-` in place of whitespace characters, e.g., `Acked-by` (this helps differentiate the footer section from a multi-paragraph body). An exception is made for `BREAKING CHANGE`, which MAY also be used as a token.
+10. A footer’s value MAY contain spaces and newlines, and parsing MUST terminate when the next valid footer token/separator pair is observed.
+11. Breaking changes MUST be indicated in the type/scope prefix of a commit, or as an entry in the footer.
+12. If included as a footer, a breaking change MUST consist of the uppercase text BREAKING CHANGE, followed by a colon, space, and description, e.g.,_BREAKING CHANGE: environment variables now take precedence over config files_.
+13. If included in the type/scope prefix, breaking changes MUST be indicated by a`!` immediately before the `:`. If `!` is used, `BREAKING CHANGE:` MAY be omitted from the footer section, and the commit description SHALL be used to describe the breaking change.
+14. Types other than `feat` and `fix` MAY be used in your commit messages, e.g., _docs: update ref docs._
+15. The units of information that make up Conventional Commits MUST NOT be treated as case sensitive by implementors, with the exception of BREAKING CHANGE which MUST be uppercase.
+16. BREAKING-CHANGE MUST be synonymous with BREAKING CHANGE, when used as a token in a footer.
+
+[source](https://omnivore.app/me/https-www-conventionalcommits-org-en-v-1-0-0-18bf36268eb#5670099d-60fe-4b9c-82b9-814e423c0e61)
+
+---
+
+### What do I do if the commit conforms to more than one of the commit types?
+
+Go back and make multiple commits whenever possible. Part of the benefit of Conventional Commits is its ability to drive us to make more organized commits and PRs.
+
+[source](https://omnivore.app/me/https-www-conventionalcommits-org-en-v-1-0-0-18bf36268eb#6ae81ced-efe6-464a-8026-c2f286faf4b7)
+
+---
+
+### How does this relate to SemVer?
+
+`fix` type commits should be translated to `PATCH` releases. `feat` type commits should be translated to `MINOR` releases. Commits with `BREAKING CHANGE` in the commits, regardless of type, should be translated to `MAJOR` releases.
+
+[source](https://omnivore.app/me/https-www-conventionalcommits-org-en-v-1-0-0-18bf36268eb#6876934a-5761-49f8-8905-3153e5d667b7)
+
+---
+
+## Original
+
+## [](#summary)Summary
+
+The Conventional Commits specification is a lightweight convention on top of commit messages. It provides an easy set of rules for creating an explicit commit history; which makes it easier to write automated tools on top of. This convention dovetails with [SemVer](http://semver.org/), by describing the features, fixes, and breaking changes made in commit messages.
+
+==The commit message should be structured as follows:==
+
+---
+
+```fortran
+[optional scope]:
+
+[optional body]
+
+[optional footer(s)]
+
+```
+
+---
+
+The commit contains the following structural elements, to communicate intent to the consumers of your library:
+
+1. **fix:** a commit of the _type_ `fix` patches a bug in your codebase (this correlates with [PATCH](http://semver.org/#summary) in Semantic Versioning).
+2. **feat:** a commit of the _type_ `feat` introduces a new feature to the codebase (this correlates with [MINOR](http://semver.org/#summary) in Semantic Versioning).
+3. **BREAKING CHANGE:** a commit that has a footer `BREAKING CHANGE:`, or appends a `!` after the type/scope, introduces a breaking API change (correlating with [MAJOR](http://semver.org/#summary) in Semantic Versioning). A BREAKING CHANGE can be part of commits of any _type_.
+4. _types_ other than `fix:` and `feat:` are allowed, for example [@commitlint/config-conventional](https://github.com/conventional-changelog/commitlint/tree/master/%40commitlint/config-conventional) (based on the [Angular convention](https://github.com/angular/angular/blob/22b96b9/CONTRIBUTING.md#-commit-message-guidelines)) recommends `build:`, `chore:`,`ci:`, `docs:`, `style:`, `refactor:`, `perf:`, `test:`, and others.
+5. _footers_ other than `BREAKING CHANGE: ` may be provided and follow a convention similar to[git trailer format](https://git-scm.com/docs/git-interpret-trailers).
+
+Additional types are not mandated by the Conventional Commits specification, and have no implicit effect in Semantic Versioning (unless they include a BREAKING CHANGE).A scope may be provided to a commit’s type, to provide additional contextual information and is contained within parenthesis, e.g., `feat(parser): add ability to parse arrays`.
+
+## [](#examples)Examples
+
+### [](#commit-message-with-description-and-breaking-change-footer)Commit message with description and breaking change footer
+
+```routeros
+feat: allow provided config object to extend other configs
+
+BREAKING CHANGE: `extends` key in config file is now used for extending other config files
+
+```
+
+### [](#commit-message-with--to-draw-attention-to-breaking-change)Commit message with `!` to draw attention to breaking change
+
+```routeros
+feat!: send an email to the customer when a product is shipped
+
+```
+
+### [](#commit-message-with-scope-and--to-draw-attention-to-breaking-change)Commit message with scope and `!` to draw attention to breaking change
+
+```routeros
+feat(api)!: send an email to the customer when a product is shipped
+
+```
+
+### [](#commit-message-with-both--and-breaking-change-footer)Commit message with both `!` and BREAKING CHANGE footer
+
+```crmsh
+chore!: drop support for Node 6
+
+BREAKING CHANGE: use JavaScript features not available in Node 6.
+
+```
+
+### [](#commit-message-with-no-body)Commit message with no body
+
+```avrasm
+docs: correct spelling of CHANGELOG
+
+```
+
+### [](#commit-message-with-scope)Commit message with scope
+
+```stylus
+feat(lang): add Polish language
+
+```
+
+### [](#commit-message-with-multi-paragraph-body-and-multiple-footers)Commit message with multi-paragraph body and multiple footers
+
+```http
+fix: prevent racing of requests
+
+Introduce a request id and a reference to latest request. Dismiss
+incoming responses other than from latest request.
+
+Remove timeouts which were used to mitigate the racing issue but are
+obsolete now.
+
+Reviewed-by: Z
+Refs: #123
+
+```
+
+## [](#specification)==Specification==
+
+==The key words “MUST”, “MUST NOT”, “REQUIRED”, “SHALL”, “SHALL NOT”, “SHOULD”, “SHOULD NOT”, “RECOMMENDED”, “MAY”, and “OPTIONAL” in this document are to be interpreted as described in== ==[RFC 2119](https://www.ietf.org/rfc/rfc2119.txt)====.==
+
+1. ==Commits MUST be prefixed with a type, which consists of a noun,== `==feat==`==,== `==fix==`==, etc., followed
+by the OPTIONAL scope, OPTIONAL== `==!==`==, and REQUIRED terminal colon and space.==
+2. ==The type== `==feat==` ==MUST be used when a commit adds a new feature to your application or library.==
+3. ==The type== `==fix==` ==MUST be used when a commit represents a bug fix for your application.==
+4. ==A scope MAY be provided after a type. A scope MUST consist of a noun describing a
+section of the codebase surrounded by parenthesis, e.g.,== `==fix====(parser)====:==`
+5. ==A description MUST immediately follow the colon and space after the type/scope prefix.
+The description is a short summary of the code changes, e.g.,== _==fix: array parsing issue when multiple spaces were contained in string==_==.==
+6. ==A longer commit body MAY be provided after the short description, providing additional contextual information about the code changes. The body MUST begin one blank line after the description.==
+7. ==A commit body is free-form and MAY consist of any number of newline separated paragraphs.==
+8. ==One or more footers MAY be provided one blank line after the body. Each footer MUST consist of
+a word token, followed by either a== `==:====<====space====>==` ==or== `==<====space====>====#==` ==separator, followed by a string value (this is inspired by the====[git trailer convention](https://git-scm.com/docs/git-interpret-trailers)====).==
+9. ==A footer’s token MUST use== `==-==` ==in place of whitespace characters, e.g.,== `==Acked-====by==` ==(this helps differentiate
+the footer section from a multi-paragraph body). An exception is made for== `==BREAKING== ==CHANGE==`==, which MAY also be used as a token.==
+10. ==A footer’s value MAY contain spaces and newlines, and parsing MUST terminate when the next valid footer
+token/separator pair is observed.==
+11. ==Breaking changes MUST be indicated in the type/scope prefix of a commit, or as an entry in the
+footer.==
+12. ==If included as a footer, a breaking change MUST consist of the uppercase text BREAKING CHANGE, followed by a colon, space, and description, e.g.,==_==BREAKING CHANGE: environment variables now take precedence over config files==_==.==
+13. ==If included in the type/scope prefix, breaking changes MUST be indicated by a==`==!==` ==immediately before the== `==:==`==. If== `==!==` ==is used,== `==BREAKING== ==CHANGE:==` ==MAY be omitted from the footer section,
+and the commit description SHALL be used to describe the breaking change.==
+14. ==Types other than== `==feat==` ==and== `==fix==` ==MAY be used in your commit messages, e.g.,== _==docs: update ref docs.==_
+15. ==The units of information that make up Conventional Commits MUST NOT be treated as case sensitive by implementors, with the exception of BREAKING CHANGE which MUST be uppercase.==
+16. ==BREAKING-CHANGE MUST be synonymous with BREAKING CHANGE, when used as a token in a footer.==
+
+## [](#why-use-conventional-commits)Why Use Conventional Commits
+
+* Automatically generating CHANGELOGs.
+* Automatically determining a semantic version bump (based on the types of commits landed).
+* Communicating the nature of changes to teammates, the public, and other stakeholders.
+* Triggering build and publish processes.
+* Making it easier for people to contribute to your projects, by allowing them to explore a more structured commit history.
+
+## [](#faq)FAQ
+
+### [](#how-should-i-deal-with-commit-messages-in-the-initial-development-phase)How should I deal with commit messages in the initial development phase?
+
+We recommend that you proceed as if you’ve already released the product. Typically _somebody_, even if it’s your fellow software developers, is using your software. They’ll want to know what’s fixed, what breaks etc.
+
+### [](#are-the-types-in-the-commit-title-uppercase-or-lowercase)Are the types in the commit title uppercase or lowercase?
+
+Any casing may be used, but it’s best to be consistent.
+
+### [](#what-do-i-do-if-the-commit-conforms-to-more-than-one-of-the-commit-types)==What do I do if the commit conforms to more than one of the commit types?==
+
+==Go back and make multiple commits whenever possible. Part of the benefit of Conventional Commits is its ability to drive us to make more organized commits and PRs.==
+
+### [](#doesnt-this-discourage-rapid-development-and-fast-iteration)Doesn’t this discourage rapid development and fast iteration?
+
+It discourages moving fast in a disorganized way. It helps you be able to move fast long term across multiple projects with varied contributors.
+
+### [](#might-conventional-commits-lead-developers-to-limit-the-type-of-commits-they-make-because-theyll-be-thinking-in-the-types-provided)Might Conventional Commits lead developers to limit the type of commits they make because they’ll be thinking in the types provided?
+
+Conventional Commits encourages us to make more of certain types of commits such as fixes. Other than that, the flexibility of Conventional Commits allows your team to come up with their own types and change those types over time.
+
+### [](#how-does-this-relate-to-semver)==How does this relate to SemVer?==
+
+`==fix==` ==type commits should be translated to== `==PATCH==` ==releases.== `==feat==` ==type commits should be translated to== `==MINOR==` ==releases. Commits with== `==BREAKING== ==CHANGE==` ==in the commits, regardless of type, should be translated to== `==MAJOR==` ==releases.==
+
+### [](#how-should-i-version-my-extensions-to-the-conventional-commits-specification-eg-jameswomackconventional-commit-spec)How should I version my extensions to the Conventional Commits Specification, e.g. `@jameswomack/conventional-commit-spec`?
+
+We recommend using SemVer to release your own extensions to this specification (and encourage you to make these extensions!)
+
+### [](#what-do-i-do-if-i-accidentally-use-the-wrong-commit-type)What do I do if I accidentally use the wrong commit type?
+
+#### [](#when-you-used-a-type-thats-of-the-spec-but-not-the-correct-type-eg-fix-instead-of-feat)When you used a type that’s of the spec but not the correct type, e.g. `fix` instead of `feat`
+
+Prior to merging or releasing the mistake, we recommend using `git rebase -i` to edit the commit history. After release, the cleanup will be different according to what tools and processes you use.
+
+#### [](#when-you-used-a-type-not-of-the-spec-eg-feet-instead-of-feat)When you used a type _not_ of the spec, e.g. `feet` instead of `feat`
+
+In a worst case scenario, it’s not the end of the world if a commit lands that does not meet the Conventional Commits specification. It simply means that commit will be missed by tools that are based on the spec.
+
+### [](#do-all-my-contributors-need-to-use-the-conventional-commits-specification)Do all my contributors need to use the Conventional Commits specification?
+
+No! If you use a squash based workflow on Git lead maintainers can clean up the commit messages as they’re merged—adding no workload to casual committers. A common workflow for this is to have your git system automatically squash commits from a pull request and present a form for the lead maintainer to enter the proper git commit message for the merge.
+
+### [](#how-does-conventional-commits-handle-revert-commits)How does Conventional Commits handle revert commits?
+
+Reverting code can be complicated: are you reverting multiple commits? if you revert a feature, should the next release instead be a patch?
+
+Conventional Commits does not make an explicit effort to define revert behavior. Instead we leave it to tooling authors to use the flexibility of _types_ and _footers_ to develop their logic for handling reverts.
+
+One recommendation is to use the `revert` type, and a footer that references the commit SHAs that are being reverted:
+
+```http
+revert: let us never again speak of the noodle incident
+
+Refs: 676104e, a215868
+
+```
\ No newline at end of file
diff --git a/Omnivore/2023-11-21 - How to Write Better Git Commit Messages – A Step-By-Step Guide.md b/Omnivore/2023-11-21 - How to Write Better Git Commit Messages – A Step-By-Step Guide.md
new file mode 100644
index 0000000..21b2a18
--- /dev/null
+++ b/Omnivore/2023-11-21 - How to Write Better Git Commit Messages – A Step-By-Step Guide.md
@@ -0,0 +1,253 @@
+---
+id: 1996b6ce-9449-415d-8c18-609ddb9cd580
+title: |
+ How to Write Better Git Commit Messages – A Step-By-Step Guide
+status: ARCHIVED
+tags:
+ - read-later
+date_added: 2023-11-21 12:10:32
+url_omnivore: |
+ https://omnivore.app/me/https-www-freecodecamp-org-news-how-to-write-better-git-commit-m-18bf26ec55f
+url_original: |
+ https://www.freecodecamp.org/news/how-to-write-better-git-commit-messages/
+---
+
+# How to Write Better Git Commit Messages – A Step-By-Step Guide
+
+## Highlights
+
+To come up with thoughtful commits, consider the following:
+
+* Why have I made these changes?
+* What effect have my changes made?
+* Why was the change needed?
+* What are the changes in reference to?
+
+[source](https://omnivore.app/me/https-www-freecodecamp-org-news-how-to-write-better-git-commit-m-18bf26ec55f#b1693951-0a92-44f4-804d-7c5008bf3113)
+
+---
+
+See the differences below:
+
+1. `git commit -m 'Add margin'`
+2. `git commit -m 'Add margin to nav items to prevent them from overlapping the logo'`
+
+[source](https://omnivore.app/me/https-www-freecodecamp-org-news-how-to-write-better-git-commit-m-18bf26ec55f#a3c842a2-18b0-46b9-8131-c37ecd867c19)
+
+---
+
+Conventional Commit is a formatting convention that provides a set of rules to formulate a consistent commit message structure like so:
+
+```fortran
+[optional scope]:
+
+[optional body]
+
+[optional footer(s)]
+```
+
+The commit type can include the following:
+
+* `feat` – a new feature is introduced with the changes
+* `fix` – a bug fix has occurred
+* `chore` – changes that do not relate to a fix or feature and don't modify src or test files (for example updating dependencies)
+* `refactor` – refactored code that neither fixes a bug nor adds a feature
+* `docs` – updates to documentation such as a the README or other markdown files
+* `style` – changes that do not affect the meaning of the code, likely related to code formatting such as white-space, missing semi-colons, and so on.
+* `test` – including new or correcting previous tests
+* `perf` – performance improvements
+* `ci` – continuous integration related
+* `build` – changes that affect the build system or external dependencies
+* `revert` – reverts a previous commit
+
+[source](https://omnivore.app/me/https-www-freecodecamp-org-news-how-to-write-better-git-commit-m-18bf26ec55f#f3ea8f19-6480-43ac-a72f-2856ee003fb6)
+
+---
+
+## Original
+
+
+
+When first introduced to Git, it's typical for developers to feel uncomfortable with the process.
+
+You might feel uncertainty when encountering the Git commit message, unsure how to properly summarize the changes you've made and why you've made them. But the earlier in your career you can develop good committing habits, the better.
+
+Have you ever wondered how you can improve your Git commit messages? This guide outlines steps to elevate your commit messages that you can start implementing today.
+
+This article assumes you already understand basic Git workflow. If not, I suggest reading through the [Git Handbook](https://guides.github.com/introduction/git-handbook/).
+
+It is also important to note that you should follow your team's conventions first and foremost. These tips are based on suggestions based upon research and general consensus from the community. But by the end of this article you may have some implementations to suggest that may help your team's workflow.
+
+> I think git enters a whole other realm the moment you start working in teams -- there are so many cool different flows and ways that people can commit code, share code, and add code to your repo open-source or closed-source-wise. — [Scott Tolinski, Syntax.fm](https://syntax.fm/).
+
+## Why should you write better commit messages?
+
+I challenge you to open up a personal project or any repository for that matter and run `git log` to view a list of old commit messages. The vast majority of us who have run through tutorials or made quick fixes will say "Yep... I have absolutely no idea what I meant by 'Fix style' 6 months ago."
+
+Perhaps you have encountered code in a professional environment where you had no idea what it was doing or meant for. You've been left in the dark without code comments or a traceable history, and even wondering "what are the odds this will break everything if I remove this line?"
+
+### Back to the Future
+
+By writing good commits, you are simply future-proofing yourself. You could save yourself and/or coworkers hours of digging around while troubleshooting by providing that helpful description.
+
+The extra time it takes to write a thoughtful commit message as a letter to your potential future self is extremely worthwhile. On large scale projects, documentation is imperative for maintenance.
+
+Collaboration and communication are of utmost importance within engineering teams. The Git commit message is a prime example of this. I highly suggest setting up a convention for commit messages on your team if you do not already have one in place.
+
+## The Anatomy of a Commit Message
+
+#### Basic:
+
+`git commit -m `
+
+#### Detailed:
+
+`git commit -m -m <description>`
+
+
+
+## 5 Steps to Write Better Commit Messages
+
+ Let's summarize the suggested guidelines:
+
+1. Capitalization and Punctuation: Capitalize the first word and do not end in punctuation. If using Conventional Commits, remember to use all lowercase.
+2. Mood: Use imperative mood in the subject line. Example – `Add fix for dark mode toggle state`. Imperative mood gives the tone you are giving an order or request.
+3. Type of Commit: Specify the type of commit. It is recommended and can be even more beneficial to have a consistent set of words to describe your changes. Example: Bugfix, Update, Refactor, Bump, and so on. See the section on Conventional Commits below for additional information.
+4. Length: The first line should ideally be no longer than 50 characters, and the body should be restricted to 72 characters.
+5. Content: Be direct, try to eliminate filler words and phrases in these sentences (examples: though, maybe, I think, kind of). Think like a journalist.
+
+### How to Find Your Inner Journalist
+
+I never quite thought my Journalism minor would benefit my future career as a Software Engineer, but here we are!
+
+Journalists and writers ask themselves questions to ensure their article is detailed, straightforward, and answers all of the reader's questions.
+
+When writing an article they look to answer _who_, _what_, _where_, _when_, _why_ and _how._ For committing purposes, it is most important to answer the what and why for our commit messages.
+
+==To come up with thoughtful commits, consider the following:==
+
+* ==Why have I made these changes?==
+* ==What effect have my changes made?==
+* ==Why was the change needed?==
+* ==What are the changes in reference to?==
+
+Assume the reader does not understand what the commit is addressing. They may not have access to the story addressing the detailed background of the change.
+
+Don't expect the code to be self-explanatory. This is similar to the point above.
+
+It might seem obvious to you, the programmer, if you're updating something like CSS styles since it is visual. You may have intimate knowledge on why these changes were needed at the time, but it's unlikely you will recall why you did that hundreds of pull requests later.
+
+Make it clear _why_ that change was made, and note if it may be crucial for the functionality or not.
+
+==See the differences below:==
+
+1. `==git== ==commit -m== =='Add margin'==`
+2. `==git commit -m 'Add margin== ==to== ==nav items== ==to== ==prevent them== ==from== ==overlapping== ==the== ==logo'==`
+
+It is clear which of these would be more useful to future readers.
+
+Pretend you're writing an important newsworthy article. Give the headline that will sum up what happened and what is important. Then, provide further details in the body in an organized fashion.
+
+In filmmaking, it is often quoted "show, don't tell" using visuals as the communication medium compared to a verbal explanation of what is happening.
+
+In our case, "**tell**, don't \[just\] show" – though we have some visuals at our disposal such as the browser, most of the specifics come from reading the physical code.
+
+If you're a VSCode user, download the [Git Blame](https://marketplace.visualstudio.com/items?itemName=waderyan.gitblame) extension. This is a prime example of when useful commit messages are helpful to future developers.
+
+This plugin will list the person who made the change, the date of the changes, as well as the commit message commented inline.
+
+Imagine how useful this could be in troubleshooting a bug or back-tracing changes made. Other honorable mentions to see Git historical information are [Git History](https://marketplace.visualstudio.com/items?itemName=donjayamanne.githistory) and [GitLens](https://marketplace.visualstudio.com/items?itemName=eamodio.gitlens).
+
+
+
+## Conventional Commits
+
+Now that we've covered basic commit structure of a good commit message, I'd like to introduce Conventional Commits to help provide some detail on creating solid commit messages.
+
+At D2iQ, we use Conventional Commit which is a great practice among engineering teams. ==Conventional Commit is a formatting convention that provides a set of rules to formulate a consistent commit message structure like so:==
+
+```fortran
+<type>[optional scope]: <description>
+
+[optional body]
+
+[optional footer(s)]
+```
+
+==The commit type can include the following:==
+
+* `==feat==` ==– a new feature is introduced with the changes==
+* `==fix==` ==– a bug fix has occurred==
+* `==chore==` ==– changes that do not relate to a fix or feature and don't modify src or test files (for example updating dependencies)==
+* `==ref====actor==` ==– refactored code that neither fixes a bug nor adds a feature==
+* `==docs==` ==– updates to documentation such as a the README or other markdown files==
+* `==style==` ==– changes that do not affect the meaning of the code, likely related to code formatting such as white-space, missing semi-colons, and so on.==
+* `==test==` ==– including new or correcting previous tests==
+* `==perf==` ==– performance improvements==
+* `==ci==` ==– continuous integration related==
+* `==build==` ==– changes that affect the build system or external dependencies==
+* `==revert==` ==– reverts a previous commit==
+
+The commit type subject line should be all lowercase with a character limit to encourage succinct descriptions.
+
+The optional commit body should be used to provide further detail that cannot fit within the character limitations of the subject line description.
+
+It is also a good location to utilize `BREAKING CHANGE: <description>` to note the reason for a breaking change within the commit.
+
+The footer is also optional. We use the footer to link the JIRA story that would be closed with these changes for example: `Closes D2IQ-<JIRA #>` .
+
+#### Full Conventional Commit Example
+
+```http
+fix: fix foo to enable bar
+
+This fixes the broken behavior of the component by doing xyz.
+
+BREAKING CHANGE
+Before this fix foo wasn't enabled at all, behavior changes from <old> to <new>
+
+Closes D2IQ-12345
+```
+
+To ensure that these committing conventions remain consistent across developers, commit message linting can be configured before changes are able to be pushed up. [Commitizen](https://commitizen-tools.github.io/commitizen/) is a great tool to enforce standards, sync up semantic versioning, along with other helpful features.
+
+To aid in adoption of these conventions, it's helpful to include guidelines for commits in a contributing or README markdown file within your projects.
+
+Conventional Commit works particularly well with semantic versioning (learn more at [SemVer.org](https://semver.org/)) where commit types can update the appropriate version to release. You can also [read more about Conventional Commits here](https://www.conventionalcommits.org/en/v1.0.0/).
+
+## Commit Message Comparisons
+
+Review the following messages and see how many of the suggested guidelines they check off in each category.
+
+#### Good
+
+* `feat: improve performance with lazy load implementation for images`
+* `chore: update npm dependency to latest version`
+* `Fix bug preventing users from submitting the subscribe form`
+* `Update incorrect client phone number within footer body per client request`
+
+#### Bad
+
+* `fixed bug on landing page`
+* `Changed style`
+* `oops`
+* `I think I fixed it this time?`
+* empty commit messages
+
+## Conclusion
+
+Writing good commit messages is an extremely beneficial skill to develop, and it helps you communicate and collaborate with your team. Commits serve as an archive of changes. They can become an ancient manuscript to help us decipher the past, and make reasoned decisions in the future.
+
+There is an existing set of agreed-upon standards we can follow, but as long as your team agrees upon a convention that is descriptive with future readers in mind, there will undoubtedly be long-term benefits.
+
+In this article, we've learned some tactics to level up our commit messages. How do you think these techniques can improve your commits?
+
+I hope you've learned something new, thanks for reading!
+
+Connect with me on Twitter [@ui\_natalie](https://twitter.com/ui%5Fnatalie).
+
+---
+
+---
+
+ 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/)
\ No newline at end of file
diff --git a/Omnivore/2023-11-21 - The Life-Changing Magic of Tidying Up Your To-Do List.md b/Omnivore/2023-11-21 - The Life-Changing Magic of Tidying Up Your To-Do List.md
new file mode 100644
index 0000000..cd1d95f
--- /dev/null
+++ b/Omnivore/2023-11-21 - The Life-Changing Magic of Tidying Up Your To-Do List.md
@@ -0,0 +1,55 @@
+---
+id: f5956559-3eb2-4717-93bd-3f3a2f0c5549
+title: |
+ The Life-Changing Magic of Tidying Up Your To-Do List
+status: ARCHIVED
+tags:
+ - read-later
+date_added: 2023-11-21 08:05:01
+url_omnivore: |
+ https://omnivore.app/me/https-todoist-com-inspiration-life-changing-magic-tidying-todois-18bf18e00a2
+url_original: |
+ https://todoist.com/inspiration/life-changing-magic-tidying-todoist
+---
+
+# The Life-Changing Magic of Tidying Up Your To-Do List
+
+## Notes
+
+Before you even start looking at your tasks, write down what having a neatly organized and prioritized to-do list would mean for your life. Maybe you want to run a successful business, get in shape, be more present with your family, have closer relationships with friends, or lead a more adventurous life.
+
+Find a medium that lets you truly envision the details. You can describe it in words, mind map it, draw it out, create a Pinterest board, collect YouTube videos, or brainstorm in whatever form suits you.
+
+Why do you want to get in shape? The answer might be "to have more energy and feel more confident." Why do you want to have more energy and feel more confident? Maybe the answer is "to be more fully yourself and stop worrying about what other people think of you." Ask yourself "why" 3-5 times for every item in your vision.
+## Original
+
+---
+
+## Other readers also enjoyed...
+
+
+
+## How to Vanquish Busywork and Spend More Time on What Matters
+
+These tips for improving your focus and productivity will help you avoid getting sucked into busywork.
+
+[Read more](https://todoist.com/inspiration/busywork-productivity-focus)
+* [Productivity](https://todoist.com/inspiration/category/productivity)
+
+
+
+## How to Ask to Work From Home (With Exact Scripts & Email Templates to Aid Your Negotiation)
+
+Follow these 9 steps to secure a remote work arrangement even in the most skeptical of organizations
+
+[Read more](https://todoist.com/inspiration/how-to-ask-to-work-from-home)
+* [Remote Work](https://todoist.com/inspiration/category/remote-work)
+
+
+
+## How to Complete Your Own Annual Review
+
+Reflect on work, health, finances, and more with a personal year in review
+
+[Read more](https://todoist.com/inspiration/annual-review)
+* [Goals](https://todoist.com/inspiration/category/goals)
\ No newline at end of file
diff --git a/Omnivore/2023-11-21 - tbaggery - A Note About Git Commit Messages.md b/Omnivore/2023-11-21 - tbaggery - A Note About Git Commit Messages.md
new file mode 100644
index 0000000..60aeae3
--- /dev/null
+++ b/Omnivore/2023-11-21 - tbaggery - A Note About Git Commit Messages.md
@@ -0,0 +1,79 @@
+---
+id: 01b3b6c1-27ae-40a4-99fa-d297febc1e7c
+title: |
+ tbaggery - A Note About Git Commit Messages
+status: ARCHIVED
+tags:
+ - read-later
+date_added: 2023-11-21 11:59:10
+url_omnivore: |
+ https://omnivore.app/me/https-tbaggery-com-2008-04-19-a-note-about-git-commit-messages-h-18bf2646727
+url_original: |
+ https://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html
+---
+
+# tbaggery - A Note About Git Commit Messages
+
+## Notes
+
+- Tratar de mantener el limite que muestra Treesitter
+- Utilizar la primera linea como "el asunto de un correo"
+- Escribir el cuerpo con una separación de una linea en blanco
+- Usar lenguaje imperativo, _"Fix bug"_ en vez de _"Fixes bug."_.
+## Original
+
+I want to take a moment to elaborate on what makes a well formed commit message. I think the best practices for commit message formatting is one of the little details that makes Git great. Understandably, some of the first commits to rails.git have messages of the really-long-line variety, and I want to expand on why this is a poor practice.
+
+Here’s a model Git commit message:
+
+```livecodeserver
+Capitalized, short (50 chars or less) summary
+
+More detailed explanatory text, if necessary. Wrap it to about 72
+characters or so. In some contexts, the first line is treated as the
+subject of an email and the rest of the text as the body. The blank
+line separating the summary from the body is critical (unless you omit
+the body entirely); tools like rebase can get confused if you run the
+two together.
+
+Write your commit message in the imperative: "Fix bug" and not "Fixed bug"
+or "Fixes bug." This convention matches up with commit messages generated
+by commands like git merge and git revert.
+
+Further paragraphs come after blank lines.
+
+- Bullet points are okay, too
+
+- Typically a hyphen or asterisk is used for the bullet, followed by a
+ single space, with blank lines in between, but conventions vary here
+
+- Use a hanging indent
+
+```
+
+Let’s start with a few of the reasons why wrapping your commit messages to 72 columns is a good thing.
+
+* `git log` doesn’t do any special special wrapping of the commit messages. With the default pager of `less -S`, this means your paragraphs flow far off the edge of the screen, making them difficult to read. On an 80 column terminal, if we subtract 4 columns for the indent on the left and 4 more for symmetry on the right, we’re left with 72 columns.
+* `git format-patch --stdout` converts a series of commits to a series of emails, using the messages for the message body. Good email netiquette dictates we wrap our plain text emails such that there’s room for a few levels of nested reply indicators without overflow in an 80 column terminal. (The current rails.git workflow doesn’t include email, but who knows what the future will bring.)
+
+Vim users can meet this requirement by installing my [vim-git runtime files](http://github.com/tpope/vim-git), or by simply setting the following option in your git commit message file:
+
+For Textmate, you can adjust the “Wrap Column” option under the view menu, then use `^Q` to rewrap paragraphs (be sure there’s a blank line afterwards to avoid mixing in the comments). Here’s a shell command to add 72 to the menu so you don’t have to drag to select each time:
+
+```lsl
+$ defaults write com.macromates.textmate OakWrapColumns '( 40, 72, 78 )'
+
+```
+
+More important than the mechanics of formatting the body is the practice of having a subject line. As the example indicates, you should shoot for about 50 characters (though this isn’t a hard maximum) and always, always follow it with a blank line. This first line should be a concise summary of the changes introduced by the commit; if there are any technical details that cannot be expressed in these strict size constraints, put them in the body instead. The subject line is used all over Git, oftentimes in truncated form if too long of a message was used. The following are just a handful of examples of where it ends up:
+
+* `git log --pretty=oneline` shows a terse history mapping containing the commit id and the summary
+* `git rebase --interactive` provides the summary for each commit in the editor it invokes
+* if the config option `merge.summary` is set, the summaries from all merged commits will make their way into the merge commit message
+* `git shortlog` uses summary lines in the changelog-like output it produces
+* `git format-patch`, `git send-email`, and related tools use it as the subject for emails
+* reflogs, a local history accessible with `git reflog` intended to help you recover from stupid mistakes, get a copy of the summary
+* `gitk` has a column for the summary
+* GitHub uses the summary in various places in their user interface
+
+The subject/body distinction may seem unimportant but it’s one of many subtle factors that makes Git history so much more pleasant to work with than Subversion.
\ No newline at end of file
diff --git a/Omnivore/2023-12-24 - Historias de usuario - Ejemplos y plantilla - Atlassian.md b/Omnivore/2023-12-24 - Historias de usuario - Ejemplos y plantilla - Atlassian.md
new file mode 100644
index 0000000..828f3af
--- /dev/null
+++ b/Omnivore/2023-12-24 - Historias de usuario - Ejemplos y plantilla - Atlassian.md
@@ -0,0 +1,182 @@
+---
+id: a82f2e4b-829e-48a5-9e5c-c152860743a7
+title: |
+ Historias de usuario | Ejemplos y plantilla | Atlassian
+status: ARCHIVED
+tags:
+ - read-later
+date_added: 2023-12-24 18:35:22
+url_omnivore: |
+ https://omnivore.app/me/https-www-atlassian-com-es-agile-project-management-user-stories-18c9dc0ecd1
+url_original: |
+ https://www.atlassian.com/es/agile/project-management/user-stories
+---
+
+# Historias de usuario | Ejemplos y plantilla | Atlassian
+
+## Highlights
+
+una historia de usuario es una explicación general e informal de una función de software escrita desde la perspectiva del usuario final. Su propósito es articular cómo proporcionará una función de software valor al cliente.
+
+[source](https://omnivore.app/me/https-www-atlassian-com-es-agile-project-management-user-stories-18c9dc0ecd1#d1988eb3-4939-4bf3-b932-44aad141c065)
+
+---
+
+Las historias encajan perfectamente en marcos ágiles como [scrum](https://www.atlassian.com/es/agile/scrum) y [kanban](https://www.atlassian.com/es/agile/kanban). En el scrum, las historias de los usuarios se añaden a los sprints y se van realizando a lo largo del sprint. Los equipos de kanban incorporan las historias de usuario en su backlog y las ejecutan siguiendo su flujo de trabajo.
+
+[source](https://omnivore.app/me/https-www-atlassian-com-es-agile-project-management-user-stories-18c9dc0ecd1#3e9e29ab-43db-4c8f-b517-c2f3b8892432)
+
+---
+
+Las historias de usuario son también los componentes básicos de los marcos ágiles más grandes, como los epics y las iniciativas. Los epics son grandes elementos de trabajo divididos en un conjunto de historias, y varios epics constituyen una iniciativa.
+
+[source](https://omnivore.app/me/https-www-atlassian-com-es-agile-project-management-user-stories-18c9dc0ecd1#8f41f654-4b72-4789-b848-b46c2d185291)
+
+---
+
+## Cómo escribir historias de usuario
+
+Piensa en lo siguiente cuando escribas historias de usuario:
+
+* **Definición de “Listo”**: la historia suele estar “lista” cuando el usuario puede completar la tarea descrita, pero debes asegurarte de definir lo que representa completarla.
+* **Describe tareas o subtareas**: decide qué pasos específicos deben completarse y quién es responsable de cada uno de ellos.
+* **Perfiles de usuario**: ¿para quién? Si hay varios usuarios finales, considera crear varias historias.
+* **Pasos ordenados**: escribe una historia para cada paso en un proceso más grande.
+* **Escucha el feedback**: habla con los usuarios y capta sus problemas o necesidades en lo que dicen. No es necesario tener que estar adivinando las historias cuando puedes obtenerlas de tus clientes.
+* **Tiempo**: el tiempo es un tema delicado. Muchos equipos de desarrollo evitan hablar sobre el tiempo, y en su lugar confían en sus marcos de trabajo de estimación. Dado que las historias deberían completarse en un sprint, aquellas que puedan necesitar semanas o meses deberían dividirse en historias más pequeñas o considerarse un epic independiente.
+
+[source](https://omnivore.app/me/https-www-atlassian-com-es-agile-project-management-user-stories-18c9dc0ecd1#536ca974-d30c-4d48-a02f-a9c16c469e01)
+
+---
+
+Las historias de usuario suelen expresarse con una frase simple con la siguiente estructura:
+
+**“Como \[perfil\], \[quiero\] \[para\].”**
+
+Desglosemos esta estructura:
+
+* “Como \[perfil\]”: ¿para quién desarrollamos esto? No solo buscamos un puesto, buscamos el perfil de la persona. Max. Nuestro equipo debería comprender quién es Max. Con suerte hemos entrevistado a muchos Max. Comprendemos cómo trabaja esa persona, cómo piensa y cómo se siente. Sentimos empatía por Max.
+* “Quiere”: aquí describimos su intención, no las funciones que usan. ¿Qué es lo que están intentando lograr realmente? Esta descripción debería realizarse con independencia de las implementaciones; si describes algún elemento de la IU y no el objetivo del usuario, estás cometiendo un error.
+* “Para”: ¿cómo encaja su deseo inmediato de hacer algo en la perspectiva general? ¿Cuál es el beneficio general que intentan lograr? ¿Cuál es el gran problema que debe resolverse?
+
+[source](https://omnivore.app/me/https-www-atlassian-com-es-agile-project-management-user-stories-18c9dc0ecd1#74f6051c-6394-4c99-94c9-176857d9caf2)
+
+---
+
+## Original
+
+* [DevOps](#)
+ * [Entrega continua](https://www.atlassian.com/es/continuous-delivery)
+ * [Git](https://www.atlassian.com/es/git)
+* [Agile](https://www.atlassian.com/es/agile)
+* [Microservicios](https://www.atlassian.com/es/microservices)
+
+Las historias de usuario son tareas de desarrollo que se suelen expresar como "persona + necesidad + propósito".
+
+Resumen: _==una historia de usuario es una explicación general e informal de una función de software escrita desde la perspectiva del usuario final. Su propósito es articular cómo proporcionará una función de software valor al cliente.==_
+
+Es tentador pensar que las historias de usuario son, en pocas palabras, requisitos del sistema de software. Pero no lo son.
+
+Un componente clave del desarrollo de software ágil es poner a las personas en primer lugar, y las historias de usuarios ponen a los usuarios finales reales en el centro de la conversación. Las historias utilizan un lenguaje no técnico para ofrecer contexto al equipo de desarrollo y sus esfuerzos. Después de leer una historia de usuario, el equipo sabe por qué está compilando lo que está compilando y qué valor crea.
+
+Las historias de usuario son uno de los componentes centrales de un programa ágil. Ayudan a proporcionar un marco centrado en el usuario para el trabajo diario, lo que impulsa la colaboración y la creatividad y mejora el producto en general.
+
+## ¿Qué son las historias de usuario ágiles?
+
+Una historia de usuario es la unidad de trabajo más pequeña en un marco ágil. Es un objetivo final, no una función, expresado desde la perspectiva del usuario del software.
+
+Una historia de usuario es una explicación general e informal de una función de software escrita desde la perspectiva del usuario final o cliente.
+
+El propósito de una historia de usuario es articular cómo un elemento de trabajo entregará un valor particular al cliente. Ten en cuenta que los "clientes" no tienen por qué ser usuarios finales externos en el sentido tradicional, también pueden ser clientes internos o colegas dentro de tu organización que dependen de tu equipo.
+
+Las historias de usuario son unas pocas frases en lenguaje sencillo que describen el resultado deseado. No entran en detalles, ya que los requisitos se añaden más tarde, una vez acordados por el equipo.
+
+==Las historias encajan perfectamente en marcos ágiles como== ==[scrum](https://www.atlassian.com/es/agile/scrum)== ==y== ==[kanban](https://www.atlassian.com/es/agile/kanban)====. En el scrum, las historias de los usuarios se añaden a los sprints y se van realizando a lo largo del sprint. Los equipos de kanban incorporan las historias de usuario en su backlog y las ejecutan siguiendo su flujo de trabajo.== Es este trabajo sobre las historias de usuario lo que ayuda a los equipos de scrum a mejorar en la [estimación](https://www.atlassian.com/es/agile/project-management/estimation) y planificación de sprints, lo que conduce a un pronóstico más preciso y a una mayor agilidad. Gracias a las historias, los equipos de kanban aprenden a gestionar el trabajo en curso (WIP) y pueden perfeccionar aún más sus flujos de trabajo.
+
+==Las historias de usuario son también los componentes básicos de los marcos ágiles más grandes, como los epics y las iniciativas. Los epics son grandes elementos de trabajo divididos en un conjunto de historias, y varios epics constituyen una iniciativa.== Estas estructuras más grandes garantizan que el trabajo diario del equipo de desarrollo contribuya a los objetivos de la organización incorporados en los epics y las iniciativas.
+
+[Más información sobre epics e iniciativas](https://www.atlassian.com/es/agile/project-management/epics-stories-themes)
+
+
+
+## ¿Por qué crear historias de usuario?
+
+Para los equipos de desarrollo nuevos en la metodología ágil, las historias de usuario a veces parecen un paso más. ¿Por qué no dividir el gran proyecto ([el epic](https://www.atlassian.com/es/agile/project-management/epics)) en una serie de pasos y seguir adelante? Pero las historias dan al equipo un contexto importante y asocian las tareas con el valor que estas aportan.
+
+Las historias de usuario tienen varios beneficios clave:
+
+* **Las historias centran la atención en el usuario.** Una lista de tareas pendientes mantiene al equipo centrado en tareas que deben completarse, pero un conjunto de historias lo mantiene centrado en solucionar problemas para usuarios reales.
+* **Las historias permiten la colaboración.** Con el objetivo definido, el equipo puede colaborar para decidir cómo ofrecer un mejor servicio al usuario y cumplir con dicho objetivo.
+* **Las historias impulsan soluciones creativas.** Las historias fomentan que el equipo piense de forma crítica y creativa sobre cómo lograr mejor un objetivo.
+* **Las historias motivan.** Con cada historia el equipo de desarrollo disfruta de un pequeño reto y una pequeña victoria, lo que aumenta la motivación.
+
+## Trabajar con historias de usuario
+
+Una vez que se ha escrito una historia, es hora de integrarla en tu flujo de trabajo. Por lo general, una historia la escribe el propietario del producto, el gestor del producto o el gestor del programa, y la envía para su revisión.
+
+Durante una reunión de planificación de sprint o iteración, el equipo decide qué historias afrontará en ese sprint. Los equipos discuten los requisitos y la funcionalidad que requiere cada historia de usuario. Esta es una oportunidad para ponerse técnico y creativo en la implementación de la historia por parte del equipo. Una vez acordados, estos requisitos se añaden a la historia.
+
+Otro paso común en esta reunión es calificar las historias en función de su complejidad o tiempo hasta su finalización. Los equipos usan las tallas de las camisetas, la secuencia de Fibonacci o el Planning Poker para hacer las estimaciones adecuadas. Una historia debe ser de un tamaño que pueda completarse en un sprint; por lo tanto, cuando el equipo establezca las especificaciones de cada historia, se deben asegurar de dividir las historias que superen ese horizonte de finalización.
+
+## ==Cómo escribir historias de usuario==
+
+==Piensa en lo siguiente cuando escribas historias de usuario:==
+
+* **==Definición de “Listo”==**==: la historia suele estar “lista” cuando el usuario puede completar la tarea descrita, pero debes asegurarte de definir lo que representa completarla.==
+* **==Describe tareas o subtareas==**==: decide qué pasos específicos deben completarse y quién es responsable de cada uno de ellos.==
+* **==Perfiles de usuario==**==: ¿para quién? Si hay varios usuarios finales, considera crear varias historias.==
+* **==Pasos ordenados==**==: escribe una historia para cada paso en un proceso más grande.==
+* **==Escucha el feedback==**==: habla con los usuarios y capta sus problemas o necesidades en lo que dicen. No es necesario tener que estar adivinando las historias cuando puedes obtenerlas de tus clientes.==
+* **==Tiempo==**==: el tiempo es un tema delicado. Muchos equipos de desarrollo evitan hablar sobre el tiempo, y en su lugar confían en sus marcos de trabajo de estimación. Dado que las historias deberían completarse en un sprint, aquellas que puedan necesitar semanas o meses deberían dividirse en historias más pequeñas o considerarse un epic independiente.==
+
+Una vez que las historias de usuario estén definidas de forma clara, debes asegurarte de que todo el equipo pueda verlas.
+
+==Las historias de usuario suelen expresarse con una frase simple con la siguiente estructura:==
+
+**==“Como [perfil], [quiero] [para].”==**
+
+==Desglosemos esta estructura:==
+
+* ==“Como [perfil]”: ¿para quién desarrollamos esto? No solo buscamos un puesto, buscamos el perfil de la persona. Max. Nuestro equipo debería comprender quién es Max. Con suerte hemos entrevistado a muchos Max. Comprendemos cómo trabaja esa persona, cómo piensa y cómo se siente. Sentimos empatía por Max.==
+* ==“Quiere”: aquí describimos su intención, no las funciones que usan. ¿Qué es lo que están intentando lograr realmente? Esta descripción debería realizarse con independencia de las implementaciones; si describes algún elemento de la IU y no el objetivo del usuario, estás cometiendo un error.==
+* ==“Para”: ¿cómo encaja su deseo inmediato de hacer algo en la perspectiva general? ¿Cuál es el beneficio general que intentan lograr? ¿Cuál es el gran problema que debe resolverse?==
+
+Por ejemplo, las historias de usuario pueden tener este aspecto:
+
+* Como Max, quiero invitar a mis amigos, para que podamos disfrutar de este servicio juntos.
+* Como Sascha, quiero organizar mi trabajo, para poder sentir que tengo un mayor control.
+* Como gestor, quiero poder comprender el progreso de mis compañeros, para poder informar sobre nuestros éxitos y fallos.
+
+Esta estructura no es obligatoria, pero resulta de ayuda para establecer una definición de "hecho". Cuando ese perfil puede alcanzar su valor deseado, la historia está completa. Recomendamos a nuestros equipos definir su propia estructura, y que no se desvíen de ella.
+
+## Introducción a las historias de usuario ágiles
+
+Las historias de los usuarios describen el por qué y el qué que hay detrás del trabajo diario de los miembros del equipo de desarrollo; a menudo las historias de usuario se expresan de la siguiente manera: _perfil + necesidad + propósito_. Entender su papel como fuente de verdad para lo que el equipo está entregando, pero también el por qué, es clave para un proceso sin problemas.
+
+Empieza por evaluar el siguiente gran proyecto o el más apremiante (por ejemplo, un epic). Divídelo en historias de usuario más pequeñas y trabaja con el equipo de desarrollo para mejorarlo. Una vez que tus historias están fuera, donde todo el equipo puede verlas, ya tienes todo listo para empezar a trabajar.
+
+.jpg?cdnVersion=1373)
+
+ Max Rehkopf
+
+Como persona caótica que soy, confío en las prácticas de la metodología ágil y en los principios optimizados para poner orden en mi día a día. Me alegra compartir estas lecciones con otras personas a través de los muchos artículos, ponencias y vídeos que hago para Atlassian.
+
+
+
+tutorial
+
+#### Cómo crear historias de usuario en Jira Software
+
+Descubre cómo los equipos pueden utilizar los tiques para realizar un seguimiento del trabajo que debe completarse.
+
+[Probar el tutorial ](https://www.atlassian.com/es/agile/tutorials/issues)
+
+
+
+artículo
+
+#### ¿Qué son los puntos de historia y cómo se estiman?
+
+Conoce por dentro los secretos de la estimación ágil y los puntos de historia. Una buena estimación ágil permite a los propietarios del producto optimizar sus procesos en términos de eficiencia e impacto.
+
+[Leer el artículo ](https://www.atlassian.com/es/agile/project-management/estimation)
\ No newline at end of file
diff --git a/Omnivore/2023-12-24 - ¿Qué son los puntos de historia en la metodología ágil y cómo se estiman-.md b/Omnivore/2023-12-24 - ¿Qué son los puntos de historia en la metodología ágil y cómo se estiman-.md
new file mode 100644
index 0000000..d60cdec
--- /dev/null
+++ b/Omnivore/2023-12-24 - ¿Qué son los puntos de historia en la metodología ágil y cómo se estiman-.md
@@ -0,0 +1,114 @@
+---
+id: 22bb5f59-fddb-4ab4-89dd-bb28fe723f4f
+title: |
+ ¿Qué son los puntos de historia en la metodología ágil y cómo se estiman?
+status: ARCHIVED
+tags:
+ - read-later
+date_added: 2023-12-24 18:36:25
+url_omnivore: |
+ https://omnivore.app/me/https-www-atlassian-com-es-agile-project-management-estimation-18c9dc1e48a
+url_original: |
+ https://www.atlassian.com/es/agile/project-management/estimation
+---
+
+# ¿Qué son los puntos de historia en la metodología ágil y cómo se estiman?
+
+## Highlights
+
+Se trata de unidades de medida que permiten expresar una estimación del esfuerzo total que deberá hacer el equipo para implementar íntegramente un elemento del backlog del producto o cualquier otro trabajo. Los equipos asignan puntos de historia en función de la complejidad y del volumen del trabajo, así como del riesgo o de la incertidumbre.
+
+[source](https://omnivore.app/me/https-www-atlassian-com-es-agile-project-management-estimation-18c9dc1e48a#4ddb962e-4ff6-44fa-8e72-b74db4a9b7a2)
+
+---
+
+## Original
+
+* [DevOps](#)
+ * [Entrega continua](https://www.atlassian.com/es/continuous-delivery)
+ * [Git](https://www.atlassian.com/es/git)
+* [Agile](https://www.atlassian.com/es/agile)
+* [Microservicios](https://www.atlassian.com/es/microservices)
+
+## Puntos de historia y estimación
+
+Una buena estimación ayuda a los propietarios de los productos a optimizar sus procesos en términos de eficiencia e impacto. Por eso es tan importante.
+
+Hacer estimaciones es complicado. Para los desarrolladores de software, es uno de los aspectos más difíciles de su trabajo, por no decir el más difícil. Conlleva tener en cuenta un montón de factores que ayudan a los propietarios de los productos a tomar decisiones que afectan a todo el equipo, así como a la empresa. Con todo eso en juego, no es de extrañar que todos, desde los desarrolladores hasta la alta dirección, tiendan a perder los estribos sobre este tema. Craso error. La estimación ágil de los puntos de historia no es más que eso, un cálculo: no es un pacto de sangre.
+
+No es obligatorio trabajar los fines de semana para compensar el tiempo de más que nos lleva un trabajo que habíamos subestimado. Dicho eso, veamos algunas maneras de realizar estimaciones con la mayor precisión posible.
+
+## Colaboración con el propietario del producto
+
+En un desarrollo ágil, el [propietario del producto](https://www.atlassian.com/es/agile/product-management) se encarga de priorizar el [backlog](https://www.atlassian.com/es/agile/scrum/backlogs), es decir, la lista ordenada de trabajo que contiene descripciones breves de todas las funciones y correcciones de un producto. Los propietarios del producto capturan los [requisitos](https://www.atlassian.com/es/agile/product-management/requirements) empresariales, pero no siempre entienden los detalles de la implementación. Por ello, una buena estimación puede informar al propietario del producto sobre el nivel de esfuerzo de cada elemento de trabajo, que a su vez sirve para evaluar la prioridad relativa de cada elemento.
+
+Cuando el equipo de ingeniería empieza su proceso de estimación, normalmente surgen preguntas sobre los requisitos y las historias de usuario. Esto es algo positivo: las preguntas ayudan a todo el equipo a entender el trabajo mejor. Específicamente en el caso de los propietarios de los productos, la división granular de los elementos de trabajo y las estimaciones les ayudan a priorizar todas las áreas del trabajo, incluidas las que pueden estar ocultas. Con las estimaciones del equipo de desarrollo en la mano, no es extraño que un propietario del producto reordene los elementos del backlog.
+
+## La estimación ágil de los puntos de historia es un trabajo en equipo
+
+Involucrar a todo el mundo (desarrolladores, diseñadores, testers, deployers... todos) en el equipo es clave. Cada miembro del equipo aporta una perspectiva diferente sobre el producto y el trabajo necesario para entregar una historia de usuario. Por ejemplo, si la gestión de productos quiere hacer algo que parece sencillo, como admitir un nuevo navegador web, el desarrollo y el control de calidad deben dar su opinión también, ya que su experiencia les ha enseñado qué dragones pueden estar al acecho bajo la superficie.
+
+Asimismo, los cambios de diseño requieren no sólo la aportación del equipo de diseño, sino también la del de desarrollo y la del de QA. Dejar a parte del equipo de producto más amplio fuera del proceso de estimación crea estimaciones de menor calidad, baja la moral porque los contribuyentes clave no se sienten incluidos y compromete la calidad del software.
+
+No dejes que tu equipo sea víctima de las estimaciones poco precisas. Es un camino seguro al fracaso.
+
+## Puntos de historia frente a horas
+
+Los equipos de software tradicionales proporcionan estimaciones en un formato de tiempo concreto: pueden ser días, semanas o meses. Sin embargo, muchos equipos ágiles han decidido pasarse a los puntos de historia. ==Se trata de unidades de medida que permiten expresar una estimación del esfuerzo total que deberá hacer el equipo para implementar íntegramente un elemento del backlog del producto o cualquier otro trabajo. Los equipos asignan puntos de historia en función de la complejidad y del volumen del trabajo, así como del riesgo o de la incertidumbre.== Los valores se asignan para desglosar el trabajo de forma más eficaz en partes más pequeñas. De esta manera, se puede gestionar la incertidumbre. Con el tiempo, esto ayuda a los equipos a ser conscientes de lo que pueden llegar a conseguir en un período de tiempo concreto y genera un sentimiento de consenso y compromiso con la solución. Aunque pueda parecer contradictorio, esta abstracción es realmente útil, ya que obliga al equipo a tomar decisiones más complejas sobre la dificultad del trabajo. A continuación, se indican algunos motivos por los cuales es recomendable utilizar puntos de historia:
+
+* Las fechas no tienen en cuenta el trabajo no relacionado con el proyecto que inevitablemente surge en nuestro día a día, como correos electrónicos, reuniones y entrevistas en las que un miembro del equipo puede participar.
+* Las fechas tienen una connotación emocional. La estimación relativa elimina este componente.
+* Cada equipo estima el trabajo en una escala ligeramente diferente, lo cual significa que su velocidad (medida en puntos) será diferente, como es natural. Asimismo, esto imposibilita que se politiquee usando la velocidad como arma.
+* Una vez que se llegue a un acuerdo sobre el esfuerzo relativo del valor de cada punto de historia, podrás asignar puntos rápidamente sin que haya lugar a demasiado debate.
+* Los puntos de historia recompensan a los miembros del equipo por resolver incidencias basándose en la dificultad, y no en el tiempo empleado. De esta forma, los miembros del equipo se mantienen centrados en entregar valor, no en el tiempo dedicado.
+
+Lamentablemente, los puntos de historia se suelen utilizar de forma incorrecta; por ejemplo, cuando se emplean para juzgar a las personas o para asignar cronogramas y recursos detallados, o bien cuando se confunden con una medida de productividad. La auténtica función de los puntos de historia es que los equipos puedan hacerse una idea del volumen de trabajo y saber qué partes tienen prioridad. Para ver un debate en profundidad sobre los puntos de historia y las prácticas relacionadas con las estimaciones, échale un vistazo a esta [mesa redonda con expertos del sector](https://community.atlassian.com/t5/Agile-articles/Six-experts-sound-off-on-story-points-the-evolution-of-agile/ba-p/1553590). Si quieres más consejos sobre la estimación ágil, sigue leyendo.
+
+[ ](https://www.youtube.com/watch?v=%5FN5gj9gzOjg)
+
+## Puntos de historia y póker de planificación
+
+Los equipos que se están iniciando en los puntos de historia usan un ejercicio llamado [Planning Poker](https://www.atlassian.com/blog/platform/a-brief-overview-of-planning-poker). En Atlassian, el Planning Poker es una práctica habitual en toda la empresa. Los miembros del equipo toman un elemento del backlog, hablan sobre él brevemente y cada uno fórmula mentalmente una estimación. A continuación, todos levantan una tarjeta con el número que refleje su estimación. Si todo el mundo está de acuerdo, ¡estupendo! De lo contrario, dedica algo de tiempo (no mucho, tan solo un par de minutos) para entender el motivo de las distintas estimaciones. Recuerda, sin embargo, que la estimación debe ser una actividad bastante general. Si el equipo se va por las ramas, respira hondo y deriva el debate a un superior.
+
+**¿Listo para intentarlo?**
+
+* Instala esta [Aplicación de póker de planificación](https://marketplace.atlassian.com/apps/1212495/planning-poker?hosting=cloud&tab=overview)
+* Obtén más información sobre el [póker de planificación](https://www.atlassian.com/blog/agile/planning-poker-sane-healthy)
+
+## Estima con mayor inteligencia, no con mayor esfuerzo
+
+Ninguna tarea individual debe superar las 16 horas de trabajo. (Si usas puntos de historia, puedes decidir que 20 puntos es el límite superior, por ejemplo). Sencillamente, es demasiado complicado estimar elementos de trabajo individuales de mayor duración con confianza. Esa confianza es especialmente importante para los elementos en la parte superior del backlog. Cuando algo se estima por encima del límite de 16 horas (o 20 puntos) del equipo, será una señal para dividirlo granularmente y volver a estimarlo.
+
+Para los elementos que se encuentren más abajo en el backlog, basta con una estimación aproximada. Cuando el equipo empiece a trabajar en esos elementos, los requisitos podrían haber cambiado y la aplicación seguramente habrá cambiado también, de modo que las estimaciones no serán tan precisas. No pierdas tiempo estimando trabajo que posiblemente cambiará. Da al propietario del producto una cifra aproximada que pueda utilizar para priorizar la hoja de ruta del producto adecuadamente.
+
+## Aprende de las estimaciones anteriores
+
+Las retrospectivas constituyen un momento para que el equipo incorpore ideas de iteraciones anteriores, incluida la precisión de sus estimaciones. Hay muchas herramientas ágiles (como [Jira Software](https://www.atlassian.com/es/software/jira)) que realizan el seguimiento de los puntos de historia, cosa que facilita en gran medida el análisis y el recalibrado de las estimaciones. Prueba, por ejemplo, a comparar las cinco últimas historias de usuario que haya entregado el equipo con un valor de 8 puntos de historia. Estudia si cada uno de estos elementos de trabajo tuvo un nivel de esfuerzo similar. Si no, analizad por qué. Utilizad esta información en los siguientes debates de estimaciones.
+
+Al igual que [el resto de los aspectos de un proceso ágil](https://www.atlassian.com/es/agile/project-management), la estimación es una cuestión de práctica. Irás mejorando con el tiempo.
+
+
+
+ Dan Radigan
+
+La metodología ágil ha influido mucho en mí, tanto en el aspecto profesional como en el personal: he aprendido que las mejores experiencias se basan en el modelo ágil, tanto al programar como en la vida real. Mis intereses suelen moverse entre la tecnología, la fotografía y el motociclismo.
+
+
+
+tutorial
+
+#### Aprender a usar diagramas de trabajo pendiente con Jira Software
+
+La guía completa sobre diagramas de evolución en Jira Software. Aprende a supervisar epics y sprints con diagramas de evolución.
+
+[Probar el tutorial ](https://www.atlassian.com/es/agile/tutorials/burndown-charts)
+
+
+
+artículo
+
+#### Cinco métricas ágiles que no odiarás
+
+¿Cómo usar métricas ágiles? Descubre las gráficas de trabajo pendiente de sprints, epics y publicaciones, los gráficos de control y velocidad, y el diagrama de flujo acumulado.
+
+[Leer el artículo ](https://www.atlassian.com/es/agile/project-management/metrics)
\ No newline at end of file
diff --git a/Omnivore/2024-02-12 - Debouncing in JavaScript – Explained by Building Auto-Complete Functionality in React.md b/Omnivore/2024-02-12 - Debouncing in JavaScript – Explained by Building Auto-Complete Functionality in React.md
new file mode 100644
index 0000000..a979606
--- /dev/null
+++ b/Omnivore/2024-02-12 - Debouncing in JavaScript – Explained by Building Auto-Complete Functionality in React.md
@@ -0,0 +1,412 @@
+---
+id: d529f41a-ca28-11ee-97f3-f78c291f6623
+title: |
+ Debouncing in JavaScript – Explained by Building Auto-Complete Functionality in React
+status: ARCHIVED
+tags:
+ - read-later
+ - RSS
+date_added: 2024-02-12 20:23:30
+url_omnivore: |
+ https://omnivore.app/me/debouncing-in-java-script-explained-by-building-auto-complete-fu-18da0bc7510
+url_original: |
+ https://www.freecodecamp.org/news/deboucing-in-react-autocomplete-example/
+---
+
+# Debouncing in JavaScript – Explained by Building Auto-Complete Functionality in React
+
+## Highlights
+
+Debouncing accepts a function and transforms it in to an updated (debounced) function so that the code inside the original function is executed after a certain period of time.
+
+[source](https://omnivore.app/me/debouncing-in-java-script-explained-by-building-auto-complete-fu-18da0bc7510#2c8f31bd-f011-49bd-99bc-36192f7fd823)
+
+---
+
+function debounce(func, delay) {let timeout=null return (...args) => {if(timeout) clearTimeout(timeout) timeout=setTimeout(() \=> { func(...args) timeout=null }, delay) } }
+
+[source](https://omnivore.app/me/debouncing-in-java-script-explained-by-building-auto-complete-fu-18da0bc7510#5a57c802-520a-409a-a51c-e554a6ec8bd5)
+
+---
+
+const useDebounce = (func, delay) => { let timeout\=null return (...args) => {if(timeout) clearTimeout(timeout)timeout\=setTimeout(() => { func(...args) }, delay) } }export default useDebounce
+
+[source](https://omnivore.app/me/debouncing-in-java-script-explained-by-building-auto-complete-fu-18da0bc7510#226d8c7b-6900-4b2f-a705-5f5b6e10afc5)
+
+---
+
+## Original
+
+
+
+Hi readers, I hope you are doing great! I am back with another tutorial on web development. If you are someone who enjoys developing web apps with JavaScript and React, then this post is for you.
+
+When you roll out a new app into production, you want to make sure that it's user friendly. A website's performance is a key part of the user experience. Every user wants the website and its contents to load quickly. Each and every second is valuable and could result into a user never visiting your website again.
+
+In this guide, we are going to understand a very important technique in JavaScript known as debouncing. Then, I will show you how to implement the autocomplete functionality in React with debouncing.
+
+Now, in order to get the most out of this tutorial, I am assuming you have a basic knowledge of JavaScript. If you need to get started or review, here are a couple resources for you:
+
+* Learn JavaScript basics – [handbook for beginners](https://www.freecodecamp.org/news/learn-javascript-for-beginners/)
+* The freeCodeCamp [JavaScript Algorithms and Data Structures certification](https://www.freecodecamp.org/news/learn-javascript-with-new-data-structures-and-algorithms-certification-projects/)
+
+## **Table of Contents:**
+
+* [What is Debouncing?](#what-is-debouncing)
+* [How to Implement Debouncing in JavaScript](#how-to-implement-debouncing-in-javascript)
+* [Use Case of Debouncing](#use-case-of-debouncing)
+* [Conclusion](#conclusion)
+
+## What is Debouncing?
+
+Debouncing is a strategy used to improve the performance of a feature by controlling the time at which a function should be executed.
+
+==Debouncing accepts a function and transforms it in to an updated (debounced) function so that the code inside the original function is executed after a certain period of time.==
+
+If the debounced function is called again within that period, the previous timer is reset and a new timer is started for this function call. The process repeats for each function call.
+
+An example will help you understand better. Let's take a function `fun()`. We want this function to execute after 500ms.
+
+```crystal
+function fun() {
+ console.log('This is a function')
+}
+```
+
+After debouncing, a new function `debouncedFun()` is returned. Now, whenever you call `debouncedFun()`, it will be called after 500ms.
+
+If you call it again within the next 500ms after first calling it, the previous timer is reset and a new timer is started for the second function call. The process repeats if you keep calling the function within 500ms.
+
+## How to Implement Debouncing in JavaScript
+
+Let's understand how to implement debouncing in JavaScript. First, we'll go over our requirements. What behavior do we want from the debounced function?
+
+* Delay the function execution by a certain time, `delay`.
+* Reset the timer if the function is called again.
+
+To debounce a function, we'll have a separate function that accepts the function reference and the delay as parameters, and returns a debounced function.
+
+```ada
+function debounce(func, delay) {
+ return () => {} // return debounced function
+}
+```
+
+This function will only be called once to return a debounced function and that, in turn, will be used in the subsequent code.
+
+To delay a function by some milliseconds, we can simply use the `setTimeout` function in JavaScript.
+
+```arcade
+function debounce(func, delay) {
+ return () => {
+ setTimeout(() => {
+ func()
+ }, delay)
+ }
+}
+```
+
+This delays the function call by `delay` milliseconds. But this is incomplete as it only satisfies the first requirement. How do we achieve the second behaviour?
+
+Let's create a variable `timeout` and assign it to the return value of `setTimeout` method. The `setTimeout` method returns a unique identifier to the timeout, which is held by `timeout` variable.
+
+```javascript
+function debounce(func, delay) {
+ let timeout=null
+ return () => {
+ timeout=setTimeout(() => {
+ func()
+ }, delay)
+ }
+}
+```
+
+Each time you invoke `setTimeout`, the ID is different. We will use this `timeout` variable to reset the timer.
+
+But how do we get access to `timeout` from outside the `debounce()` method? As mentioned before, `debounce()` is only used once to return a debounced function. This, in turn, performs the debouncing logic.
+
+Then, how does the debounced function have access to `timeout` even if it is used outside the `debounce()` function? Well, it uses a concept called closure.
+
+### What's a closure in JavaScript?
+
+In JavaScript, an inner function always has access to the local variables of the outer function. In our case, the inner function has access to `timeout` that has function level scope in the `debounce()` method.
+
+But when the outer function returns this inner function, the inner function still holds a reference to the local variables of the outer function long after the outer function has finished execution. This is the concept of a closure.
+
+Let's understand closures with an example.
+
+```javascript
+function outerFunction() {
+ const x = 5;
+
+ return () => {
+ console.log(x);
+ }
+}
+
+const inner = outerFunction();
+
+inner(); // prints 5
+
+// console.log(x) Throws reference error
+```
+
+Here, if we call `inner()`, the code runs without any errors and prints 5\. But, if we try to access `x` directly, JavaScript throws a reference error.
+
+
+
+JavaScript Reference Error
+
+Here, `inner()` closes over `x` and only this function can use the variable and no one other one can. We cannot access the variable explicitly.
+
+You can check out [this beginner-friendly tutorial](https://www.freecodecamp.org/news/closures-in-javascript/) to learn more about closures.
+
+### Back to Debouncing
+
+Let's get back to where we left off:
+
+```javascript
+function debounce(func, delay) {
+ let timeout=null
+ return () => {
+ timeout=setTimeout(() => {
+ func()
+ }, delay)
+ }
+}
+```
+
+Here, JavaScript uses a closure to hold access to `timeout` every time we use the debounced function.
+
+Let's use this to our advantage. Since `debouncedFun()` has access to the same `timeout` variable in every function call, we can add a condition to check whether a previous timeout exists. We can simply do this with a null check, `if(timeout !== null)` or `if(timeout)`.
+
+Then, we use the `clearTimeout()` method to cancel the previous timeout, thus resetting the timer.
+
+Add the following statement before starting a new timeout:
+
+```lisp
+if(timeout)
+ clearTimeout(timeout)
+
+```
+
+Once the timeout is reset, a new timeout is started for the current function call, whose ID is then assigned to `timeout`. The process is repeated for the subsequent function calls who have access to the same `timeout` due to closures.
+
+```javascript
+function debounce(func, delay) {
+ let timeout=null
+ return () => {
+ if(timeout) clearTimeout(timeout)
+
+ timeout=setTimeout(() => {
+ func()
+ }, delay)
+ }
+}
+```
+
+With this, we have satisfied our second requirement – that is, resetting the timer and starting a new one. It's time to use this debounced function.
+
+Let's pass `fun()` to the `debounce()` method with a delay of 500ms.
+
+```kotlin
+const debouncedFun = debounce(fun, 500)
+
+```
+
+`debouncedFun()` is basically `fun()` with debouncing behaviour. Let's call this function at different time intervals to test our functionality.
+
+```stylus
+debouncedFun()
+
+setTimeout(debouncedFun, 300)
+
+setTimeout(debouncedFun, 900)
+```
+
+The first function call is made instantly. The other two are made after 300ms and 900ms respectively. Can you guess the output?
+
+The code prints `This is a function` two times. Let's understand why. Here, after the first call is made, `fun()` is scheduled to execute after 500ms. But the second one is made in 300ms which resets the timer and starts a new one.
+
+500ms have passed and the `fun()` method executes. Then, at 900ms, another function call is made. This again executes `fun()` after 500ms.
+
+There is still a small improvement we should make. Our logic does not consider function arguments. Let's replace `fun()` with `fun(a, b)`.
+
+```javascript
+function fun(a, b) {
+ console.log(`This is a function with arguments ${a} and ${b}`)
+}
+```
+
+To incorporate arguments while debouncing, return a debounced function that accepts arguments.
+
+```javascript
+function debounce(func, delay) {
+ let timeout=null
+ return (...args) => {
+ if(timeout) clearTimeout(timeout)
+
+ timeout=setTimeout(() => {
+ func(...args)
+ timeout=null
+ }, delay)
+ }
+}
+```
+
+By using the spread operator, any arguments passed to the debounced function will be stored as an array in the `args` variable. Then, spread out the same `args` array to call the actual function with the arguments passed.
+
+```kotlin
+const debouncedFun=debounce(fun, 500)
+debouncedFun(2,3)
+```
+
+The above code prints `This is a function with arguments 2 and 3` after 500ms.
+
+## Use Case of Debouncing
+
+Let's see how debouncing is used in practical applications. The most common use case of debouncing is the autocomplete functionality. You must have seen many websites where you type into an input field and it shows a list of results as you type them.
+
+Here's an example from Google Search:
+
+
+
+Google Search Autocomplete after typing in "Top 10"
+
+Google search shows the most recent and commonly searched terms. The information is mostly fetched from the browser cache. But, several websites make API calls to backend server to fetch the data from a database.
+
+This can easily be implemented by adding an `onchange` event to the `input` element and implementing the fetch logic in the event handler. But there's a slight issue with this.
+
+Consider the following example:
+
+
+
+API Request made for each input value
+
+When I type the word _absolute_, an API request is made every time the value of the input field changes. We are making 8 API requests in very few milliseconds which puts a lot of load on the backend server and could cause performance issues.
+
+Ideally, we want to show the auto-complete results some time after the user has finished typing. Here, the user has typed _absolute_ in one go, so instead of showing results every time the input changes, we could show them once the user has finished typing – that is, we could add some delay between the input change and the results being displayed.
+
+So, we only make the API calls when the user finishes typing their word and not on every input change. This reduces the number of API calls and improves performance. We can achieve this behavior with debouncing.
+
+Let's understand how to implement the autocomplete functionality in React.
+
+### Auto-complete example
+
+Use `create-react-app` (or a modern build tool like Vite) to create the project. Remove the existing boilerplate code. There is no need to install any additional dependencies. Run `npm start` command to start the project. You can find the complete code on [GitHub](https://github.com/KunalN25/react-debouncing).
+
+I have set up a Node server to fetch data for the app. You can find it in the Git repo. Run the `node server` command to start it. I am not going to show the Node.js code as it's out of the scope of this tutorial.
+
+Let's get started with the implementation. We will write a simple autocomplete functionality. The app should show a list of cities that contain an input string typed by the user.
+
+#### App Component
+
+We'll first need an `input` element to accept user input and a _results container_ for the search results. Attach an event handler to the `input` element which is an `async` function since it will include the fetching logic.
+
+```javascript
+function App() {
+ const [data, setData] = useState(null)
+
+ const loadData = async (event) => {
+
+ }
+ return (
+ <div className="App">
+ <input type="text" onChange={(e) => loadData(e)}/>
+ {data && data.length !== 0 &&
+ <div className="results-container">
+ {data.map(item => (
+ <div key={item.id} className="result-item">
+ <p> {item.city} </p>
+ </div>
+ ))}
+ </div>}
+ </div>
+ );
+}
+```
+
+The data will be stored as state and the results will only be shown if the data is non-empty. I'll skip over the CSS for this tutorial, you can find it in the [Git Repo](https://github.com/KunalN25/react-debouncing).
+
+#### Event Handler
+
+The `loadData()` function fetches our data and stores the response as state.
+
+```cs
+const loadData = async (event) => {
+ const value=event.target.value
+ if(value === '') {
+ setData(null)
+ return
+ }
+ const response=await fetch(`http://localhost:8000/data/${value}`)
+ const res=await response.json()
+ setData(res)
+}
+```
+
+If no value is entered, simply exit the function. Else, make the request to the node server endpoint. This function is called every time the input changes, so we will debounce this function.
+
+#### Debounce Implementation using a Custom Hook
+
+We will write the debouncing logic inside a custom hook. The advantage of custom hooks is that you can re-use the same logic throughout your application. It is highly advisable to do so.
+
+Create a new folder `custom-hooks` and inside it, create a file `useDebounce.js`. As explained before, the `useDebounce()` method should take a function and delay as parameters and return the debounced function.
+
+```routeros
+const useDebounce = (func, delay) => {
+ let timeout=null
+
+ return (...args) => {
+ if(timeout) clearTimeout(timeout)
+
+ timeout=setTimeout(() => {
+ func(...args)
+ }, delay)
+ }
+}
+
+export default useDebounce
+```
+
+Now, inside the app component, call this method once to get `loadDataDebounced()`.
+
+```angelscript
+const loadDataDebounced = useDebounce(loadData, 400)
+
+```
+
+We'll use this new method as the event handler for the `input` element.
+
+```reasonml
+<input type="text" onChange={(e) => loadDataDebounced(e)}/>
+
+```
+
+#### Output
+
+Enter a search string inside the `input` element to test our code.
+
+
+
+On-screen output
+
+
+
+As you can see in the Network tab, only one request is getting sent instead of three. This makes the search performance much better.
+
+## Conclusion
+
+In this tutorial, you learned what debouncing is and how it is implemented. Debouncing delays the function execution by a certain time and resets the previous timer if the function is called again.
+
+Debouncing uses the important concept of closures. I took a slight detour from the implementation to explain what closure is. It can be a confusing concept for beginners, so take your time understanding it. Closures allow you to work with local variables even after a function has finished execution.
+
+After that, I showed you a popular use case of debouncing, the auto-complete functionality. The performance of the feature can be improved with debouncing. I also showed you how to implement auto-complete in React and use debouncing with custom hooks. I hope this helps you in future projects.
+
+If you are unable to understand the content or find the explanation unsatisfactory, let me know. New ideas are always appreciated! Feel free to connect with me on Twitter. Till then, Goodbye!
+
+---
+
+---
+
+ 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/)
\ No newline at end of file
diff --git a/Omnivore/2024-02-15 - Configuring Zsh Without Dependencies.md b/Omnivore/2024-02-15 - Configuring Zsh Without Dependencies.md
new file mode 100644
index 0000000..c6362ac
--- /dev/null
+++ b/Omnivore/2024-02-15 - Configuring Zsh Without Dependencies.md
@@ -0,0 +1,145 @@
+---
+id: 191e19a9-a07e-479a-82bc-52f90227746c
+title: |
+ Configuring Zsh Without Dependencies
+status: ARCHIVED
+tags:
+ - read-later
+date_added: 2024-02-15 10:01:52
+url_omnivore: |
+ https://omnivore.app/me/https-thevaluable-dev-zsh-install-configure-mouseless-18dacdbdb29
+url_original: |
+ https://thevaluable.dev/zsh-install-configure-mouseless/
+---
+
+# Configuring Zsh Without Dependencies
+
+## Highlights
+
+Zsh read these files in the following order:
+
+1. `.zshenv` \- Should only contain user’s environment variables.
+2. `.zprofile` \- Can be used to execute commands just after logging in.
+3. `.zshrc` \- Should be used for the shell configuration and for executing commands.
+4. `.zlogin` \- Same purpose than `.zprofile`, but read just after `.zshrc`.
+5. `.zlogout` \- Can be used to execute commands when a shell exit.
+
+[source](https://omnivore.app/me/https-thevaluable-dev-zsh-install-configure-mouseless-18dacdbdb29#debc2c0b-4a8b-4073-8a0b-fbddbf99bdcb)
+
+---
+
+## Original
+
+<DIV id="readability-content"><DIV data-omnivore-anchor-idx="1" class="page" id="readability-page-1"><div data-omnivore-anchor-idx="2"><main data-omnivore-anchor-idx="3" role="main"><article data-omnivore-anchor-idx="4"><header data-omnivore-anchor-idx="5"></header><section data-omnivore-anchor-idx="6"><picture data-omnivore-anchor-idx="7"><source data-omnivore-anchor-idx="8" srcset="https://proxy-prod.omnivore-image-cache.app/0x0,srshUvfS3G_ezR33RSwvxWA169d3kznE6QwTzqZ8P_6Y/https://thevaluable.dev/images/2020/zsh/zsh.webp," type="image/webp"><img data-omnivore-anchor-idx="9" data-omnivore-original-src="https://thevaluable.dev/images/2020/zsh/zsh.jpg" width="780" height="520" src="https://proxy-prod.omnivore-image-cache.app/780x520,sRAkOrK0pbDyfGGP8JZyhZzzaifzNMRVFQJs9ceY2rMQ/https://thevaluable.dev/images/2020/zsh/zsh.jpg" alt="Huey, Dewey, and Louie with a Z, S, and H t-shirt"></picture><p data-omnivore-anchor-idx="10">This article is part of a series about Zsh:</p><p data-omnivore-anchor-idx="11">There are many boring tasks we repeat day after day: creating, copying, moving or searching files, launching again and again the same tools, docker containers, and whatnot.</p><p data-omnivore-anchor-idx="12">For a developer, the shell is a precious asset which can increase your efficiency over time. It will bring powerful tools at your fingertips, and, more importantly, it will allow you to automate many parts of your workflow.</p><p data-omnivore-anchor-idx="13">To leverage these functionalities, you’ll need a powerful and flexible shell. Today, I would like to present your next best friend: the Z shell, or Zsh.</p><p data-omnivore-anchor-idx="14">If you look at the documentation (around 450 pages for the <a data-omnivore-anchor-idx="15" href="http://zsh.sourceforge.net/Doc/zsh_a4.pdf" target="_blank" rel="noopener">PDF version</a>), Zsh can feel daunting. There are so many options available, it can be difficult to come up with a basic configuration you can build upon.</p><p data-omnivore-anchor-idx="16">We’ll build, in this article, a basic Zsh config. I’ll explain the meaning of (almost) everything along the way, including:</p><ul data-omnivore-anchor-idx="17"><li data-omnivore-anchor-idx="18">What’s a Unix shell.</li><li data-omnivore-anchor-idx="19">Why Zsh is a good choice.</li><li data-omnivore-anchor-idx="20">How to install Zsh.</li><li data-omnivore-anchor-idx="21">A brief overview of:<ul data-omnivore-anchor-idx="22"><li data-omnivore-anchor-idx="23">Useful environment variables.</li><li data-omnivore-anchor-idx="24">Aliases.</li><li data-omnivore-anchor-idx="25">The Zsh options.</li><li data-omnivore-anchor-idx="26">The Zsh completion.</li><li data-omnivore-anchor-idx="27">The Zsh prompt.</li><li data-omnivore-anchor-idx="28">The Zsh directory stack.</li></ul></li><li data-omnivore-anchor-idx="29">How to configure Zsh to make it Vim-like.</li><li data-omnivore-anchor-idx="30">How to add external plugins to Zsh.</li><li data-omnivore-anchor-idx="31">External programs you can use to improve your Zsh experience.</li></ul><p data-omnivore-anchor-idx="32">Are your keyboard ready? Are you fingers warm? Did you stretch your arms? Let’s begin, then!</p><h2 data-omnivore-anchor-idx="33" id="brief-unix-shell-overview">Brief Unix Shell Overview</h2><p data-omnivore-anchor-idx="34">A shell <em data-omnivore-anchor-idx="35">interpret</em> command lines. You can type them using a prompt in an <em data-omnivore-anchor-idx="36">interactive shell</em>, or you can run shell scripts using a <em data-omnivore-anchor-idx="37">non-interactive shell</em>.</p><p data-omnivore-anchor-idx="38">The shell run just after you logged in with your user. You can imagine the shell as the layer directly above the kernel of Unix-based operating systems (including Linux). Here’s the charismatic <a data-omnivore-anchor-idx="39" href="https://youtu.be/tc4ROCJYbm0?t=248" target="_blank" rel="noopener">Brian Kernighan explaining it casually with his feet on a table</a>.</p><p data-omnivore-anchor-idx="40">When you use a graphical interface (or GUI), you click around with your mouse to perform tasks. When you use a shell, you use plain text instead.</p><p data-omnivore-anchor-idx="41">If you use a graphical interface (like a windows manager or a desktop environment), you’ll need a <em data-omnivore-anchor-idx="42">terminal emulator</em> to access the shell. In the old days, a <a data-omnivore-anchor-idx="43" href="https://en.wikipedia.org/wiki/Computer_terminal" target="_blank" rel="noopener">terminal was a real device</a>. Nowadays, it’s a program.</p><p data-omnivore-anchor-idx="44">The shell gives you access to many powerful programs. They are called CLIs, or Command Line Interfaces.</p><p data-omnivore-anchor-idx="45">At that point, you might wonder: why using a shell, instead of a graphical interface?</p><ul data-omnivore-anchor-idx="46"><li data-omnivore-anchor-idx="47">It’s difficult to get a graphical interface right, especially if your software has many functionalities. It can be simpler to build a CLI to avoid some complexity.</li><li data-omnivore-anchor-idx="48">CLIs are usually faster.</li><li data-omnivore-anchor-idx="49">A developer deals often with plain text. CLIs are great for that.</li><li data-omnivore-anchor-idx="50">Many shells, like Linux shells, allow you to pipe CLIs together in order to create a powerful transformation flow.</li><li data-omnivore-anchor-idx="51">It’s easier to automate textual commands rather than actions on a graphical interface.</li></ul><blockquote data-omnivore-anchor-idx="52"><p data-omnivore-anchor-idx="53">Play around with your command shell, and you’ll be surprised at how much more productive it makes you.</p></blockquote><p data-omnivore-anchor-idx="54">A shell is the keystone of a Mouseless Development Environment, and the most powerful tool you can use as a developer.</p><h2 data-omnivore-anchor-idx="55" id="bash-vs-zsh">Bash vs Zsh</h2><p data-omnivore-anchor-idx="56">There are other Linux shells available out there, including the famous <a data-omnivore-anchor-idx="57" href="https://en.wikipedia.org/wiki/Bash_%28Unix_shell%29" target="_blank" rel="noopener">Bash</a>. Why using Zsh?</p><ul data-omnivore-anchor-idx="58"><li data-omnivore-anchor-idx="59">The level of flexibility and customization of Zsh is crazy.</li><li data-omnivore-anchor-idx="60">You have access to a powerful completion for your favorite CLIs.</li><li data-omnivore-anchor-idx="61">The Vi mode is golden for every Vim lovers.</li><li data-omnivore-anchor-idx="62">There is an important and active community around Zsh.</li><li data-omnivore-anchor-idx="63">Bash scripts are (mostly) compatible with Zsh.</li></ul><p data-omnivore-anchor-idx="64">Bash is simpler than Zsh, but it has also less functionalities.</p><h2 data-omnivore-anchor-idx="65" id="zsh-without-oh-my-zsh">Zsh Without oh-my-zsh</h2><p data-omnivore-anchor-idx="66">You’ll see many advising you to install a Zsh framework with a crazy number of plugins, options, aliases, all already configured. The famous ones are <a data-omnivore-anchor-idx="67" href="https://ohmyz.sh/" target="_blank" rel="noopener">Oh My Zsh</a> and <a data-omnivore-anchor-idx="68" href="https://github.com/sorin-ionescu/prezto" target="_blank" rel="noopener">prezto</a>.</p><p data-omnivore-anchor-idx="69">I tried this approach for years and I think the drawbacks outweigh the benefits:</p><ul data-omnivore-anchor-idx="70"><li data-omnivore-anchor-idx="71">I have no clue what’s included in these frameworks. When I read their documentations, I can’t possibly remember everything it sets. Therefore, I barely use 10% of the functionalities.</li><li data-omnivore-anchor-idx="72">Zsh has already many functionalities and options, it’s even more daunting to have a framework on top.</li><li data-omnivore-anchor-idx="73">A framework is a big external dependency which brings more complexity. If there is a conflict with my own configuration or a bug, it can take a long time to figure out what’s happening.</li><li data-omnivore-anchor-idx="74">A framework impose rules and way of doing I don’t necessarily want, or need.</li></ul><p data-omnivore-anchor-idx="75">Don’t get me wrong: these frameworks are incredible feats. They can be useful to get some inspiration for your own configuration. But I wouldn’t use them directly.</p><h2 data-omnivore-anchor-idx="76" id="let-the-party-begin">Let The Party Begin</h2><p data-omnivore-anchor-idx="77">We’ll now configure Zsh. If the files or folders I’m speaking about don’t exist, you need to create them.</p><p data-omnivore-anchor-idx="78">This configuration was tested with a Linux based system. I have no idea about macOS, but it should work.</p><h3 data-omnivore-anchor-idx="79" id="installing-zsh">Installing Zsh</h3><p data-omnivore-anchor-idx="80">You can install Zsh like everything else:</p><ul data-omnivore-anchor-idx="81"><li data-omnivore-anchor-idx="82">Debian / Ubuntu: <code data-omnivore-anchor-idx="83" class="hljs language-cmake language-ebnf">sudo apt <span data-omnivore-anchor-idx="84" class="hljs-keyword">install</span> zsh</code></li><li data-omnivore-anchor-idx="85">Red Hat: <code data-omnivore-anchor-idx="86" class="hljs language-cmake language-ebnf">sudo yum <span data-omnivore-anchor-idx="87" class="hljs-keyword">install</span> zsh</code></li><li data-omnivore-anchor-idx="88">Arch Linux: <code data-omnivore-anchor-idx="89" class="hljs language-ebnf language-nginx"><span data-omnivore-anchor-idx="90" class="hljs-attribute">sudo pacman -S zsh</span></code></li><li data-omnivore-anchor-idx="91">macOS (with brew): <code data-omnivore-anchor-idx="92" class="hljs language-mipsasm language-armasm"><span data-omnivore-anchor-idx="93" class="hljs-keyword">brew </span><span data-omnivore-anchor-idx="94" class="hljs-keyword">install </span>zsh</code></li></ul><p data-omnivore-anchor-idx="95">Then, run it in a terminal by typing <code data-omnivore-anchor-idx="96" class="hljs language-ebnf"><span data-omnivore-anchor-idx="97" class="hljs-attribute">zsh</span></code>.</p><h3 data-omnivore-anchor-idx="98" id="zsh-config-files">Zsh Config Files</h3><p data-omnivore-anchor-idx="99">To configure Zsh for your user’s session, you can use the following files:</p><ul data-omnivore-anchor-idx="100"><li data-omnivore-anchor-idx="101"><code data-omnivore-anchor-idx="102" class="hljs language-gams language-autoit"><span data-omnivore-anchor-idx="103" class="hljs-meta"><span data-omnivore-anchor-idx="104" class="hljs-meta-keyword">$ZDOTDIR</span>/.zshenv</span></code></li><li data-omnivore-anchor-idx="105"><code data-omnivore-anchor-idx="106" class="hljs language-gams language-autoit"><span data-omnivore-anchor-idx="107" class="hljs-meta"><span data-omnivore-anchor-idx="108" class="hljs-meta-keyword">$ZDOTDIR</span>/.zprofile</span></code></li><li data-omnivore-anchor-idx="109"><code data-omnivore-anchor-idx="110" class="hljs language-gams language-autoit"><span data-omnivore-anchor-idx="111" class="hljs-meta"><span data-omnivore-anchor-idx="112" class="hljs-meta-keyword">$ZDOTDIR</span>/.zshrc</span></code></li><li data-omnivore-anchor-idx="113"><code data-omnivore-anchor-idx="114" class="hljs language-gams language-autoit"><span data-omnivore-anchor-idx="115" class="hljs-meta"><span data-omnivore-anchor-idx="116" class="hljs-meta-keyword">$ZDOTDIR</span>/.zlogin</span></code></li><li data-omnivore-anchor-idx="117"><code data-omnivore-anchor-idx="118" class="hljs language-gams language-autoit"><span data-omnivore-anchor-idx="119" class="hljs-meta"><span data-omnivore-anchor-idx="120" class="hljs-meta-keyword">$ZDOTDIR</span>/.zlogout</span></code></li></ul><p data-omnivore-anchor-idx="121">In case you wonder what <code data-omnivore-anchor-idx="122" class="hljs language-gams language-autoit"><span data-omnivore-anchor-idx="123" class="hljs-meta"><span data-omnivore-anchor-idx="124" class="hljs-meta-keyword">$ZDOTDIR</span></span></code> stands for, we’ll come back to it soon.</p><p data-omnivore-anchor-idx="125">Zsh read these files in the following order:</p><ol data-omnivore-anchor-idx="126"><li data-omnivore-anchor-idx="127"><code data-omnivore-anchor-idx="128" class="hljs language-asciidoc language-css"><span data-omnivore-anchor-idx="129" class="hljs-title">.zshenv</span></code> - Should only contain user’s environment variables.</li><li data-omnivore-anchor-idx="130"><code data-omnivore-anchor-idx="131" class="hljs language-asciidoc language-css"><span data-omnivore-anchor-idx="132" class="hljs-title">.zprofile</span></code> - Can be used to execute commands just after logging in.</li><li data-omnivore-anchor-idx="133"><code data-omnivore-anchor-idx="134" class="hljs language-asciidoc language-css"><span data-omnivore-anchor-idx="135" class="hljs-title">.zshrc</span></code> - Should be used for the shell configuration and for executing commands.</li><li data-omnivore-anchor-idx="136"><code data-omnivore-anchor-idx="137" class="hljs language-asciidoc language-css"><span data-omnivore-anchor-idx="138" class="hljs-title">.zlogin</span></code> - Same purpose than <code data-omnivore-anchor-idx="139" class="hljs language-asciidoc language-css"><span data-omnivore-anchor-idx="140" class="hljs-title">.zprofile</span></code>, but read just after <code data-omnivore-anchor-idx="141" class="hljs language-asciidoc language-css"><span data-omnivore-anchor-idx="142" class="hljs-title">.zshrc</span></code>.</li><li data-omnivore-anchor-idx="143"><code data-omnivore-anchor-idx="144" class="hljs language-asciidoc language-css"><span data-omnivore-anchor-idx="145" class="hljs-title">.zlogout</span></code> - Can be used to execute commands when a shell exit.</li></ol><p data-omnivore-anchor-idx="146">We’ll use only <code data-omnivore-anchor-idx="147" class="hljs language-asciidoc language-css"><span data-omnivore-anchor-idx="148" class="hljs-title">.zshenv</span></code> and <code data-omnivore-anchor-idx="149" class="hljs language-asciidoc language-css"><span data-omnivore-anchor-idx="150" class="hljs-title">.zshrc</span></code> in this article.</p><h3 data-omnivore-anchor-idx="151" id="zsh-config-path">Zsh Config Path</h3><p data-omnivore-anchor-idx="152">By default, Zsh will try to find the user’s configuration files in the <code data-omnivore-anchor-idx="153" class="hljs language-gams language-autoit"><span data-omnivore-anchor-idx="154" class="hljs-meta"><span data-omnivore-anchor-idx="155" class="hljs-meta-keyword">$HOME</span></span></code> directory. You can change it by setting the environment variable <code data-omnivore-anchor-idx="156" class="hljs language-gams language-autoit"><span data-omnivore-anchor-idx="157" class="hljs-meta"><span data-omnivore-anchor-idx="158" class="hljs-meta-keyword">$ZDOTDIR</span></span></code>.</p><p data-omnivore-anchor-idx="159">Personally, I like to have all my configuration files in <code data-omnivore-anchor-idx="160" class="hljs language-gams language-arduino"><span data-omnivore-anchor-idx="161" class="hljs-meta"><span data-omnivore-anchor-idx="162" class="hljs-meta-keyword">$HOME</span>/.config</span></code>. To do so:</p><ol data-omnivore-anchor-idx="163"><li data-omnivore-anchor-idx="164">I set the variable <code data-omnivore-anchor-idx="165" class="hljs language-gams language-autoit"><span data-omnivore-anchor-idx="166" class="hljs-meta"><span data-omnivore-anchor-idx="167" class="hljs-meta-keyword">$XDG</span>_CONFIG_HOME</span></code> as following: <code data-omnivore-anchor-idx="168" class="hljs language-routeros language-bash"><span data-omnivore-anchor-idx="169" class="hljs-builtin-name">export</span> <span data-omnivore-anchor-idx="170" class="hljs-attribute">XDG_CONFIG_HOME</span>=<span data-omnivore-anchor-idx="171" class="hljs-string">"<span data-omnivore-anchor-idx="172" class="hljs-variable">$HOME</span>/.config"</span></code>.</li><li data-omnivore-anchor-idx="173">I set the environment variable <code data-omnivore-anchor-idx="174" class="hljs language-gams language-autoit"><span data-omnivore-anchor-idx="175" class="hljs-meta"><span data-omnivore-anchor-idx="176" class="hljs-meta-keyword">$ZDOTDIR</span></span></code>: <code data-omnivore-anchor-idx="177" class="hljs language-routeros language-bash"><span data-omnivore-anchor-idx="178" class="hljs-builtin-name">export</span> <span data-omnivore-anchor-idx="179" class="hljs-attribute">ZDOTDIR</span>=<span data-omnivore-anchor-idx="180" class="hljs-string">"<span data-omnivore-anchor-idx="181" class="hljs-variable">$XDG_CONFIG_HOME</span>/zsh"</span></code>.</li><li data-omnivore-anchor-idx="182">I put the file <code data-omnivore-anchor-idx="183" class="hljs language-asciidoc language-css"><span data-omnivore-anchor-idx="184" class="hljs-title">.zshrc</span></code> in the <code data-omnivore-anchor-idx="185" class="hljs language-gams language-autoit"><span data-omnivore-anchor-idx="186" class="hljs-meta"><span data-omnivore-anchor-idx="187" class="hljs-meta-keyword">$ZDOTDIR</span></span></code> directory.</li></ol><p data-omnivore-anchor-idx="188">Most software will use the path in <code data-omnivore-anchor-idx="189" class="hljs language-gams language-autoit"><span data-omnivore-anchor-idx="190" class="hljs-meta"><span data-omnivore-anchor-idx="191" class="hljs-meta-keyword">$XDG</span>_CONFIG_HOME</span></code> to install their own config files. As a result, you’ll have a clean <code data-omnivore-anchor-idx="192" class="hljs language-gams language-autoit"><span data-omnivore-anchor-idx="193" class="hljs-meta"><span data-omnivore-anchor-idx="194" class="hljs-meta-keyword">$HOME</span></span></code> directory.</p><p data-omnivore-anchor-idx="195">Unfortunately, the file <code data-omnivore-anchor-idx="196" class="hljs language-asciidoc language-css"><span data-omnivore-anchor-idx="197" class="hljs-title">.zshenv</span></code> <strong data-omnivore-anchor-idx="198">needs to be in your home directory</strong>. It’s where you’ll set <code data-omnivore-anchor-idx="199" class="hljs language-gams language-autoit"><span data-omnivore-anchor-idx="200" class="hljs-meta"><span data-omnivore-anchor-idx="201" class="hljs-meta-keyword">$ZDOTDIR</span></span></code>. Then, every file read after <code data-omnivore-anchor-idx="202" class="hljs language-asciidoc language-css"><span data-omnivore-anchor-idx="203" class="hljs-title">.zshenv</span></code> can go into your <code data-omnivore-anchor-idx="204" class="hljs language-gams language-autoit"><span data-omnivore-anchor-idx="205" class="hljs-meta"><span data-omnivore-anchor-idx="206" class="hljs-meta-keyword">$ZDOTDIR</span></span></code> directory.</p><h2 data-omnivore-anchor-idx="207" id="zsh-basic-config">Zsh Basic Config</h2><h3 data-omnivore-anchor-idx="208" id="environment-variables">Environment Variables</h3><p data-omnivore-anchor-idx="209">As we saw, you can set the environment variables you need for your user’s session in the file <code data-omnivore-anchor-idx="210" class="hljs language-gams language-autoit"><span data-omnivore-anchor-idx="211" class="hljs-meta"><span data-omnivore-anchor-idx="212" class="hljs-meta-keyword">$HOME</span>/.zshenv</span></code>. This file should only define environment variables.</p><p data-omnivore-anchor-idx="213">For example, you can set up the <a data-omnivore-anchor-idx="214" href="https://wiki.archlinux.org/index.php/XDG_Base_Directory" target="_blank" rel="noopener">XDG Base directory</a> there, as seen above:</p><div data-omnivore-anchor-idx="215"><pre data-omnivore-anchor-idx="216" tabindex="0"><code data-omnivore-anchor-idx="217" class="hljs language-routeros language-bash"><span data-omnivore-anchor-idx="218" class="hljs-builtin-name">export</span> <span data-omnivore-anchor-idx="219" class="hljs-attribute">XDG_CONFIG_HOME</span>=<span data-omnivore-anchor-idx="220" class="hljs-string">"<span data-omnivore-anchor-idx="221" class="hljs-variable">$HOME</span>/.config"</span>
+<span data-omnivore-anchor-idx="222" class="hljs-builtin-name">export</span> <span data-omnivore-anchor-idx="223" class="hljs-attribute">XDG_DATA_HOME</span>=<span data-omnivore-anchor-idx="224" class="hljs-string">"<span data-omnivore-anchor-idx="225" class="hljs-variable">$XDG_CONFIG_HOME</span>/local/share"</span>
+<span data-omnivore-anchor-idx="226" class="hljs-builtin-name">export</span> <span data-omnivore-anchor-idx="227" class="hljs-attribute">XDG_CACHE_HOME</span>=<span data-omnivore-anchor-idx="228" class="hljs-string">"<span data-omnivore-anchor-idx="229" class="hljs-variable">$XDG_CONFIG_HOME</span>/cache"</span>
+</code></pre></div><p data-omnivore-anchor-idx="230">You can also make sure that any program requiring a text editor use your favorite one:</p><div data-omnivore-anchor-idx="231"><pre data-omnivore-anchor-idx="232" tabindex="0"><code data-omnivore-anchor-idx="233" class="hljs language-routeros language-cpp"><span data-omnivore-anchor-idx="234" class="hljs-builtin-name">export</span> <span data-omnivore-anchor-idx="235" class="hljs-attribute">EDITOR</span>=<span data-omnivore-anchor-idx="236" class="hljs-string">"nvim"</span>
+<span data-omnivore-anchor-idx="237" class="hljs-builtin-name">export</span> <span data-omnivore-anchor-idx="238" class="hljs-attribute">VISUAL</span>=<span data-omnivore-anchor-idx="239" class="hljs-string">"nvim"</span>
+</code></pre></div><p data-omnivore-anchor-idx="240">You can set some Zsh environment variables, too:</p><div data-omnivore-anchor-idx="241"><pre data-omnivore-anchor-idx="242" tabindex="0"><code data-omnivore-anchor-idx="243" class="hljs language-routeros language-bash"><span data-omnivore-anchor-idx="244" class="hljs-builtin-name">export</span> <span data-omnivore-anchor-idx="245" class="hljs-attribute">ZDOTDIR</span>=<span data-omnivore-anchor-idx="246" class="hljs-string">"<span data-omnivore-anchor-idx="247" class="hljs-variable">$XDG_CONFIG_HOME</span>/zsh"</span>
+
+<span data-omnivore-anchor-idx="248" class="hljs-builtin-name">export</span> <span data-omnivore-anchor-idx="249" class="hljs-attribute">HISTFILE</span>=<span data-omnivore-anchor-idx="250" class="hljs-string">"<span data-omnivore-anchor-idx="251" class="hljs-variable">$ZDOTDIR</span>/.zhistory"</span> # History filepath
+<span data-omnivore-anchor-idx="252" class="hljs-builtin-name">export</span> <span data-omnivore-anchor-idx="253" class="hljs-attribute">HISTSIZE</span>=10000 # Maximum events <span data-omnivore-anchor-idx="254" class="hljs-keyword">for</span> internal history
+<span data-omnivore-anchor-idx="255" class="hljs-builtin-name">export</span> <span data-omnivore-anchor-idx="256" class="hljs-attribute">SAVEHIST</span>=10000 # Maximum events <span data-omnivore-anchor-idx="257" class="hljs-keyword">in</span> history file
+</code></pre></div><p data-omnivore-anchor-idx="258">I already explained the first line. For the other ones, they will:</p><ul data-omnivore-anchor-idx="259"><li data-omnivore-anchor-idx="260">Store your command line history in the file <code data-omnivore-anchor-idx="261" class="hljs language-asciidoc language-css"><span data-omnivore-anchor-idx="262" class="hljs-title">.zhistory</span></code>.</li><li data-omnivore-anchor-idx="263">Allows you to have a history of 10000 entries maximum.</li></ul><p data-omnivore-anchor-idx="264"><a data-omnivore-anchor-idx="265" href="https://github.com/Phantas0s/.dotfiles/blob/master/zsh/zshenv" target="_blank" rel="noopener">Here’s my .zshenv file</a>, if you need some inspiration.</p><h3 data-omnivore-anchor-idx="266" id="aliases">Aliases</h3><p data-omnivore-anchor-idx="267">Aliases are crucial to improve your efficiency. For example, I have a bunch of aliases for git I use all the time. It’s always easier to type when it’s shorter:</p><div data-omnivore-anchor-idx="268"><pre data-omnivore-anchor-idx="269" tabindex="0"><code data-omnivore-anchor-idx="270" class="hljs language-vhdl language-monkey"><span data-omnivore-anchor-idx="271" class="hljs-keyword">alias</span> gs=<span data-omnivore-anchor-idx="272" class="hljs-symbol">'git</span> status'
+<span data-omnivore-anchor-idx="273" class="hljs-keyword">alias</span> ga=<span data-omnivore-anchor-idx="274" class="hljs-symbol">'git</span> add'
+<span data-omnivore-anchor-idx="275" class="hljs-keyword">alias</span> gp=<span data-omnivore-anchor-idx="276" class="hljs-symbol">'git</span> push'
+<span data-omnivore-anchor-idx="277" class="hljs-keyword">alias</span> gpo=<span data-omnivore-anchor-idx="278" class="hljs-symbol">'git</span> push origin'
+<span data-omnivore-anchor-idx="279" class="hljs-keyword">alias</span> gtd=<span data-omnivore-anchor-idx="280" class="hljs-symbol">'git</span> tag <span data-omnivore-anchor-idx="281" class="hljs-comment">--delete'</span>
+<span data-omnivore-anchor-idx="282" class="hljs-keyword">alias</span> gtdr=<span data-omnivore-anchor-idx="283" class="hljs-symbol">'git</span> tag <span data-omnivore-anchor-idx="284" class="hljs-comment">--delete origin'</span>
+<span data-omnivore-anchor-idx="285" class="hljs-keyword">alias</span> gr=<span data-omnivore-anchor-idx="286" class="hljs-symbol">'git</span> branch -r'
+<span data-omnivore-anchor-idx="287" class="hljs-keyword">alias</span> gplo=<span data-omnivore-anchor-idx="288" class="hljs-symbol">'git</span> pull origin'
+<span data-omnivore-anchor-idx="289" class="hljs-keyword">alias</span> gb=<span data-omnivore-anchor-idx="290" class="hljs-symbol">'git</span> branch '
+<span data-omnivore-anchor-idx="291" class="hljs-keyword">alias</span> gc=<span data-omnivore-anchor-idx="292" class="hljs-symbol">'git</span> commit'
+<span data-omnivore-anchor-idx="293" class="hljs-keyword">alias</span> gd=<span data-omnivore-anchor-idx="294" class="hljs-symbol">'git</span> diff'
+<span data-omnivore-anchor-idx="295" class="hljs-keyword">alias</span> gco=<span data-omnivore-anchor-idx="296" class="hljs-symbol">'git</span> checkout '
+<span data-omnivore-anchor-idx="297" class="hljs-keyword">alias</span> gl=<span data-omnivore-anchor-idx="298" class="hljs-symbol">'git</span> log'
+<span data-omnivore-anchor-idx="299" class="hljs-keyword">alias</span> gr=<span data-omnivore-anchor-idx="300" class="hljs-symbol">'git</span> remote'
+<span data-omnivore-anchor-idx="301" class="hljs-keyword">alias</span> grs=<span data-omnivore-anchor-idx="302" class="hljs-symbol">'git</span> remote show'
+<span data-omnivore-anchor-idx="303" class="hljs-keyword">alias</span> glo=<span data-omnivore-anchor-idx="304" class="hljs-symbol">'git</span> log <span data-omnivore-anchor-idx="305" class="hljs-comment">--pretty="oneline"'</span>
+<span data-omnivore-anchor-idx="306" class="hljs-keyword">alias</span> glol=<span data-omnivore-anchor-idx="307" class="hljs-symbol">'git</span> log <span data-omnivore-anchor-idx="308" class="hljs-comment">--graph --oneline --decorate'</span>
+</code></pre></div><p data-omnivore-anchor-idx="309">I like to have my aliases in one separate file (called, surprisingly, <code data-omnivore-anchor-idx="310" class="hljs language-ebnf language-maxima"><span data-omnivore-anchor-idx="311" class="hljs-attribute">aliases</span></code>), and I source it in my <code data-omnivore-anchor-idx="312" class="hljs language-asciidoc language-css"><span data-omnivore-anchor-idx="313" class="hljs-title">.zshrc</span></code>:</p><div data-omnivore-anchor-idx="314"><pre data-omnivore-anchor-idx="315" tabindex="0"><code data-omnivore-anchor-idx="316" class="hljs language-gradle language-applescript"><span data-omnivore-anchor-idx="317" class="hljs-keyword">source</span> <span data-omnivore-anchor-idx="318" class="hljs-regexp">/path/</span>to<span data-omnivore-anchor-idx="319" class="hljs-regexp">/my/</span>aliases
+</code></pre></div><p data-omnivore-anchor-idx="320">Here are <a data-omnivore-anchor-idx="321" href="https://github.com/Phantas0s/.dotfiles/blob/master/aliases/aliases" target="_blank" rel="noopener">all my aliases</a>.</p><h3 data-omnivore-anchor-idx="322" id="zsh-options">Zsh Options</h3><p data-omnivore-anchor-idx="323">You can set or unset many <a data-omnivore-anchor-idx="324" href="http://zsh.sourceforge.net/Doc/Release/Options.html" target="_blank" rel="noopener">Zsh options</a> using <code data-omnivore-anchor-idx="325" class="hljs language-bash language-ebnf"><span data-omnivore-anchor-idx="326" class="hljs-built_in">setopt</span></code> or <code data-omnivore-anchor-idx="327" class="hljs language-bash language-ebnf"><span data-omnivore-anchor-idx="328" class="hljs-built_in">unsetopt</span></code>. For example:</p><div data-omnivore-anchor-idx="329"><pre data-omnivore-anchor-idx="330" tabindex="0"><code data-omnivore-anchor-idx="331" class="hljs language-bash language-delphi"><span data-omnivore-anchor-idx="332" class="hljs-built_in">setopt</span> HIST_SAVE_NO_DUPS <span data-omnivore-anchor-idx="333" class="hljs-comment"># Do not write a duplicate event to the history file.</span>
+<span data-omnivore-anchor-idx="334" class="hljs-built_in">unsetopt</span> HIST_SAVE_NO_DUPS <span data-omnivore-anchor-idx="335" class="hljs-comment"># Write a duplicate event to the history file</span>
+</code></pre></div><p data-omnivore-anchor-idx="336">You can already do a lot of customization only using these options.</p><h3 data-omnivore-anchor-idx="337" id="zsh-completion-system">Zsh Completion System</h3><p data-omnivore-anchor-idx="338">The completion system of Zsh is one of its bigger strength, compared to other shells.</p><p data-omnivore-anchor-idx="339">To initialize the completion for the current Zsh session, you’ll need to call the function <code data-omnivore-anchor-idx="340" class="hljs language-ebnf"><span data-omnivore-anchor-idx="341" class="hljs-attribute">compinit</span></code>. More precisely, you’ll need to add this in your <code data-omnivore-anchor-idx="342" class="hljs language-ebnf"><span data-omnivore-anchor-idx="343" class="hljs-attribute">zshrc</span></code>:</p><div data-omnivore-anchor-idx="344"><pre data-omnivore-anchor-idx="345" tabindex="0"><code data-omnivore-anchor-idx="346" class="hljs language-nginx language-abnf"><span data-omnivore-anchor-idx="347" class="hljs-attribute">autoload</span> -U compinit; <span data-omnivore-anchor-idx="348" class="hljs-attribute">compinit</span>
+</code></pre></div><p data-omnivore-anchor-idx="349">What does it mean?</p><p data-omnivore-anchor-idx="350">The <code data-omnivore-anchor-idx="351" class="hljs language-angelscript language-bash"><span data-omnivore-anchor-idx="352" class="hljs-built_in">auto</span>load</code> command load a file containing shell commands. To find this file, Zsh will look in the directories of the <em data-omnivore-anchor-idx="353">Zsh file search path</em>, defined in the variable <code data-omnivore-anchor-idx="354" class="hljs language-gams language-arcade"><span data-omnivore-anchor-idx="355" class="hljs-meta"><span data-omnivore-anchor-idx="356" class="hljs-meta-keyword">$fpath</span></span></code>, and search a file called <code data-omnivore-anchor-idx="357" class="hljs language-ebnf"><span data-omnivore-anchor-idx="358" class="hljs-attribute">compinit</span></code>.</p><p data-omnivore-anchor-idx="359">When <code data-omnivore-anchor-idx="360" class="hljs language-ebnf"><span data-omnivore-anchor-idx="361" class="hljs-attribute">compinit</span></code> is found, its content will be loaded as a <em data-omnivore-anchor-idx="362">function</em>. The function name will be the name of the file. You can then call this function like any other shell function.</p><div data-omnivore-anchor-idx="363"><p data-omnivore-anchor-idx="364">What about the semi-colon <code data-omnivore-anchor-idx="365" class="hljs language-abnf language-ini"><span data-omnivore-anchor-idx="366" class="hljs-comment">;</span></code>? It’s just a handy way to separate commands. It’s the same as calling <code data-omnivore-anchor-idx="367" class="hljs language-ebnf"><span data-omnivore-anchor-idx="368" class="hljs-attribute">compinit</span></code> on a new line.</p></div><p data-omnivore-anchor-idx="369">Why using autoload, and not sourcing the file by doing <code data-omnivore-anchor-idx="370" class="hljs language-gradle language-arcade"><span data-omnivore-anchor-idx="371" class="hljs-keyword">source</span> ~<span data-omnivore-anchor-idx="372" class="hljs-regexp">/path/</span>of<span data-omnivore-anchor-idx="373" class="hljs-regexp">/compinit</span></code>?</p><ul data-omnivore-anchor-idx="374"><li data-omnivore-anchor-idx="375">It avoids name conflicts if you have an executable with the same name.</li><li data-omnivore-anchor-idx="376">It doesn’t expand aliases thanks to the <code data-omnivore-anchor-idx="377" class="hljs language-diff language-haml"><span data-omnivore-anchor-idx="378" class="hljs-deletion">-U</span></code> option.</li><li data-omnivore-anchor-idx="379">It will load the function only when it’s needed (lazy-loading). It comes in handy to speed up Zsh startup.</li></ul><p data-omnivore-anchor-idx="380">Then, let’s add the following;</p><div data-omnivore-anchor-idx="381"><pre data-omnivore-anchor-idx="382" tabindex="0"><code data-omnivore-anchor-idx="383" class="hljs language-applescript language-dts">_comp_options+=(globdots) <span data-omnivore-anchor-idx="384" class="hljs-comment"># With hidden files</span>
+source /<span data-omnivore-anchor-idx="385" class="hljs-keyword">my</span>/path/<span data-omnivore-anchor-idx="386" class="hljs-keyword">to</span>/zsh/completion.zsh
+</code></pre></div><p data-omnivore-anchor-idx="387">The first line will complete <a data-omnivore-anchor-idx="388" href="https://wiki.archlinux.org/index.php/Dotfiles" target="_blank" rel="noopener">dotfiles</a>.</p><p data-omnivore-anchor-idx="389">The second line source <a data-omnivore-anchor-idx="390" href="https://github.com/Phantas0s/.dotfiles/blob/master/zsh/completion.zsh" target="_blank" rel="noopener">this file</a>. It’s my personal config for the Zsh completion. I’ve written an <a data-omnivore-anchor-idx="391" href="https://thevaluable.dev/zsh-completion-guide-examples/">article about that</a> if you’re interested to dive more into the completion system.</p><p data-omnivore-anchor-idx="392">Now, the completion should work:</p><ul data-omnivore-anchor-idx="393"><li data-omnivore-anchor-idx="394">If you type <code data-omnivore-anchor-idx="395" class="hljs language-avrasm language-ebnf"><span data-omnivore-anchor-idx="396" class="hljs-keyword">cp</span></code> and hit the tab key, you’ll see that Zsh will complete the command.</li><li data-omnivore-anchor-idx="397">If you type <code data-omnivore-anchor-idx="398" class="hljs language-avrasm language-nginx"><span data-omnivore-anchor-idx="399" class="hljs-keyword">cp</span> -</code> and hit the tab key, Zsh will display the possible arguments for the command.</li></ul><picture data-omnivore-anchor-idx="400"><source data-omnivore-anchor-idx="401" srcset="https://proxy-prod.omnivore-image-cache.app/0x0,sfiBcmObf97NIeUibtBNabIdkPJ0sEqndbvVxv52zQmk/https://thevaluable.dev/images/2020/zsh/auto_complete.webp," type="image/webp"><img data-omnivore-anchor-idx="402" data-omnivore-original-src="https://thevaluable.dev/images/2020/zsh/auto_complete.png" width="780" height="520" src="https://proxy-prod.omnivore-image-cache.app/780x520,shXcZ-OuRAMljwivxvaLoPqZ9COFjw6mY9KEnyqQBCKQ/https://thevaluable.dev/images/2020/zsh/auto_complete.png" alt="Zsh completion in action"></picture><h3 data-omnivore-anchor-idx="403" id="pimp-my-zsh-prompt">Pimp My Zsh Prompt</h3><p data-omnivore-anchor-idx="404">What would be the shell experience without a nice prompt? Dull. Tasteless. Depressing.</p><p data-omnivore-anchor-idx="405">Let’s be honest here: Zsh default prompt is ugly. We need to change it, before our eyes start crying some blood. My needs are simple:</p><ul data-omnivore-anchor-idx="406"><li data-omnivore-anchor-idx="407">The prompt needs to be on one line. I had display problems with two lines.</li><li data-omnivore-anchor-idx="408">The prompt needs to display some git info when necessary.</li></ul><p data-omnivore-anchor-idx="409">From there, I created <a data-omnivore-anchor-idx="410" href="https://github.com/Phantas0s/purification/blob/master/prompt_purification_setup" target="_blank" rel="noopener">my own prompt</a> from <a data-omnivore-anchor-idx="411" href="https://github.com/therealklanni/purity" target="_blank" rel="noopener">another one</a>. It looks like that:</p><picture data-omnivore-anchor-idx="412"><source data-omnivore-anchor-idx="413" srcset="https://proxy-prod.omnivore-image-cache.app/0x0,sEbG09G1juFPo63j_VjykyvXcIJNnKy9th3zqNYTNLns/https://thevaluable.dev/images/2020/zsh/prompt.webp," type="image/webp"><img data-omnivore-anchor-idx="414" data-omnivore-original-src="https://thevaluable.dev/images/2020/zsh/prompt.png" width="780" height="520" src="https://proxy-prod.omnivore-image-cache.app/780x520,sYO_QmAuKGoSirbH4ZiWqkffidw64lNbq8Ixd6jKGOew/https://thevaluable.dev/images/2020/zsh/prompt.png" alt="Zsh prompt"></picture><p data-omnivore-anchor-idx="415">If you open the prompt script, you’ll see that it’s pretty simple:</p><ul data-omnivore-anchor-idx="416"><li data-omnivore-anchor-idx="417">I set two environment variables: <code data-omnivore-anchor-idx="418" class="hljs language-gams language-autoit"><span data-omnivore-anchor-idx="419" class="hljs-meta"><span data-omnivore-anchor-idx="420" class="hljs-meta-keyword">$PROMPT</span></span></code> and <code data-omnivore-anchor-idx="421" class="hljs language-gams language-autoit"><span data-omnivore-anchor-idx="422" class="hljs-meta"><span data-omnivore-anchor-idx="423" class="hljs-meta-keyword">$RPROMPT</span></span></code>. The first one format the left prompt, the second display git information on the far right.</li><li data-omnivore-anchor-idx="424">You can add some formatting styles using, for example, <code data-omnivore-anchor-idx="425" class="hljs language-haml language-cos"><span data-omnivore-anchor-idx="426" class="hljs-tag">%<span data-omnivore-anchor-idx="427" class="hljs-selector-tag">F</span>{blue}</span>%f</code> to change the color, or <code data-omnivore-anchor-idx="428" class="hljs language-cos language-gcode"><span data-omnivore-anchor-idx="429" class="hljs-built_in">%Bmy</span>-cool-prompt<span data-omnivore-anchor-idx="430" class="hljs-built_in">%b</span></code> to make everything bold.</li></ul><p data-omnivore-anchor-idx="431">This prompt doesn’t need any external <a data-omnivore-anchor-idx="432" href="https://thevaluable.dev/cohesion-coupling-guide-examples/">dependency</a>. You can copy it right away and modify it as much as you want.</p><p data-omnivore-anchor-idx="433"><a data-omnivore-anchor-idx="434" href="http://zsh.sourceforge.net/Doc/Release/Prompt-Expansion.html" target="_blank" rel="noopener">Here’s everything you need, to create the prompt of your dream</a>.</p><p data-omnivore-anchor-idx="435">To load the prompt, you need to add something like that in your <code data-omnivore-anchor-idx="436" class="hljs language-ebnf"><span data-omnivore-anchor-idx="437" class="hljs-attribute">zshrc</span></code>:</p><div data-omnivore-anchor-idx="438"><pre data-omnivore-anchor-idx="439" tabindex="0"><code data-omnivore-anchor-idx="440" class="hljs language-applescript language-arcade">fpath=(/<span data-omnivore-anchor-idx="441" class="hljs-keyword">my</span>/path/<span data-omnivore-anchor-idx="442" class="hljs-keyword">to</span>/zsh/prompt $fpath)
+autoload -Uz name_of_the_prompt_file; name_of_the_prompt_file
+</code></pre></div><p data-omnivore-anchor-idx="443">The first line will add the folder containing the prompt to <code data-omnivore-anchor-idx="444" class="hljs language-gams language-arcade"><span data-omnivore-anchor-idx="445" class="hljs-meta"><span data-omnivore-anchor-idx="446" class="hljs-meta-keyword">$fpath</span></span></code>, as discussed above. It will also ensure that any function declared in the folder <code data-omnivore-anchor-idx="447" class="hljs language-applescript language-awk">/<span data-omnivore-anchor-idx="448" class="hljs-keyword">my</span>/path/<span data-omnivore-anchor-idx="449" class="hljs-keyword">to</span>/zsh/prompt</code> will overwrite every other ones with the same name, in other <code data-omnivore-anchor-idx="450" class="hljs language-ebnf"><span data-omnivore-anchor-idx="451" class="hljs-attribute">fpath</span></code> folders.</p><p data-omnivore-anchor-idx="452">The second line autoload the prompt itself.</p><p data-omnivore-anchor-idx="453">This prompt require <a data-omnivore-anchor-idx="454" href="https://fontawesome.com/v4.7.0/" target="_blank" rel="noopener">font awesome 4</a> for the git icons. You can download the font and install it, or you can change the icons.</p><h3 data-omnivore-anchor-idx="455" id="zsh-directory-stack">Zsh Directory Stack</h3><p data-omnivore-anchor-idx="456">Zsh has commands to <a data-omnivore-anchor-idx="457" href="http://zsh.sourceforge.net/Intro/intro_6.html" target="_blank" rel="noopener">push and pop directories on a directory stack</a>.</p><p data-omnivore-anchor-idx="458">By manipulating this stack, you can set up an history of directory visited, and be able to jump back to these directories.</p><p data-omnivore-anchor-idx="459">First, let’s set some options in your <code data-omnivore-anchor-idx="460" class="hljs language-asciidoc language-css"><span data-omnivore-anchor-idx="461" class="hljs-title">.zshrc</span></code>:</p><div data-omnivore-anchor-idx="462"><pre data-omnivore-anchor-idx="463" tabindex="0"><code data-omnivore-anchor-idx="464" class="hljs language-bash language-nginx"><span data-omnivore-anchor-idx="465" class="hljs-built_in">setopt</span> AUTO_PUSHD <span data-omnivore-anchor-idx="466" class="hljs-comment"># Push the current directory visited on the stack.</span>
+<span data-omnivore-anchor-idx="467" class="hljs-built_in">setopt</span> PUSHD_IGNORE_DUPS <span data-omnivore-anchor-idx="468" class="hljs-comment"># Do not store duplicates in the stack.</span>
+<span data-omnivore-anchor-idx="469" class="hljs-built_in">setopt</span> PUSHD_SILENT <span data-omnivore-anchor-idx="470" class="hljs-comment"># Do not print the directory stack after pushd or popd.</span>
+</code></pre></div><p data-omnivore-anchor-idx="471">Then, you can create these aliases:</p><div data-omnivore-anchor-idx="472"><pre data-omnivore-anchor-idx="473" tabindex="0"><code data-omnivore-anchor-idx="474" class="hljs language-bash language-perl"><span data-omnivore-anchor-idx="475" class="hljs-built_in">alias</span> d=<span data-omnivore-anchor-idx="476" class="hljs-string">'dirs -v'</span>
+<span data-omnivore-anchor-idx="477" class="hljs-keyword">for</span> index ({1..9}) <span data-omnivore-anchor-idx="478" class="hljs-built_in">alias</span> <span data-omnivore-anchor-idx="479" class="hljs-string">"<span data-omnivore-anchor-idx="480" class="hljs-variable">$index</span>"</span>=<span data-omnivore-anchor-idx="481" class="hljs-string">"cd +<span data-omnivore-anchor-idx="482" class="hljs-variable">${index}</span>"</span>; <span data-omnivore-anchor-idx="483" class="hljs-built_in">unset</span> index
+</code></pre></div><p data-omnivore-anchor-idx="484">What does it do?</p><ul data-omnivore-anchor-idx="485"><li data-omnivore-anchor-idx="486">Every directory visited will populate the stack.</li><li data-omnivore-anchor-idx="487">When you use the alias <code data-omnivore-anchor-idx="488" class="hljs language-ebnf"><span data-omnivore-anchor-idx="489" class="hljs-attribute">d</span></code>, it will display the directories on the stack prefixed with a number.</li><li data-omnivore-anchor-idx="490">The line <code data-omnivore-anchor-idx="491" class="hljs language-perl language-bash"><span data-omnivore-anchor-idx="492" class="hljs-keyword">for</span> <span data-omnivore-anchor-idx="493" class="hljs-keyword">index</span> ({<span data-omnivore-anchor-idx="494" class="hljs-number">1</span>..<span data-omnivore-anchor-idx="495" class="hljs-number">9</span>}) alias <span data-omnivore-anchor-idx="496" class="hljs-string">"$index"</span>=<span data-omnivore-anchor-idx="497" class="hljs-string">"cd +<span data-omnivore-anchor-idx="498" class="hljs-subst">${<span data-omnivore-anchor-idx="499" class="hljs-keyword">index</span>}</span>"</span>; unset <span data-omnivore-anchor-idx="500" class="hljs-keyword">index</span></code> will create aliases from 1 to 9. They will allow you to jump directly in whatever directory on your stack.</li></ul><p data-omnivore-anchor-idx="501">For example, if you execute <code data-omnivore-anchor-idx="502" class="hljs language-angelscript language-lsl"><span data-omnivore-anchor-idx="503" class="hljs-number">1</span></code> in Zsh, you’ll jump to the directory prefixed with <code data-omnivore-anchor-idx="504" class="hljs language-angelscript language-lsl"><span data-omnivore-anchor-idx="505" class="hljs-number">1</span></code> in your stack list.</p><p data-omnivore-anchor-idx="506">You can also increase <code data-omnivore-anchor-idx="507" class="hljs language-angelscript language-lsl">index ({<span data-omnivore-anchor-idx="508" class="hljs-number">1.</span><span data-omnivore-anchor-idx="509" class="hljs-number">.9</span>})</code> to <code data-omnivore-anchor-idx="510" class="hljs language-angelscript language-lsl">index ({<span data-omnivore-anchor-idx="511" class="hljs-number">1.</span><span data-omnivore-anchor-idx="512" class="hljs-number">.100</span>})</code> for example, if you want to be able to jump back to 100 directories.</p><p data-omnivore-anchor-idx="513">For example, you can do that:</p><div data-omnivore-anchor-idx="514"><pre data-omnivore-anchor-idx="515" tabindex="0"><code data-omnivore-anchor-idx="516" class="hljs language-jboss-cli language-arduino">~ > <span data-omnivore-anchor-idx="517" class="hljs-keyword">cd</span> <span data-omnivore-anchor-idx="518" class="hljs-string">.config</span>
+~<span data-omnivore-anchor-idx="519" class="hljs-string">/.config</span> > <span data-omnivore-anchor-idx="520" class="hljs-keyword">cd</span> devdash
+~<span data-omnivore-anchor-idx="521" class="hljs-string">/.config/devdash</span> > <span data-omnivore-anchor-idx="522" class="hljs-keyword">cd</span> <span data-omnivore-anchor-idx="523" class="hljs-string">..</span>
+~<span data-omnivore-anchor-idx="524" class="hljs-string">/.config</span> > <span data-omnivore-anchor-idx="525" class="hljs-keyword">cd</span> i3
+~<span data-omnivore-anchor-idx="526" class="hljs-string">/.config/i3</span> > <span data-omnivore-anchor-idx="527" class="hljs-keyword">cd</span> <span data-omnivore-anchor-idx="528" class="hljs-string">..</span>
+~<span data-omnivore-anchor-idx="529" class="hljs-string">/.config</span> > d
+0 ~<span data-omnivore-anchor-idx="530" class="hljs-string">/.config</span>
+1 ~<span data-omnivore-anchor-idx="531" class="hljs-string">/.config/i3</span>
+2 ~<span data-omnivore-anchor-idx="532" class="hljs-string">/.config/devdash</span>
+3 ~
+~<span data-omnivore-anchor-idx="533" class="hljs-string">/.config</span> > 2
+~<span data-omnivore-anchor-idx="534" class="hljs-string">/.config/devdash</span> >
+</code></pre></div><h3 data-omnivore-anchor-idx="535" id="zsh-by-default">Zsh By Default</h3><p data-omnivore-anchor-idx="536">When you’re ready psychologically to set Zsh as your default shell, you can run these commands:</p><ul data-omnivore-anchor-idx="537"><li data-omnivore-anchor-idx="538">For Linux: <code data-omnivore-anchor-idx="539" class="hljs language-reasonml language-arcade">chsh -s <span data-omnivore-anchor-idx="540" class="hljs-constructor">$(<span data-omnivore-anchor-idx="541" class="hljs-params">which</span> <span data-omnivore-anchor-idx="542" class="hljs-params">zsh</span>)</span></code></li><li data-omnivore-anchor-idx="543">For macOS: <code data-omnivore-anchor-idx="544" class="hljs language-reasonml language-bash">sudo sh -c <span data-omnivore-anchor-idx="545" class="hljs-string">"echo $(which zsh) >> /etc/shells"</span><span data-omnivore-anchor-idx="546" class="hljs-operator"> && </span>chsh -s <span data-omnivore-anchor-idx="547" class="hljs-constructor">$(<span data-omnivore-anchor-idx="548" class="hljs-params">which</span> <span data-omnivore-anchor-idx="549" class="hljs-params">zsh</span>)</span></code></li></ul><p data-omnivore-anchor-idx="550">A good soul on Reddit whispered me that Zsh is now the default shell from macOS Catalina onwards, so you don’t necessarily need the above command.</p><p data-omnivore-anchor-idx="551">Zsh is now part of your life. Congratulation!</p><h2 data-omnivore-anchor-idx="552" id="zsh-with-vim-flavors">Zsh With Vim Flavors</h2><p data-omnivore-anchor-idx="553">For editing purposes, <a data-omnivore-anchor-idx="554" href="https://thevaluable.dev/phpstorm-vs-vim/">Vim is my best friend</a>. I love when CLIs use some Vim key binding, and Zsh gives you even more than that. If you’d like to learn Vim, this <a data-omnivore-anchor-idx="555" href="https://thevaluable.dev/vim-commands-beginner/" target="_blank" rel="noopener">series of articles</a> can help.</p><h3 data-omnivore-anchor-idx="556" id="activating-vi-mode">Activating Vi Mode</h3><p data-omnivore-anchor-idx="557">Zsh has a Vi mode you can enable by adding the following in your <code data-omnivore-anchor-idx="558" class="hljs language-asciidoc language-css"><span data-omnivore-anchor-idx="559" class="hljs-title">.zshrc</span></code>:</p><div data-omnivore-anchor-idx="560"><pre data-omnivore-anchor-idx="561" tabindex="0"><code data-omnivore-anchor-idx="562" class="hljs language-routeros language-bash">bindkey -v
+<span data-omnivore-anchor-idx="563" class="hljs-builtin-name">export</span> <span data-omnivore-anchor-idx="564" class="hljs-attribute">KEYTIMEOUT</span>=1
+</code></pre></div><p data-omnivore-anchor-idx="565">You can now switch between INSERT and NORMAL mode (called also COMMAND mode) with the <code data-omnivore-anchor-idx="566" class="hljs language-ebnf"><span data-omnivore-anchor-idx="567" class="hljs-attribute">ESC</span></code> key, and use the familiar Vim keystrokes to edit what you’re typing in your shell prompt. I write the different modes in uppercase here for clarity, but it doesn’t have to be.</p><p data-omnivore-anchor-idx="568">The second line <code data-omnivore-anchor-idx="569" class="hljs language-routeros language-angelscript"><span data-omnivore-anchor-idx="570" class="hljs-builtin-name">export</span> <span data-omnivore-anchor-idx="571" class="hljs-attribute">KEYTIMEOUT</span>=1</code> makes the switch between modes quicker.</p><h3 data-omnivore-anchor-idx="572" id="changing-cursor">Changing Cursor</h3><p data-omnivore-anchor-idx="573">A visual indicator to show the current mode (NORMAL or INSERT) could be nice. In Vim, my cursor is a beam <code data-omnivore-anchor-idx="574" class="hljs language-1c"><span data-omnivore-anchor-idx="575" class="hljs-string">|</span></code> when I’m in INSERT mode, and a block <code data-omnivore-anchor-idx="576" class="hljs language-undefined">█</code> when I’m in NORMAL mode. I wanted the same for Zsh.</p><p data-omnivore-anchor-idx="577">You can add the following in your <code data-omnivore-anchor-idx="578" class="hljs language-ebnf"><span data-omnivore-anchor-idx="579" class="hljs-attribute">zshrc</span></code>, or autoload it from a file, <a data-omnivore-anchor-idx="580" href="https://github.com/Phantas0s/.dotfiles/blob/master/zsh/plugins/cursor_mode" target="_blank" rel="noopener">as I did</a>.</p><div data-omnivore-anchor-idx="581"><pre data-omnivore-anchor-idx="582" tabindex="0"><code data-omnivore-anchor-idx="583" class="hljs language-bash language-perl"><span data-omnivore-anchor-idx="584" class="hljs-function"><span data-omnivore-anchor-idx="585" class="hljs-title">cursor_mode</span></span>() {
+ <span data-omnivore-anchor-idx="586" class="hljs-comment"># See https://ttssh2.osdn.jp/manual/4/en/usage/tips/vim.html for cursor shapes</span>
+ cursor_block=<span data-omnivore-anchor-idx="587" class="hljs-string">'\e[2 q'</span>
+ cursor_beam=<span data-omnivore-anchor-idx="588" class="hljs-string">'\e[6 q'</span>
+
+ <span data-omnivore-anchor-idx="589" class="hljs-keyword">function</span> <span data-omnivore-anchor-idx="590" class="hljs-built_in">zle</span>-keymap-select {
+ <span data-omnivore-anchor-idx="591" class="hljs-keyword">if</span> [[ <span data-omnivore-anchor-idx="592" class="hljs-variable">${KEYMAP}</span> == vicmd ]] ||
+ [[ <span data-omnivore-anchor-idx="593" class="hljs-variable">$1</span> = <span data-omnivore-anchor-idx="594" class="hljs-string">'block'</span> ]]; <span data-omnivore-anchor-idx="595" class="hljs-keyword">then</span>
+ <span data-omnivore-anchor-idx="596" class="hljs-built_in">echo</span> -ne <span data-omnivore-anchor-idx="597" class="hljs-variable">$cursor_block</span>
+ <span data-omnivore-anchor-idx="598" class="hljs-keyword">elif</span> [[ <span data-omnivore-anchor-idx="599" class="hljs-variable">${KEYMAP}</span> == main ]] ||
+ [[ <span data-omnivore-anchor-idx="600" class="hljs-variable">${KEYMAP}</span> == viins ]] ||
+ [[ <span data-omnivore-anchor-idx="601" class="hljs-variable">${KEYMAP}</span> = <span data-omnivore-anchor-idx="602" class="hljs-string">''</span> ]] ||
+ [[ <span data-omnivore-anchor-idx="603" class="hljs-variable">$1</span> = <span data-omnivore-anchor-idx="604" class="hljs-string">'beam'</span> ]]; <span data-omnivore-anchor-idx="605" class="hljs-keyword">then</span>
+ <span data-omnivore-anchor-idx="606" class="hljs-built_in">echo</span> -ne <span data-omnivore-anchor-idx="607" class="hljs-variable">$cursor_beam</span>
+ <span data-omnivore-anchor-idx="608" class="hljs-keyword">fi</span>
+ }
+
+ <span data-omnivore-anchor-idx="609" class="hljs-built_in">zle</span>-line-<span data-omnivore-anchor-idx="610" class="hljs-function"><span data-omnivore-anchor-idx="611" class="hljs-title">init</span></span>() {
+ <span data-omnivore-anchor-idx="612" class="hljs-built_in">echo</span> -ne <span data-omnivore-anchor-idx="613" class="hljs-variable">$cursor_beam</span>
+ }
+
+ <span data-omnivore-anchor-idx="614" class="hljs-built_in">zle</span> -N <span data-omnivore-anchor-idx="615" class="hljs-built_in">zle</span>-keymap-select
+ <span data-omnivore-anchor-idx="616" class="hljs-built_in">zle</span> -N <span data-omnivore-anchor-idx="617" class="hljs-built_in">zle</span>-line-init
+}
+
+cursor_mode
+</code></pre></div><p data-omnivore-anchor-idx="618">You can now speak about beams and blocks with passion and verve.</p><h3 data-omnivore-anchor-idx="619" id="vim-mapping-for-completion">Vim Mapping For Completion</h3><p data-omnivore-anchor-idx="620">To give Zsh more of a Vim taste, we can set up the keys <code data-omnivore-anchor-idx="621" class="hljs language-ebnf"><span data-omnivore-anchor-idx="622" class="hljs-attribute">hjkl</span></code> to navigate the completion menu.</p><p data-omnivore-anchor-idx="623">First, add the following to your <code data-omnivore-anchor-idx="624" class="hljs language-ebnf"><span data-omnivore-anchor-idx="625" class="hljs-attribute">zshrc</span></code>:</p><div data-omnivore-anchor-idx="626"><pre data-omnivore-anchor-idx="627" tabindex="0"><code data-omnivore-anchor-idx="628" class="hljs language-vim language-bash">zmodload zsh/complist
+bindkey -M menuselect <span data-omnivore-anchor-idx="629" class="hljs-string">'h'</span> <span data-omnivore-anchor-idx="630" class="hljs-keyword">vi</span>-backward-char
+bindkey -M menuselect <span data-omnivore-anchor-idx="631" class="hljs-string">'k'</span> <span data-omnivore-anchor-idx="632" class="hljs-keyword">vi</span>-<span data-omnivore-anchor-idx="633" class="hljs-keyword">up</span>-<span data-omnivore-anchor-idx="634" class="hljs-built_in">line</span>-<span data-omnivore-anchor-idx="635" class="hljs-built_in">or</span>-<span data-omnivore-anchor-idx="636" class="hljs-keyword">history</span>
+bindkey -M menuselect <span data-omnivore-anchor-idx="637" class="hljs-string">'l'</span> <span data-omnivore-anchor-idx="638" class="hljs-keyword">vi</span>-forward-char
+bindkey -M menuselect <span data-omnivore-anchor-idx="639" class="hljs-string">'j'</span> <span data-omnivore-anchor-idx="640" class="hljs-keyword">vi</span>-down-<span data-omnivore-anchor-idx="641" class="hljs-built_in">line</span>-<span data-omnivore-anchor-idx="642" class="hljs-built_in">or</span>-<span data-omnivore-anchor-idx="643" class="hljs-keyword">history</span>
+</code></pre></div><p data-omnivore-anchor-idx="644">We load here the Zsh module <code data-omnivore-anchor-idx="645" class="hljs language-ebnf"><span data-omnivore-anchor-idx="646" class="hljs-attribute">complist</span></code>. Modules have functionalities which are not part of the Zsh’s core, but they can be loaded on demand. <a data-omnivore-anchor-idx="647" href="http://zsh.sourceforge.net/Doc/Release/Zsh-Modules.html" target="_blank" rel="noopener">Many different modules are available</a> for your needs.</p><p data-omnivore-anchor-idx="648">Here, the module <code data-omnivore-anchor-idx="649" class="hljs language-ebnf"><span data-omnivore-anchor-idx="650" class="hljs-attribute">complist</span></code> give you access to the keymap <code data-omnivore-anchor-idx="651" class="hljs language-ebnf"><span data-omnivore-anchor-idx="652" class="hljs-attribute">menuselect</span></code>, to customize the menu selection during completion, including how to select what you want.</p><p data-omnivore-anchor-idx="653">In general, the command <code data-omnivore-anchor-idx="654" class="hljs language-armasm language-bash"><span data-omnivore-anchor-idx="655" class="hljs-keyword">bindkey </span>-M</code> bind a key to a specific <em data-omnivore-anchor-idx="656">keymap</em>. A keymap is a set of keystrokes bind to specific Zsh functions. In this case, the keymap <code data-omnivore-anchor-idx="657" class="hljs language-ebnf"><span data-omnivore-anchor-idx="658" class="hljs-attribute">menuselect</span></code> bind keystrokes with selecting something in a list.</p><p data-omnivore-anchor-idx="659">To list all the keymaps available (depending on the modules you’ve loaded), you can run in your shell <code data-omnivore-anchor-idx="660" class="hljs language-armasm language-bash"><span data-omnivore-anchor-idx="661" class="hljs-keyword">bindkey </span>-l</code> (for <code data-omnivore-anchor-idx="662" class="hljs language-ebnf"><span data-omnivore-anchor-idx="663" class="hljs-attribute">l</span></code>ist). You can also <a data-omnivore-anchor-idx="664" href="http://zsh.sourceforge.net/Doc/Release/Zsh-Line-Editor.html#Keymaps" target="_blank" rel="noopener">find the default ones here</a>.</p><p data-omnivore-anchor-idx="665">Last thing: you should always load the module <code data-omnivore-anchor-idx="666" class="hljs language-undefined">zsh/complist</code> <em data-omnivore-anchor-idx="667">before</em> autoloading <code data-omnivore-anchor-idx="668" class="hljs language-ebnf"><span data-omnivore-anchor-idx="669" class="hljs-attribute">compinit</span></code>.</p><h3 data-omnivore-anchor-idx="670" id="editing-command-lines-in-vim">Editing Command Lines In Vim</h3><p data-omnivore-anchor-idx="671">Good news: you can use your favorite editor to edit the commands you’re typing in your prompt! Let’s add these lines in your <code data-omnivore-anchor-idx="672" class="hljs language-asciidoc language-css"><span data-omnivore-anchor-idx="673" class="hljs-title">.zshrc</span></code> to do so:</p><div data-omnivore-anchor-idx="674"><pre data-omnivore-anchor-idx="675" tabindex="0"><code data-omnivore-anchor-idx="676" class="hljs language-vim language-gauss">autoload -Uz <span data-omnivore-anchor-idx="677" class="hljs-keyword">edit</span>-<span data-omnivore-anchor-idx="678" class="hljs-keyword">command</span>-<span data-omnivore-anchor-idx="679" class="hljs-built_in">line</span>
+zle -<span data-omnivore-anchor-idx="680" class="hljs-keyword">N</span> <span data-omnivore-anchor-idx="681" class="hljs-keyword">edit</span>-<span data-omnivore-anchor-idx="682" class="hljs-keyword">command</span>-<span data-omnivore-anchor-idx="683" class="hljs-built_in">line</span>
+bindkey -M vicmd v <span data-omnivore-anchor-idx="684" class="hljs-keyword">edit</span>-<span data-omnivore-anchor-idx="685" class="hljs-keyword">command</span>-<span data-omnivore-anchor-idx="686" class="hljs-built_in">line</span>
+</code></pre></div><p data-omnivore-anchor-idx="687">Here, we autoload <code data-omnivore-anchor-idx="688" class="hljs language-vim language-gauss"><span data-omnivore-anchor-idx="689" class="hljs-keyword">edit</span>-<span data-omnivore-anchor-idx="690" class="hljs-keyword">command</span>-<span data-omnivore-anchor-idx="691" class="hljs-built_in">line</span></code>, a function from the module <a data-omnivore-anchor-idx="692" href="https://linux.die.net/man/1/zshcontrib" target="_blank" rel="noopener">zshcontrib</a>, which includes many contributions from Zsh users. This specific function let you edit a command line in your visual editor, defined by the environment variable <code data-omnivore-anchor-idx="693" class="hljs language-gams language-autoit"><span data-omnivore-anchor-idx="694" class="hljs-meta"><span data-omnivore-anchor-idx="695" class="hljs-meta-keyword">$VISUAL</span></span></code> (or <code data-omnivore-anchor-idx="696" class="hljs language-gams language-autoit"><span data-omnivore-anchor-idx="697" class="hljs-meta"><span data-omnivore-anchor-idx="698" class="hljs-meta-keyword">$EDITOR</span></span></code>). Great! That’s what we wanted.</p><p data-omnivore-anchor-idx="699">We already saw <code data-omnivore-anchor-idx="700" class="hljs language-armasm language-bash"><span data-omnivore-anchor-idx="701" class="hljs-keyword">bindkey </span>-M</code>. Using the keymap <code data-omnivore-anchor-idx="702" class="hljs language-ebnf"><span data-omnivore-anchor-idx="703" class="hljs-attribute">vicmd</span></code>, we can bind commands to some NORMAL mode keystrokes. It means that, when you’re in NORMAL mode, you can hit <code data-omnivore-anchor-idx="704" class="hljs language-ebnf"><span data-omnivore-anchor-idx="705" class="hljs-attribute">v</span></code> to directly edit your command in your editor.</p><h3 data-omnivore-anchor-idx="706" id="adding-text-objects">Adding Text Objects</h3><p data-omnivore-anchor-idx="707">If you use the Vi-mode of Zsh for a while, you’ll notice that there are no text objects for quotes or brackets: impossible to do something like <code data-omnivore-anchor-idx="708" class="hljs language-1c language-vim">da<span data-omnivore-anchor-idx="709" class="hljs-string">"</span></code> (to delete a quoted substring) or <code data-omnivore-anchor-idx="710" class="hljs language-isbl language-stata"><span data-omnivore-anchor-idx="711" class="hljs-function"><span data-omnivore-anchor-idx="712" class="hljs-title">ci</span>(</span></code> (to change inside parenthesis). Zsh supports these, you just need to generate and bind them to specific Zsh widgets:</p><div data-omnivore-anchor-idx="713"><pre data-omnivore-anchor-idx="714" tabindex="0"><code data-omnivore-anchor-idx="715" class="hljs language-bash language-properties"><span data-omnivore-anchor-idx="716" class="hljs-built_in">autoload</span> -Uz select-bracketed select-quoted
+<span data-omnivore-anchor-idx="717" class="hljs-built_in">zle</span> -N select-quoted
+<span data-omnivore-anchor-idx="718" class="hljs-built_in">zle</span> -N select-bracketed
+<span data-omnivore-anchor-idx="719" class="hljs-keyword">for</span> km <span data-omnivore-anchor-idx="720" class="hljs-keyword">in</span> viopp visual; <span data-omnivore-anchor-idx="721" class="hljs-keyword">do</span>
+ <span data-omnivore-anchor-idx="722" class="hljs-built_in">bindkey</span> -M <span data-omnivore-anchor-idx="723" class="hljs-variable">$km</span> -- <span data-omnivore-anchor-idx="724" class="hljs-string">'-'</span> vi-up-line-or-history
+ <span data-omnivore-anchor-idx="725" class="hljs-keyword">for</span> c <span data-omnivore-anchor-idx="726" class="hljs-keyword">in</span> {a,i}<span data-omnivore-anchor-idx="727" class="hljs-variable">${(s..)^:-\'\"\`\|,./:;=+@}</span>; <span data-omnivore-anchor-idx="728" class="hljs-keyword">do</span>
+ <span data-omnivore-anchor-idx="729" class="hljs-built_in">bindkey</span> -M <span data-omnivore-anchor-idx="730" class="hljs-variable">$km</span> <span data-omnivore-anchor-idx="731" class="hljs-variable">$c</span> select-quoted
+ <span data-omnivore-anchor-idx="732" class="hljs-keyword">done</span>
+ <span data-omnivore-anchor-idx="733" class="hljs-keyword">for</span> c <span data-omnivore-anchor-idx="734" class="hljs-keyword">in</span> {a,i}<span data-omnivore-anchor-idx="735" class="hljs-variable">${(s..)^:-'()[]{}</span><>bB<span data-omnivore-anchor-idx="736" class="hljs-string">'}; do
+ bindkey -M $km $c select-bracketed
+ done
+done
+</span></code></pre></div><p data-omnivore-anchor-idx="737">If you want to know more about Zsh widgets, I’ve <a data-omnivore-anchor-idx="738" href="https://thevaluable.dev/zsh-line-editor-configuration-mouseless/">written another article about that</a>, where I also explain the code above.</p><h3 data-omnivore-anchor-idx="739" id="surrounding">Surrounding</h3><p data-omnivore-anchor-idx="740">Zsh also allows us to mimic the famous <a data-omnivore-anchor-idx="741" href="https://github.com/tpope/vim-surround" target="_blank" rel="noopener">Tim Pope’s surround plugin</a>. Just add the following to your <code data-omnivore-anchor-idx="742" class="hljs language-ebnf"><span data-omnivore-anchor-idx="743" class="hljs-attribute">zshrc</span></code>:</p><div data-omnivore-anchor-idx="744"><pre data-omnivore-anchor-idx="745" tabindex="0"><code data-omnivore-anchor-idx="746" class="hljs language-smali language-dsconfig">autoload -Uz surround
+zle -N delete-surround surround
+zle -N<span data-omnivore-anchor-idx="747" class="hljs-built_in"> add-surround </span>surround
+zle -N change-surround surround
+bindkey -M vicmd cs change-surround
+bindkey -M vicmd ds delete-surround
+bindkey -M vicmd ys<span data-omnivore-anchor-idx="748" class="hljs-built_in"> add-surround
+</span>bindkey -M visual S<span data-omnivore-anchor-idx="749" class="hljs-built_in"> add-surround
+</span></code></pre></div><p data-omnivore-anchor-idx="750">You can then use <code data-omnivore-anchor-idx="751" class="hljs language-ebnf language-stata"><span data-omnivore-anchor-idx="752" class="hljs-attribute">cs</span></code> (change surrounding), <code data-omnivore-anchor-idx="753" class="hljs language-ebnf language-stata"><span data-omnivore-anchor-idx="754" class="hljs-attribute">ds</span></code> (delete surrounding), <code data-omnivore-anchor-idx="755" class="hljs language-ebnf"><span data-omnivore-anchor-idx="756" class="hljs-attribute">ys</span></code> (add surrounding) in Zsh’s NORMAL mode.</p><h2 data-omnivore-anchor-idx="757" id="zsh-plugins">Zsh Plugins</h2><p data-omnivore-anchor-idx="758">The term “plugin”, as I use it, has nothing official. People often speak about Zsh plugins as external pieces of configuration you can add to your own.</p><p data-omnivore-anchor-idx="759">There are many of these plugins available for Zsh. Many of them are part of Zsh frameworks.</p><h3 data-omnivore-anchor-idx="760" id="zsh-completions">Zsh Completions</h3><p data-omnivore-anchor-idx="761">By default, Zsh can complete already many popular CLIs like <code data-omnivore-anchor-idx="762" class="hljs language-bash language-dos"><span data-omnivore-anchor-idx="763" class="hljs-built_in">cd</span></code>, <code data-omnivore-anchor-idx="764" class="hljs language-avrasm language-ebnf"><span data-omnivore-anchor-idx="765" class="hljs-keyword">cp</span></code>, <code data-omnivore-anchor-idx="766" class="hljs language-ebnf"><span data-omnivore-anchor-idx="767" class="hljs-attribute">git</span></code>, and so on.</p><p data-omnivore-anchor-idx="768">The plugin <a data-omnivore-anchor-idx="769" href="https://github.com/zsh-users/zsh-completions" target="_blank" rel="noopener">zsh-completions</a> add even more completions. The <a data-omnivore-anchor-idx="770" href="https://github.com/zsh-users/zsh-completions/tree/master/src" target="_blank" rel="noopener">list of the newly supported CLIs is here</a></p><p data-omnivore-anchor-idx="771">If you don’t use any of the program listed, you don’t need this plugin.</p><p data-omnivore-anchor-idx="772">I added <code data-omnivore-anchor-idx="773" class="hljs language-ebnf"><span data-omnivore-anchor-idx="774" class="hljs-attribute">zsh-completion</span></code> as a <a data-omnivore-anchor-idx="775" href="https://github.com/Phantas0s/.dotfiles/blob/master/.gitmodules" target="_blank" rel="noopener">git submodule in my dotfiles</a>. Then, you can automatically add every completion to your <code data-omnivore-anchor-idx="776" class="hljs language-ebnf"><span data-omnivore-anchor-idx="777" class="hljs-attribute">fpath</span></code>, in your zshrc:</p><div data-omnivore-anchor-idx="778"><pre data-omnivore-anchor-idx="779" tabindex="0"><code data-omnivore-anchor-idx="780" class="hljs language-elixir language-ruby">fpath=(<span data-omnivore-anchor-idx="781" class="hljs-regexp">/path/to</span><span data-omnivore-anchor-idx="782" class="hljs-regexp">/my/zsh</span><span data-omnivore-anchor-idx="783" class="hljs-regexp">/plugins/zsh</span>-completions/src <span data-omnivore-anchor-idx="784" class="hljs-variable">$fpath</span>)
+</code></pre></div><p data-omnivore-anchor-idx="785">You don’t need to load every completion file, one by one. If you look at the beginning of one of these files, you’ll see <code data-omnivore-anchor-idx="786" class="hljs language-ebnf"><span data-omnivore-anchor-idx="787" class="hljs-attribute">compdef</span></code>. It’s a function from Zsh which load automagically the completion when it’s needed. The completion file itself only needs to be included in your <code data-omnivore-anchor-idx="788" class="hljs language-ebnf"><span data-omnivore-anchor-idx="789" class="hljs-attribute">fpath</span></code>.</p><p data-omnivore-anchor-idx="790">You can also cherry-pick the specific completions you want.</p><h3 data-omnivore-anchor-idx="791" id="zsh-syntax-highlighting">Zsh Syntax Highlighting</h3><p data-omnivore-anchor-idx="792">What about syntax highlighting in Zsh? That’s what <a data-omnivore-anchor-idx="793" href="https://github.com/zsh-users/zsh-syntax-highlighting" target="_blank" rel="noopener">zsh-syntax-highlighting</a> is about.</p><p data-omnivore-anchor-idx="794">You can source it directly:</p><div data-omnivore-anchor-idx="795"><pre data-omnivore-anchor-idx="796" tabindex="0"><code data-omnivore-anchor-idx="797" class="hljs language-vim language-dts"><span data-omnivore-anchor-idx="798" class="hljs-keyword">source</span> /path/<span data-omnivore-anchor-idx="799" class="hljs-keyword">to</span>/my/zsh/plugins/zsh-<span data-omnivore-anchor-idx="800" class="hljs-keyword">syntax</span>-highlighting/zsh-<span data-omnivore-anchor-idx="801" class="hljs-keyword">syntax</span>-highlighting.zsh
+</code></pre></div><p data-omnivore-anchor-idx="802">There is one minor downside however: it seems to be currently incompatible with the surround widget we’ve seen above. If you want to use both, you need to use the branch <a data-omnivore-anchor-idx="803" href="https://github.com/zsh-users/zsh-syntax-highlighting/tree/feature/redrawhook" target="_blank" rel="noopener">feature/redrawhook</a>.</p><p data-omnivore-anchor-idx="804">You should source this plugin at the bottom of your <code data-omnivore-anchor-idx="805" class="hljs language-ebnf"><span data-omnivore-anchor-idx="806" class="hljs-attribute">zshrc</span></code>. Everything loaded before will then be able to use syntax highlighting if needed.</p><h3 data-omnivore-anchor-idx="807" id="jumping-to-a-parent-directory-easily">Jumping To A Parent Directory Easily</h3><p data-omnivore-anchor-idx="808">Do you like to type <code data-omnivore-anchor-idx="809" class="hljs language-routeros language-gams">cd <span data-omnivore-anchor-idx="810" class="hljs-built_in">..</span>/<span data-omnivore-anchor-idx="811" class="hljs-built_in">..</span>/<span data-omnivore-anchor-idx="812" class="hljs-built_in">..</span></code> to come back to the great-grand-parent of the current folder?</p><p data-omnivore-anchor-idx="813">Me neither.</p><p data-omnivore-anchor-idx="814">It’s where <a data-omnivore-anchor-idx="815" href="https://github.com/Tarrasch/zsh-bd" target="_blank" rel="noopener">bd</a> can help you. Imagine that you’re in the folder <code data-omnivore-anchor-idx="816" class="hljs language-awk language-crystal">~<span data-omnivore-anchor-idx="817" class="hljs-regexp">/a/</span>b<span data-omnivore-anchor-idx="818" class="hljs-regexp">/c/</span>d</code>. You can jump directly to <code data-omnivore-anchor-idx="819" class="hljs language-ebnf language-livecodeserver"><span data-omnivore-anchor-idx="820" class="hljs-attribute">a</span></code> with the command <code data-omnivore-anchor-idx="821" class="hljs language-armasm language-ebnf"><span data-omnivore-anchor-idx="822" class="hljs-keyword">bd </span>a</code>.</p><p data-omnivore-anchor-idx="823">The Zsh completion is even included. Awesomeness!</p><p data-omnivore-anchor-idx="824">To use it, you need to source the file <a data-omnivore-anchor-idx="825" href="https://github.com/Tarrasch/zsh-bd/blob/master/bd.zsh" target="_blank" rel="noopener">bd.zsh</a>.</p><h2 data-omnivore-anchor-idx="826" id="custom-scripts">Custom Scripts</h2><p data-omnivore-anchor-idx="827">Using a shell allows you to automate many parts of your workflow with shell scripts. That’s a huge benefit you should take advantage of.</p><p data-omnivore-anchor-idx="828">I keep most of <a data-omnivore-anchor-idx="829" href="https://github.com/Phantas0s/.dotfiles/blob/master/zsh/scripts.zsh" target="_blank" rel="noopener">my scripts in one file</a> and I <a data-omnivore-anchor-idx="830" href="https://github.com/Phantas0s/.dotfiles/blob/master/zsh/README.md" target="_blank" rel="noopener">document them</a> (roughly) for me to remember what’s in there, and for others to get inspired.</p><p data-omnivore-anchor-idx="831">I source the functions in my <code data-omnivore-anchor-idx="832" class="hljs language-asciidoc language-css"><span data-omnivore-anchor-idx="833" class="hljs-title">.zshrc</span></code>, but you could autoload them too.</p><p data-omnivore-anchor-idx="834">While working, ask yourself what tasks you do again and again, to automate them as much as you can. This is the real power of the shell, and it will make your whole workflow more fun.</p><h2 data-omnivore-anchor-idx="835" id="external-programs">External Programs</h2><p data-omnivore-anchor-idx="836">A shell without CLIs would be useless. Here are my personal favorites to expand Zsh functionalities.</p><h3 data-omnivore-anchor-idx="837" id="multiplex-your-zsh-with-tmux">Multiplex Your Zsh With tmux</h3><p data-omnivore-anchor-idx="838">I’ve already <a data-omnivore-anchor-idx="839" href="https://thevaluable.dev/tmux-boost-productivity-terminal/">written about tmux here</a>. It’s a terminal multiplexer with a tonne of functionalities: you can split your terminal in many windows or panes, synchronize them, and keep your sessions alive even without terminal. You can even extend it with plugins helping you automating your whole shell workflow.</p><h3 data-omnivore-anchor-idx="840" id="fuzzy-search-with-fzf">Fuzzy Search With fzf</h3><p data-omnivore-anchor-idx="841">The fuzzy finder <code data-omnivore-anchor-idx="842" class="hljs language-ebnf"><span data-omnivore-anchor-idx="843" class="hljs-attribute">fzf</span></code> is a fast and powerful tool. You can use it to search anything you want, like a file, an entry in your command line history, or a specific git commit message.</p><p data-omnivore-anchor-idx="844">I wrote (or copied and pasted) a bunch of <a data-omnivore-anchor-idx="845" href="https://github.com/Phantas0s/.dotfiles/blob/master/zsh/scripts_fzf.zsh" target="_blank" rel="noopener">scripts using zsh</a> too, to search through git logs or <code data-omnivore-anchor-idx="846" class="hljs language-ebnf"><span data-omnivore-anchor-idx="847" class="hljs-attribute">tmuxp</span></code> projects.</p><p data-omnivore-anchor-idx="848">There are different ways to install <code data-omnivore-anchor-idx="849" class="hljs language-ebnf"><span data-omnivore-anchor-idx="850" class="hljs-attribute">fzf</span></code>. You’ll need first the executable. Then, I would recommend sourcing the files:</p><ul data-omnivore-anchor-idx="851"><li data-omnivore-anchor-idx="852"><code data-omnivore-anchor-idx="853" class="hljs language-css language-gauss"><span data-omnivore-anchor-idx="854" class="hljs-selector-tag">key-bindings</span><span data-omnivore-anchor-idx="855" class="hljs-selector-class">.zsh</span></code>, which will include some practical keystrokes like <code data-omnivore-anchor-idx="856" class="hljs language-ebnf"><span data-omnivore-anchor-idx="857" class="hljs-attribute">Ctrl-h</span></code> or <code data-omnivore-anchor-idx="858" class="hljs language-ebnf language-excel"><span data-omnivore-anchor-idx="859" class="hljs-attribute">Ctrl-t</span></code></li><li data-omnivore-anchor-idx="860"><code data-omnivore-anchor-idx="861" class="hljs language-css"><span data-omnivore-anchor-idx="862" class="hljs-selector-tag">completion</span><span data-omnivore-anchor-idx="863" class="hljs-selector-class">.zsh</span></code>, for <code data-omnivore-anchor-idx="864" class="hljs language-ebnf"><span data-omnivore-anchor-idx="865" class="hljs-attribute">fzf</span></code> completion.</li></ul><p data-omnivore-anchor-idx="866">If you use Arch Linux, you’ll need to install the package <code data-omnivore-anchor-idx="867" class="hljs language-ebnf"><span data-omnivore-anchor-idx="868" class="hljs-attribute">fzf</span></code> and simply source these two files in your <code data-omnivore-anchor-idx="869" class="hljs language-ebnf"><span data-omnivore-anchor-idx="870" class="hljs-attribute">zshrc</span></code>:</p><div data-omnivore-anchor-idx="871"><pre data-omnivore-anchor-idx="872" tabindex="0"><code data-omnivore-anchor-idx="873" class="hljs language-gradle language-awk"><span data-omnivore-anchor-idx="874" class="hljs-keyword">source</span> <span data-omnivore-anchor-idx="875" class="hljs-regexp">/usr/</span>share<span data-omnivore-anchor-idx="876" class="hljs-regexp">/fzf/</span>completion.zsh
+<span data-omnivore-anchor-idx="877" class="hljs-keyword">source</span> <span data-omnivore-anchor-idx="878" class="hljs-regexp">/usr/</span>share<span data-omnivore-anchor-idx="879" class="hljs-regexp">/fzf/</span>key-bindings.zsh
+</code></pre></div><p data-omnivore-anchor-idx="880">Otherwise, you’ll need to follow the installation process from fzf’s README file.</p><h2 data-omnivore-anchor-idx="881" id="the-z-shell-is-now-yours">The Z-Shell Is Now Yours</h2><p data-omnivore-anchor-idx="882">You should now have a clean and lean Zsh configuration, and you should understand enough of it to customize it.</p><p data-omnivore-anchor-idx="883">What did we learn with this article?</p><ul data-omnivore-anchor-idx="884"><li data-omnivore-anchor-idx="885">Zsh reads its configuration files in a precise order.</li><li data-omnivore-anchor-idx="886">You can set (or unset) many Zsh options depending on your needs.</li><li data-omnivore-anchor-idx="887">The completion system of Zsh is one of its best feature.</li><li data-omnivore-anchor-idx="888">Zsh directory stack allow you to jump easily in directories you’ve already visited.</li><li data-omnivore-anchor-idx="889">If you like Vim, Zsh allows you to use keystrokes from the Vim world. You can even edit your commands directly in Vim.</li><li data-omnivore-anchor-idx="890">External plugins can be found on The Internet, to improve even further the Zsh experience.</li><li data-omnivore-anchor-idx="891">You should go crazy on shell scripting, to automate your workflow as much as you can.</li><li data-omnivore-anchor-idx="892">External programs can enhance your experience with the shell, like <code data-omnivore-anchor-idx="893" class="hljs language-ebnf"><span data-omnivore-anchor-idx="894" class="hljs-attribute">tmux</span></code> or <code data-omnivore-anchor-idx="895" class="hljs language-ebnf"><span data-omnivore-anchor-idx="896" class="hljs-attribute">fzf</span></code>.</li></ul><p data-omnivore-anchor-idx="897">All your colleagues will be jealous. Guaranteed.</p></section></article></main></div></DIV></DIV>
\ No newline at end of file
diff --git a/Omnivore/2024-02-15 - React Optimization Techniques to Help You Write More Performant Code.md b/Omnivore/2024-02-15 - React Optimization Techniques to Help You Write More Performant Code.md
new file mode 100644
index 0000000..c837547
--- /dev/null
+++ b/Omnivore/2024-02-15 - React Optimization Techniques to Help You Write More Performant Code.md
@@ -0,0 +1,764 @@
+---
+id: c4ab379e-cc84-11ee-b3d0-afc69cc1061d
+title: |
+ React Optimization Techniques to Help You Write More Performant Code
+status: ARCHIVED
+tags:
+ - read-later
+ - RSS
+date_added: 2024-02-15 21:57:28
+url_omnivore: |
+ https://omnivore.app/me/react-optimization-techniques-to-help-you-write-more-performant--18db03268c2
+url_original: |
+ https://www.freecodecamp.org/news/react-performance-optimization-techniques/
+---
+
+# React Optimization Techniques to Help You Write More Performant Code
+
+## Highlights
+
+List visualization, or windowing, involves rendering only the items currently visible on the screen.
+
+[source](https://omnivore.app/me/react-optimization-techniques-to-help-you-write-more-performant--18db03268c2#9fb355ed-811d-44e7-aa61-12c0b18db7e2)
+
+---
+
+Lazy loading allows you to defer or delay the loading of images until they are needed or visible to the user instead of loading all the images on page load.
+
+[source](https://omnivore.app/me/react-optimization-techniques-to-help-you-write-more-performant--18db03268c2#f9c0a23a-9d66-4a80-bb4c-a4f2806ed1aa)
+
+---
+
+Another approach is to use the [intersection observer API](https://developer.mozilla.org/en-US/docs/Web/API/Intersection%5FObserver%5FAPI), which is a web API that allows you to detect when an element enters or exists the viewport efficiently.
+
+[source](https://omnivore.app/me/react-optimization-techniques-to-help-you-write-more-performant--18db03268c2#a44706c9-5cce-4765-ac78-77efdca40a30)
+
+---
+
+Memoization in React is a technique used to optimize the performance of functional components by caching the results of expensive computations or function calls. It's particularly useful when dealing with computationally intensive or frequently called functions with the same input values, as it helps avoid redundant calculations and improves the overall efficiency of the application.
+
+[source](https://omnivore.app/me/react-optimization-techniques-to-help-you-write-more-performant--18db03268c2#051f1544-65d2-4eae-87c6-bb7f226c4fa7)
+
+---
+
+Below is an example on how to use the `React.memo` with a functional component:
+
+```javascript
+import React from 'react';
+
+const Post = ({ signedIn, post }) => {
+ console.log('Rendering Post');
+ return (
+
+ {post.title}
+ {post.content}
+ {signedIn && Edit Post}
+
+ );
+};
+
+export default React.memo(Post);
+
+```
+
+In the code above, `Post` (functional component) depends on the `signedIn` and `post` props. By wrapping it with `React.memo()`, React will only re-render the `Post` component if either `signedIn` or `post` changes.
+
+> [!note]
+> You can memoize complete components to prevent re-renders if the props doesn't change, this use `React.memo()`, not the `useMemo()` hook
+
+[source](https://omnivore.app/me/react-optimization-techniques-to-help-you-write-more-performant--18db03268c2#f0735f25-7bdf-4562-84cb-6f93f3a0b5a6)
+
+---
+
+The `useMemo()` hook optimizes performance by memoizing the result of a function call or an expensive computation. It caches the result and recalculates it only when the input values change.
+
+[source](https://omnivore.app/me/react-optimization-techniques-to-help-you-write-more-performant--18db03268c2#360c5717-251f-40d7-9dd8-24bccb26a59b)
+
+---
+
+The `useCallback()` hook in React is used to memoize a function instead of memoizing the function result. It is particularly useful when passing events as props to child components to prevent unnecessary re-renders.
+
+`useCallback()` memoizes the function, ensuring it remains the same across re-renders as long as the dependencies haven't changed.
+
+This is especially beneficial when passing functions as props to child components, preventing unnecessary re-renders.
+
+[source](https://omnivore.app/me/react-optimization-techniques-to-help-you-write-more-performant--18db03268c2#c01f0766-7401-44ae-9888-ee1da6d10ca7)
+
+---
+
+It's important to note that `useCallback` should be used sparingly and only for performance-critical parts of your application. Overusing `useCallback` can actually lead to worse performance due to the overhead of memoization itself. Always measure the performance impact before and after using `useCallback` to ensure it's having the desired effect.
+
+[source](https://omnivore.app/me/react-optimization-techniques-to-help-you-write-more-performant--18db03268c2#4292a582-b6cb-44e9-baff-3be6a127ed14)
+
+---
+
+Throttling in React is a technique used to limit the number of times a function or an event handler is invoked. It ensures that the function is called at a specified interval, preventing it from being executed too frequently.
+
+[source](https://omnivore.app/me/react-optimization-techniques-to-help-you-write-more-performant--18db03268c2#5e73fc50-7717-449d-a27f-f3bb87fd100f)
+
+---
+
+Debouncing, on the other hand, is also used to limit the number of times a function or an event handler is invoked. It ensures that the function is called only after a certain period of inactivity. Debouncing allows you to postpone the function call until the user has finished typing or a specific time has elapsed since the last event.
+
+[source](https://omnivore.app/me/react-optimization-techniques-to-help-you-write-more-performant--18db03268c2#2926578f-0a36-4acc-8c03-5d740981bb04)
+
+---
+
+// Debounce function to delay the searchAPI call const debounce = (func, delay) => {let timeoutId;return function (...args) { clearTimeout(timeoutId); timeoutId = setTimeout(() \=> { func(...args); }, delay); }; };
+
+[source](https://omnivore.app/me/react-optimization-techniques-to-help-you-write-more-performant--18db03268c2#131255d3-029e-43c9-8c5e-0489e786e425)
+
+---
+
+Code splitting in React is a technique used to split a large JavaScript bundle into smaller, manageable chunks. It helps improve performance by loading only the necessary code for a specific part of an application rather than loading the entire bundle upfront.
+
+[source](https://omnivore.app/me/react-optimization-techniques-to-help-you-write-more-performant--18db03268c2#9f66f0bf-2185-499a-a4f1-591e5af60182)
+
+---
+
+In this example, `AsyncComponent` is a component that uses `lazy` and `Suspense` to perform code splitting. The `DynamicComponent` is dynamically imported using the import() syntax.
+
+[source](https://omnivore.app/me/react-optimization-techniques-to-help-you-write-more-performant--18db03268c2#aff44dd9-50f2-4ad2-8f93-d52e6ab0988d)
+
+---
+
+Web Workers serve as a solution to alleviate the burden on the main thread. They allow the execution of scripts in the background on a separate thread, distinct from the main JavaScript thread.
+
+[source](https://omnivore.app/me/react-optimization-techniques-to-help-you-write-more-performant--18db03268c2#16416227-0870-4503-a67d-76418223953a)
+
+---
+
+The `useTransition` hook in React plays a pivotal role in improving the performance of applications by allowing the marking of state updates as non-blocking transitions. This capability enables React to defer rendering for these updates, preventing UI blocking and enhancing overall responsiveness.
+
+[source](https://omnivore.app/me/react-optimization-techniques-to-help-you-write-more-performant--18db03268c2#0622edf4-fa98-4848-aeee-174fa1cbde22)
+
+---
+
+## Original
+
+
+
+Performance optimization is a critical aspect of developing web applications. Users expect applications to load quickly and respond to their interactions smoothly.
+
+In the React ecosystem, performance optimization techniques can significantly enhance the user experience by reducing load times and improving responsiveness.
+
+In this article, we will discuss eight effective techniques for optimizing the performance of your React application.
+
+## Table of Contents
+
+1. [Why Performance Optimization is Important](#why-performance-optimization-is-important)
+2. [List visualization](#list-visualization)
+3. [Lazy Loading Images](#lazy-loading-images)
+4. [Memoization](#memoization)
+5. [Throttling and Debouncing Events](#throttling-and-debouncing-events)
+6. [Code Splitting](#code-splitting)
+7. [React Fragments](#react-fragments)
+8. [Web Workers](#web-workers)
+9. [UseTransition Hook](#usetransition-hook)
+10. [Conclusion](#conclusion)
+
+## Why Performance Optimization is Important
+
+Optimizing the performance of your React application is crucial for several reasons:
+
+* **Better User Experience:** A slow-loading or laggy application can lead to a poor user experience, negatively impacting your business. Users expect fast and responsive interactions, and performance optimization helps deliver that.
+* **Improved SEO:** Search engines like Google consider page load times and overall performance when ranking websites. A well-optimized application will rank higher in search results, making it more visible to potential users.
+* **Reduced Bounce Rates:** If your application takes too long to load or respond, users will likely leave and never return. By optimizing performance, you can reduce bounce rates and increase engagement.
+* **Cost Savings** A performant application requires fewer resources (like servers and memory) to handle the same workload. This means lower hosting costs and reduced infrastructure needs.
+* **Competitive Advantage:** A fast and efficient application sets you apart from competitors whose applications may be slower or less optimized. According to research by [Portent](https://www.portent.com/blog/analytics/research-site-speed-hurting-everyones-revenue.htm), a website that loads within one second has a conversion rate five times higher than a site that takes ten seconds to load. Therefore, ensuring your React applications perform well is crucial for retaining users and maintaining a competitive edge.
+
+## 8 React Performance Optimization Techniques
+
+Below are eight React performance optimization techniques you can use to speed up your applications.
+
+### List visualization
+
+==List visualization, or windowing, involves rendering only the items currently visible on the screen.==
+
+When dealing with a large number of items in a list, rendering all the items at once can lead to slow performance and consume a significant amount of memory. List virtualization tackles this issue by rendering only a subset of the list items currently visible within the view, which conserves resources as the users scroll through the list.
+
+The virtualization technique dynamically replaces rendered items with new ones, keeping the visible portion of the list updated and responsive. It efficiently allows you to render large lists or tabular data by only rendering the visible portion, recycling components as needed, and optimizing scroll performance.
+
+There are different approaches to implementing list visualization in React, and one is using a popular library called [React Virtualized](https://www.npmjs.com/package/react-virtualized).
+
+To install `react-virtualized`, you can use the following command:
+
+```sql
+npm install react-virtualized --save
+```
+
+After installing `react-virtualized`, you can import the required components and styles. Below is an example of how to use the `List` component to create a virtualized list:
+
+```javascript
+import React from 'react';
+import { List } from 'react-virtualized';
+import 'react-virtualized/styles.css'; // Import styles
+
+// Your list data
+const list = Array(5000).fill().map((_, index) => ({
+ id: index,
+ name: `Item ${index}`
+}));
+
+// Function to render each row
+function rowRenderer({ index, key, style }) {
+ return (
+ <div key={key} style={style}>
+ {list[index].name}
+ </div>
+ );
+}
+
+// Main component
+function MyVirtualizedList() {
+ return (
+ <List
+ width={300}
+ height={300}
+ rowCount={list.length}
+ rowHeight={20}
+ rowRenderer={rowRenderer}
+ />
+ );
+}
+
+export default MyVirtualizedList;
+
+```
+
+In this example, `List` is the main component provided by `react-virtualized`. The `rowRenderer` function defines how each row should be rendered. The `width`, `height`, `rowCount`, `rowHeight`, and `rowRenderer` props are essential for configuring the list's behavior and appearance.
+
+React applications can handle massive amounts of data by leveraging list virtualization without sacrificing performance or user experience.
+
+### Lazy Loading Images
+
+Similar to the list virtualization technique, lazy loading images prevents the creation of unnecessary DOM nodes, thereby boosting performance. Lazy loading allows you to defer or delay the loading of images until they are needed or visible to the user instead of loading all the images on page load.
+
+The concept behind lazy loading is to initiate the load of a placeholder or a small low-resolution version of the image, typically a small-sized thumbnail or a blurred placeholder. As the user scrolls or interacts with the page, the actual image is loaded dynamically, replacing the placeholder when the user enters the viewport or when it becomes visible.
+
+Lazy loading in React can be achieved using various libraries and techniques. One of the popular libraries is the [react-lazyload](https://www.npmjs.com/package/react-lazyload).
+
+To install `react-lazyload`, you can use the following command:
+
+```sql
+npm install --save react-lazyload
+```
+
+Below is an example of a simple React component that uses `react-lazyload` to implement lazy loading for images:
+
+```javascript
+import React from 'react';
+import LazyLoad from 'react-lazyload';
+
+const MyLazyLoadedImage = ({ src, alt }) => {
+ return (
+ <LazyLoad height={200} offset={100}>
+ {/* The height and offset props control when the image should start loading */}
+ <img src={src} alt={alt} />
+ </LazyLoad>
+ );
+};
+
+export default MyLazyLoadedImage;
+
+```
+
+In this example, `MyLazyLoadedImage` uses the `LazyLoad` component from `react-lazyload`. The `height` prop specifies the height of the placeholder, and the `offset` prop determines how far below the viewport the placeholder should start loading.
+
+==Another approach is to use the== ==[intersection observer API](https://developer.mozilla.org/en-US/docs/Web/API/Intersection%5FObserver%5FAPI)====, which is a web API that allows you to detect when an element enters or exists the viewport efficiently.== Here's how we can use the Intersection Observer API along with the `useEffect` hook in React:
+
+```javascript
+import React, { useEffect, useRef } from 'react';
+
+const IntersectionLazyLoad = ({ src, alt }) => {
+ const imageRef = useRef();
+
+ useEffect(() => {
+ const options = {
+ root: null, // Use the viewport as the root
+ rootMargin: '0px', // No margin around the root
+ threshold: 0.5, // 50% of the image should be visible
+ };
+
+ const observer = new IntersectionObserver(handleIntersection, options);
+
+ if (imageRef.current) {
+ observer.observe(imageRef.current);
+ }
+
+ return () => {
+ // Cleanup the observer when the component is unmounted
+ observer.disconnect();
+ };
+ }, []);
+
+ const handleIntersection = (entries) => {
+ entries.forEach((entry) => {
+ if (entry.isIntersecting) {
+ // Load the image when it becomes visible
+ imageRef.current.src = src;
+ imageRef.current.alt = alt;
+ }
+ });
+ };
+
+ return <img ref={imageRef} style={{ height: '200px' }} alt="Placeholder" />;
+};
+
+export default IntersectionLazyLoad;
+
+```
+
+In this example, `IntersectionLazyLoad` uses the Intersection Observer API to determine when the image becomes visible in the viewport.
+
+By utilizing this API along with React `useEffect` hook, you can implement your custom lazy loading solution for images in React.
+
+### Memoization
+
+Memoization in React is a technique used to optimize the performance of functional components by caching the results of expensive computations or function calls. It's particularly useful when dealing with computationally intensive or frequently called functions with the same input values, as it helps avoid redundant calculations and improves the overall efficiency of the application.
+
+In React, there are three techniques for memoization: `React.memo()`, `useMemo(),` and `useCallback().` Let's delve into the details for each:
+
+#### How to use `React.memo()`
+
+This higher-order component wraps purely functional components to prevent re-rendering if the received props remain unchanged.
+
+By using `React.memo()`, the rendering result is cached based on props. If the props haven't changed since the last render, React reuses the previously rendered result instead of redoing the rendering process. This saves time and resources.
+
+==Below is an example on how to use the== `==React====.====memo==` ==with a functional component:==
+
+```javascript
+import React from 'react';
+
+const Post = ({ signedIn, post }) => {
+ console.log('Rendering Post');
+ return (
+ <div>
+ <h2>{post.title}</h2>
+ <p>{post.content}</p>
+ {signedIn && <button>Edit Post</button>}
+ </div>
+ );
+};
+
+export default React.memo(Post);
+
+```
+
+==In the code above,== `==Post==` ==(functional component) depends on the== `==signedIn==` ==and== `==post==` ==props. By wrapping it with== `==React====.====memo====()==`==, React will only re-render the== `==Post==` ==component if either== `==signedIn==` ==or== `==post==` ==changes.==
+
+You can now use the memoized component like any other component in your application:
+
+```javascript
+import React, { useState } from 'react';
+import Post from './Post';
+
+const App = () => {
+ const [signedIn, setSignedIn] = useState(false);
+ const post = { title: 'Hello World', content: 'Welcome to my blog!' };
+
+ return (
+ <div>
+ <Post signedIn={signedIn} post={post} />
+ <button onClick={() => setSignedIn(!signedIn)}>
+ Toggle Signed In
+ </button>
+ </div>
+ );
+};
+
+export default App;
+
+```
+
+When you click the `Toggle Signed In` button, it will toggle the `signedIn` state. Since `Post` is wrapped with `React.memo()`, it will only re-render when the `signedIn` prop changes, thus saving rendering time and resources
+
+#### How to use `useMemo()`
+
+The `useMemo()` hook optimizes performance by memoizing the result of a function call or an expensive computation. It caches the result and recalculates it only when the input values change. Below is an example on how to use the `useMemo` hook in functional component:
+
+```javascript
+import React, { useMemo } from 'react';
+
+function App() {
+ const [count, setCount] = React.useState(0);
+ const [otherState, setOtherState] = React.useState('');
+
+ const expensiveComputation = (num) => {
+ let i = 0;
+ while (i < 1000000000) i++;
+ return num * num;
+ };
+
+ const memoizedValue = useMemo(() => expensiveComputation(count), [count]);
+
+ return (
+ <div>
+ <p>Count: {count}</p>
+ <p>Square: {memoizedValue}</p>
+ <button onClick={() => setCount(count + 1)}>Increase Count</button>
+ <input type="text" onChange={(e) => setOtherState(e.target.value)} />
+ </div>
+ );
+}
+
+export default App;
+
+```
+
+In the code above, the `expensiveComputation` function simulates a resource-intensive operation, like squaring a number.
+
+The `useMemo` hook is utilized to cache the result of this computation. The memoized value, stored in `memoizedValue`, is only recalculated when the `count` state changes, as `count` is specified as a dependency in the `useMemo` dependency array. Consequently, clicking the `Increase Count` button increments the `count` state, triggering a recalculation of the memoized value.
+
+Conversely, changing the `otherState` via the input field does not prompt a recalculation, as `otherState` is not included in the `useMemo` dependency array.
+
+#### How to use `useCallback()`
+
+The `useCallback()` hook in React is used to memoize a function instead of memoizing the function result. It is particularly useful when passing events as props to child components to prevent unnecessary re-renders.
+
+`useCallback()` memoizes the function, ensuring it remains the same across re-renders as long as the dependencies haven't changed.
+
+This is especially beneficial when passing functions as props to child components, preventing unnecessary re-renders. It is often used with `React.memo()` to ensure child components do not re-render when unnecessary. Below is an exmple of how to use the `useCallback()` hook:
+
+```javascript
+import React, { useState, useCallback } from 'react';
+
+const ParentComponent = () => {
+ const [count, setCount] = useState(0);
+
+ // Define a function that increments the count state
+ const incrementCount = () => {
+ setCount(count + 1);
+ };
+
+ // Memoize the incrementCount function using useCallback
+ const memoizedIncrement = useCallback(incrementCount, [count]);
+
+ return (
+ <div>
+ <p>Count: {count}</p>
+ <ChildComponent onIncrement={memoizedIncrement} />
+ </div>
+ );
+};
+
+const ChildComponent = React.memo(({ onIncrement }) => {
+ console.log('Child component rendered');
+ return (
+ <div>
+ <button onClick={onIncrement}>Increment Count</button>
+ </div>
+ );
+});
+
+export default ParentComponent;
+
+```
+
+In the code above, the `ParentComponent` is responsible for managing a state variable named `count` and introduces a function called `incrementCount`, which handles the incrementation of the count. Utilizing the `useCallback` hook, the `incrementCount` function is memoized, guaranteeing its stability across renders unless any of its dependencies, in this case, `count`, undergo changes.
+
+On the other hand, the `ChildComponent` is a component nested within the parent. It receives the memoized `onIncrement` function from the parent as a prop.
+
+To optimize performance and prevent unnecessary re-renders when the props remain constant, the `ChildComponent` is wrapped with `React.memo()`. This ensures that the child component will only re-render when its props, specifically the memoized function, experience changes, contributing to a more efficient rendering process.
+
+==It's important to note that== `==useCallback==` ==should be used sparingly and only for performance-critical parts of your application. Overusing== `==useCallback==` ==can actually lead to worse performance due to the overhead of memoization itself. Always measure the performance impact before and after using== `==useCallback==` ==to ensure it's having the desired effect.==
+
+### Throttling and Debouncing Events
+
+Throttling in React is a technique used to limit the number of times a function or an event handler is invoked. It ensures that the function is called at a specified interval, preventing it from being executed too frequently.
+
+Throttling allows you to control the rate at which the function is called by setting up a minimum time interval between each function invocation. If the function is called multiple times within that interval, only the first invocation is executed, and subsequent invocations are ignored until the interval elapses
+
+Now, let's illustrate throttling with a code example. First, without t==hrottling:==
+
+```javascript
+// Without throttling, this function will be called every time the event is triggered
+function handleResize() {
+ console.log('Window resized');
+}
+
+window.addEventListener('resize', handleResize);
+
+```
+
+==With throttling, we can limit how often the== `==handleResize==` ==function is called:==
+
+```actionscript
+// Throttling function
+function throttle(func, delay) {
+ let lastCall = 0;
+ return function(...args) {
+ const now = new Date().getTime();
+ if (now - lastCall < delay) {
+ return;
+ }
+ lastCall = now;
+ func(...args);
+ };
+}
+
+// Throttled event handler
+const throttledHandleResize = throttle(handleResize, 200);
+
+window.addEventListener('resize', throttledHandleResize)
+
+```
+
+In this example, the `throttle` function wraps `handleResize` and ensures it's not called more often than every 200 milliseconds. If the `resize` event fires more frequently than that, the `handleResize` function will only be executed once every 200 milliseconds, reducing the potential for performance issues caused by rapid, repeated function calls
+
+==Debouncing, on the other hand, is also used to limit the number of times a function or an event handler is invoked. It ensures that the function is called only after a certain period of inactivity. Debouncing allows you to postpone the function call until the user has finished typing or a specific time has elapsed since the last event.==
+
+For example, imagine you have a search input field and want to trigger a search API request only when the user has finished typing for a certain duration, like `300ms`.
+
+With debouncing, the search function will only be invoked after the user stops typing for` 300ms`. If the user continues typing within that interval, the function call will be delayed until the pause occurs. Without debouncing, the function will be called for every keystroke, potentially leading to excessive function calls and unnecessary computation. let's demonstrate with a code example:
+
+```javascript
+import React, { useState, useEffect } from 'react';
+
+const SearchComponent = () => {
+ const [searchTerm, setSearchTerm] = useState('');
+
+ // Function to simulate a search API request
+ const searchAPI = (query) => {
+ console.log(`Searching for: ${query}`);
+ // In a real application, you would make an API request here
+ };
+
+ // Debounce function to delay the searchAPI call
+ const debounce = (func, delay) => {
+ let timeoutId;
+ return function (...args) {
+ clearTimeout(timeoutId);
+ timeoutId = setTimeout(() => {
+ func(...args);
+ }, delay);
+ };
+ };
+
+ // Debounced search function
+ const debouncedSearch = debounce(searchAPI, 300);
+
+ // useEffect to watch for changes in searchTerm and trigger debouncedSearch
+ useEffect(() => {
+ debouncedSearch(searchTerm);
+ }, [searchTerm, debouncedSearch]);
+
+ // Event handler for the search input
+ const handleSearchChange = (event) => {
+ setSearchTerm(event.target.value);
+ };
+
+ return (
+ <div>
+ <label htmlFor="search">Search:</label>
+ <input
+ type="text"
+ id="search"
+ value={searchTerm}
+ onChange={handleSearchChange}
+ placeholder="Type to search..."
+ />
+ </div>
+ );
+};
+
+export default SearchComponent;
+
+```
+
+With this setup, the `searchAPI` function will only be invoked after the user stops typing for 300ms, preventing excessive API requests and improving the overall performance of the search functionality.
+
+### Code Splitting
+
+Code splitting in React is a technique used to split a large JavaScript bundle into smaller, manageable chunks. It helps improve performance by loading only the necessary code for a specific part of an application rather than loading the entire bundle upfront.
+
+When you develop a new React application, all your JavaScript code is typically bundled together into a single file. This file contains all the components, libraries, and other code required for your application to function. But as your application grows, the bundle size can become quite large, resulting in slow initial load times for your users.
+
+Code splitting ==allows you to divide a single bundle into multiple chunks, which can be loaded selectively based on the current needs of your application. Instead of downloading the entire bundle upfront,== only the necessary code is fetched and executed when a user visits a particular page or triggers a specific action.
+
+Below is a basic example of code splitting:
+
+```javascript
+// AsyncComponent.js
+import React, { lazy, Suspense } from 'react';
+
+const DynamicComponent = lazy(() => import('./DynamicComponent'));
+
+const AsyncComponent = () => (
+ <Suspense fallback={<div>Loading...</div>}>
+ <DynamicComponent />
+ </Suspense>
+);
+
+export default AsyncComponent;
+
+
+// DynamicComponent.js
+import React from 'react';
+
+const DynamicComponent = () => (
+ <div>
+ <p>This is a dynamically loaded component!</p>
+ </div>
+);
+
+export default DynamicComponent;
+
+```
+
+==In this example,== `==AsyncComponent==` ==is a component that uses== `==lazy==` ==and== `==Suspense==` ==to perform code splitting. The== `==DynamicComponent==` ==is dynamically imported using the import() syntax.==
+
+When `AsyncComponent` is rendered, React will load `DynamicComponent` only when it is needed, reducing the initial bundle size and improving the application's performance. The fallback prop in Suspense specifies what to render while waiting for the dynamic import to resolve, providing a better user experience during the loading process.
+
+### React Fragments
+
+React Fragments are a feature introduced in [React 16.2](https://legacy.reactjs.org/blog/2017/11/28/react-v16.2.0-fragment-support.html) that allows you to group multiple elements together without adding an additional DOM node. This is particularly useful when you need to return multiple elements from a component's render method, but you don't want to introduce unnecessary DOM elements that could affect the layout or styles of your application.
+
+Imagine you are arranging books on a bookshelf. Each book represents a React component, and the bookshelf represents the DOM.
+
+Normally, if you have multiple books, you might want to group them together under a category label (analogous to a DOM element like a `<div>`). But sometimes you just want to place the books side by side without a label because the label itself doesn't hold any value and only takes up physical space.
+
+React Fragments are like the option to arrange the books without a label, saving space and making the arrangement cleaner.
+
+Here's an example of how to utilize React fragments:
+
+```actionscript
+import React from 'react';
+
+function BookShelf() {
+ return (
+ <>
+ <Book title="React for Beginners" />
+ <Book title="Mastering Redux" />
+ <Book title="JavaScript Essentials" />
+ </>
+ );
+}
+
+function Book({ title }) {
+ return <li>{title}</li>;
+}
+
+export default BookShelf;
+
+```
+
+In this example, the `BookShelf` component returns a list of `Book` components without wrapping them in a `<div>` or other unnecessary DOM element. Instead, it uses the `<>` shorthand syntax for React Fragments.
+
+This results in a cleaner DOM structure, which can improve the performance of your React application by reducing the number of elements that the browser has to process and render. Using fragments can also reduce unnecessary markup and contribute to a cleaner and more efficient render tree.
+
+### Web Workers
+
+JavaScript operates as a single-threaded application designed to handle synchronous tasks.
+
+When a web page is being rendered, JavaScript executes multiple tasks, including manipulating DOM elements, managing UI interactions, handling API response data, and enabling CSS animations, all within a single thread. Despite its efficiency in managing these tasks, executing them in a single thread can sometimes lead to performance bottlenecks.
+
+==Web Workers serve as a solution to alleviate the burden on the main thread. They allow the execution of scripts in the background on a separate thread, distinct from the main JavaScript thread.==
+
+This separation enables the handling of computationally intensive tasks, execution of long-running operations, or management of tasks that might otherwise block the main thread. By doing so, Web Workers contribute to maintaining user interface responsiveness and overall application performance.
+
+To use web worker in React, create a new JavaScript file that will contain the code for the worker thread:
+
+```php
+// worker.js
+self.onmessage = function(event) {
+ var input = event.data;
+ var result = performHeavyComputation(input);
+ postMessage(result);
+};
+
+function performHeavyComputation(input) {
+ // Insert your heavy computation logic here
+ return input * 2; // Just a placeholder operation
+}
+
+```
+
+In your React component, instantiate the Web Worker and establish a communication channel with it:
+
+```javascript
+import React, { useEffect, useRef } from 'react';
+
+function MyComponent() {
+ const workerRef = useRef();
+
+ useEffect(() => {
+ // Initialize the worker
+ workerRef.current = new Worker('path-to-your-worker-file.js');
+
+ // Handle incoming messages from the worker
+ workerRef.current.onmessage = (event) => {
+ console.log('Message received from worker:', event.data);
+ };
+
+ // Cleanup the worker when the component unmounts
+ return () => {
+ workerRef.current.terminate();
+ };
+ }, []);
+
+ // Function to send a message to the worker
+ const sendMessageToWorker = (message) => {
+ workerRef.current.postMessage(message);
+ };
+
+ // Rest of your component
+ return (
+ // ...
+ );
+}
+
+
+```
+
+In this example, a Web Worker is initialized in the `useEffect` hook and stored in a ref for future use. Messages from the worker are handled with an `onmessage` event listener, and the worker is terminated when the component is unmounted to clean up resources. The `sendMessageToWorker` function demonstrates how to communicate with the worker using `postMessage`
+
+### UseTransition Hook
+
+==The== `==useTransition==` ==hook in React plays a pivotal role in improving the performance of applications by allowing the marking of state updates as non-blocking transitions. This capability enables React to defer rendering for these updates, preventing UI blocking and enhancing overall responsiveness.==
+
+When utilizing `useTransition,` state updates within the `startTransition` function are treated as low-priority transitions, susceptible to interruption by higher-priority state updates. So if a high-priority update occurs during a transition, React may prioritize finishing the high-priority update, interrupting the ongoing transition.
+
+This non-blocking transition mechanism is valuable in preventing UI blocking during intensive operations such as data fetching or large-scale updates. By deferring the rendering of components associated with transition updates, React ensures that the user interface remains responsive even in scenarios where the UI might otherwise become unresponsive.
+
+This example demonstrates the use of `useTransition` in a React component:
+
+```javascript
+import React, { useState, useTransition } from 'react';
+
+function MyComponent() {
+ const [state, setState] = useState(initialState);
+ const [isPending, startTransition] = useTransition();
+
+ function handleClick() {
+ startTransition(() => {
+ setState(newState); // This state update is marked as a transition
+ });
+ }
+
+ return (
+ <>
+ {/* Your component JSX */}
+ <button onClick={handleClick}>Update State</button>
+ {isPending && <div>Loading...</div>}
+ </>
+ );
+}
+
+```
+
+This example showcases how React avoids blocking the UI during transitions triggered by user actions, allowing for interruption if higher-priority state updates are detected.
+
+Note that `useTransition` is part of the Concurrent Mode API, introduced in React 18 and later versions. As a powerful tool for altering the default behavior of state updates, make sure you use it with care, considering the specific implications of deferring rendering within the context of your application.
+
+## Conclusion
+
+Optimizing the performance of a React application involves a combination of strategies, from the fundamental understanding of React's diffing algorithm to leveraging built-in features and third-party tools.
+
+By applying these techniques judiciously, you can create applications that are not only visually appealing but also performant, leading to a better overall user experience.
+
+---
+
+---
+
+ 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/)
\ No newline at end of file
diff --git a/Omnivore/2024-02-18 - Git Tips 1- Oldies but Goodies.md b/Omnivore/2024-02-18 - Git Tips 1- Oldies but Goodies.md
new file mode 100644
index 0000000..089b346
--- /dev/null
+++ b/Omnivore/2024-02-18 - Git Tips 1- Oldies but Goodies.md
@@ -0,0 +1,192 @@
+---
+id: a6c66f79-fd38-4d76-b05a-9c5d7dc9119f
+title: |
+ Git Tips 1: Oldies but Goodies
+status: ARCHIVED
+tags:
+ - read-later
+ - dotfiles
+ - git
+date_added: 2024-02-18 11:02:02
+url_omnivore: |
+ https://omnivore.app/me/git-tips-1-oldies-but-goodies-18dbc861eae
+url_original: |
+ https://blog.gitbutler.com/git-tips-1-theres-a-git-config-for-that/
+---
+
+# Git Tips 1: Oldies but Goodies
+
+## Highlights
+
+But there is also `--system` (which probably none of you have used) which writes it to a system-wide config file and `--local` (the default) that writes it to `.git/config` in whatever project you're currently in.
+
+[source](https://omnivore.app/me/git-tips-1-oldies-but-goodies-18dbc861eae#4994949d-07aa-4baf-8b39-7b003dcc4487)
+
+---
+
+However, there is a _secret fourth_ place that Git can look. If you add to your global config something that looks like this:
+
+```cs
+[includeIf "gitdir:~/projects/oss"]
+ path = ~/.gitconfig-oss
+```
+
+Then Git will look in the `~/.gitconfig-oss` files for values _only if_ the project you are currently working in matches `~/projects/oss` . So, you could have a "work" directory and have work-specific values there (company email address, gpg signing key, etc) and an "oss" directory with values for your open source projects, etc.
+
+[source](https://omnivore.app/me/git-tips-1-oldies-but-goodies-18dbc861eae#400065ab-ea9d-4b03-80c8-aec98b643a27)
+
+---
+
+One thing that is really not great about using blame in GUI tools is that the CLI has much more powerful tooling for finding something closer to the real story behind your code.
+
+[source](https://omnivore.app/me/git-tips-1-oldies-but-goodies-18dbc861eae#60d94f0c-f71c-4e30-83d7-ed9d4ac07265)
+
+---
+
+Finally, if you're rebasing or cherry-picking a lot and you've ever run into the same conflict more than once, you can turn on a feature where Git memorizes the conflict and the resolution to it. If it ever sees that same conflict again, it will _automatically_ re-solve it for you.
+
+You can easily turn it on with the config setting `rerere.enabled` and you can further ask it to automatically stage it for you with `rerere.autoUpdate`
+
+```routeros
+$ git config --global rerere.enabled true
+$ git config --global rerere.autoUpdate true
+```
+
+[source](https://omnivore.app/me/git-tips-1-oldies-but-goodies-18dbc861eae#7e50290a-231d-4e52-9518-2e8ad22503cf)
+
+---
+
+## Original
+
+
+
+ Do you know some of the cool stuff in Git that's been around for a while? All the magical -L and -C options in the Git world? Let's find out!
+
+For the first in our [short series of Git tips](https://blog.gitbutler.com/git-tips-and-tricks/), I wanted to start with stuff that's been around for a while, but it still seems like a lot of people don't know about or don't know how to use.
+
+None of this is new, but I find them useful and they're arguably a little obscure. I'm just going to cover:
+
+* [Conditional Configs](#conditional-configs)
+* [Git Blame and Log with Line Ranges](#git-blame-and-log-with-line-ranges)
+* [Git Blame with Following](https://blog.gitbutler.com/git-tips-1-theres-a-git-config-for-that/git-blame-with-following)
+* [Word Diff](#word-diff)
+* [Resolution Reuse](#reuse-recorded-resolution)
+
+Let's dig in!
+
+## Conditional Configs
+
+Many of you probably know this, but Git has a cool little key/value store called `git config` which will check in three places for values to use when it's running various commands.
+
+Every Git user will have [probably been told](https://git-scm.com/book/en/v2/Getting-Started-First-Time-Git-Setup?ref=blog.gitbutler.com) to run something like this when they first set up:
+
+```routeros
+$ git config --global user.name "John Doe"
+$ git config --global user.email johndoe@example.com
+```
+
+That adds the `user.name` value to your `~.gitconfig` file. ==But there is also== `==--system==` ==(which probably none of you have used) which writes it to a system-wide config file and== `==--local==` ==(the default) that writes it to== `==.git/====config==` ==in whatever project you're currently in.==
+
+When Git looks for a value, it will look in that order - local, global, system - for a definition.
+
+==However, there is a== _==secret fourth==_ ==place that Git can look. If you add to your global config something that looks like this:==
+
+```cs
+[includeIf "gitdir:~/projects/oss"]
+ path = ~/.gitconfig-oss
+```
+
+==Then Git will look in the== `==~/.gitconfig-oss==` ==files for values== _==only if==_ ==the project you are currently working in matches== `==~====/projects/====oss==` ==. So, you could have a "work" directory and have work-specific values there (company email address, gpg signing key, etc) and an "oss" directory with values for your open source projects, etc.==
+
+But `gitdir` is not the only filter you can use. You can also put _branch name_ specific values as a include filter with `onbranch` or you can only include config files if the project you are currently in has a remote matching a specific URL with `hasconfig:remote.*.url` . So like if you have GitHub org specific keys or something.
+
+Check out [the docs](https://git-scm.com/docs/git-config?ref=blog.gitbutler.com#%5Fincludes) for more.
+
+## Git Blame and Log with Line Ranges
+
+There are a couple of interesting options that you can use with `git blame` that most people don't know about and nearly none of the existing GUIs implement.
+
+One is the line range option, `-L`. A lot of times, if you're running blame on the command line, you just page the whole file and find the part you're looking for. However, if you want to just display a subsection of your file, you can give it a line range, like `git blame -L 28,43 path/to/file`
+
+
+
+git blame -L
+
+You can also use a semi-strange `:` syntax to give Git a pattern to find the beginning of a block and only blame that block. So in this same situation, I can get the same result by running `git blame -L :'class LocalFile' gitbutler-ui/src/lib/vbranches/types.ts`
+
+Typically you can use a function name or something for that string.
+
+The _other_ thing you can do to see similar information in a different way, is to run `git log` with similar options. This will give you all the commits filtered to those that last touched this region of the file. So for example, `git log -L28,43:gitbutler-ui/src/lib/vbranches/types.ts` will give you something like this:
+
+
+
+So instead of being ordered by lines, it sort of gathers all the commits that are shown in the blame and then shows you those commits with code that modified that block in each commit. Basically the same data, but in a different format, more like a story of how that code was put together.
+
+## Git Blame with Following
+
+==One thing that is really not great about using blame in GUI tools is that the CLI has much more powerful tooling for finding something closer to the real story behind your code.==
+
+There are many scenarios where this is really valuable. The first is ignoring whitespace changes. Some of the GUIs do that, but not all of them. So if you go and implement a `prettierrc` file, BLAM, now you're the owner of tons of lines of code. The `git blame -w` option will ignore these types of whitespace changes.
+
+The other great option is `-C` which will look for code movement between files in a commit. So if you refactor a function from one file to another, the normal `git blame` will simply show you as the author in the new file, but the `-C` option will follow that movement and show the last person to actually change those lines of code. Either of these scenarios could be what you're looking for, but I would argue that more often it's the latter.
+
+If you want Git to try even harder (look for movement in multiple commits or in _all_ of your commits) you can pass `-C` up to three times.
+
+ Also, your GUI _does not_ do this (most likely, I can't speak for all of them).
+
+So, let's look at the VS Code GitLens blame output of the previous example:
+
+
+
+git blame in GitLens VS Code plugin
+
+Ok, looks good. Kiril wrote most of this code it appears. Let's now look at the same block with `git blame -w -C -C -C`
+
+
+
+git blame -C -C -C
+
+Now we can see that Git has followed this hunk of code from file to file over the course of multiple renames.
+
+Also, Kiril only really owns a few lines of code, Mattias actually wrote big hunks of it. If we want to know about those lines, it's much better to ask Mattias rather than Kiril, as our GUI blame would suggest.
+
+## Word Diff
+
+This is incredibly minor, and some GUIs have nice versions of this (I find GitHub's better than what I'm about to show you, since it subtly does both) but if you _ARE_ running `git diff` on the command line and there is a line change where something small changed within it, you can change Git's default format to word-based rather than line based with the `--word-diff` option.
+
+
+
+normal, line-based git diff
+
+
+
+super cool git diff --word-diff
+
+## Reuse Recorded Resolution
+
+==Finally, if you're rebasing or cherry-picking a lot and you've ever run into the same conflict more than once, you can turn on a feature where Git memorizes the conflict and the resolution to it. If it ever sees that same conflict again, it will== _==automatically==_ ==re-solve it for you.==
+
+==You can easily turn it on with the config setting== `==rerere====.enabled==` ==and you can further ask it to automatically stage it for you with== `==rerere.====auto====Update==`
+
+```routeros
+$ git config --global rerere.enabled true
+$ git config --global rerere.autoUpdate true
+```
+
+
+
+a conflict... always remembers
+
+Then, the next time you get a merge conflict that it's seen before, magic!
+
+
+
+automatically fix it the next time
+
+## Up Next
+
+Again, all of this has been in Git for a while, but if you don't know... now you know.
+
+Next up is [New Stuff in Git](https://blog.gitbutler.com/git-tips-2-new-stuff-in-git/).
+
+### Subscribe to new posts.
\ No newline at end of file
diff --git a/Omnivore/2024-02-18 - Git Tips 2- New Stuff in Git.md b/Omnivore/2024-02-18 - Git Tips 2- New Stuff in Git.md
new file mode 100644
index 0000000..bb96805
--- /dev/null
+++ b/Omnivore/2024-02-18 - Git Tips 2- New Stuff in Git.md
@@ -0,0 +1,208 @@
+---
+id: 3811e8c9-49ed-47bc-8302-d7dc0529d828
+title: |
+ Git Tips 2: New Stuff in Git
+status: ARCHIVED
+tags:
+ - read-later
+ - dotfiles
+ - git
+date_added: 2024-02-18 11:02:19
+url_omnivore: |
+ https://omnivore.app/me/git-tips-2-new-stuff-in-git-18dbc865f77
+url_original: |
+ https://blog.gitbutler.com/git-tips-2-new-stuff-in-git/
+---
+
+# Git Tips 2: New Stuff in Git
+
+## Highlights
+
+So, Git has created a new force pushing option called `--force-with-lease` that will essentially check that what you last pushed is still what's on the server before it will force the new branch update.
+
+[source](https://omnivore.app/me/git-tips-2-new-stuff-in-git-18dbc865f77#303433c7-6c8d-45df-b8ae-729aa598255b)
+
+---
+
+It's pretty easy to do. Just set `gpg.format` to `ssh` and tell it where your signing key is:
+
+```routeros
+$ git config gpg.format ssh
+$ git config user.signingKey ~/.ssh/id_rsa.pub
+```
+
+Now if you run `git commit -S` it will try to sign your commit with this key. If it succeeds and you upload that public key to GitHub here (under "Signing Keys"), then you'll get pretty "verified" badges on your commits:
+
+[source](https://omnivore.app/me/git-tips-2-new-stuff-in-git-18dbc865f77#6870b9f8-0e0c-4a26-8d4e-b0dd630f7260)
+
+---
+
+provides a way to add cronjobs that run daily, hourly and weekly maintenance tasks on your Git repositories.
+
+You can turn it on for your Git repository by simply running:
+
+```crmsh
+$ git maintenance start
+```
+
+[source](https://omnivore.app/me/git-tips-2-new-stuff-in-git-18dbc865f77#0a2d2271-21f5-46e5-8f83-8fd08a82e25c)
+
+---
+
+This means that every hour it will rebuild your commit graph and do a prefetch (we will cover these concepts in the next post), and once per day it will clean up loose objects and put them in pack-files and also repack the object directory using the `multi-pack-index` feature (read more about that in an incredible blog post from GitHub's Taylor Blau [here](https://github.blog/2021-04-29-scaling-monorepo-maintenance/?ref=blog.gitbutler.com#multi-pack-indexes)).
+
+Basically it will just make lots of things faster in the background all the time automatically.
+
+[source](https://omnivore.app/me/git-tips-2-new-stuff-in-git-18dbc865f77#cdd9aacf-451b-4437-9976-61dcbc1322aa)
+
+---
+
+## Original
+
+
+
+ There are a bunch of new tricks that Git can do that were added in the last few years. How up to date are you?
+
+Next up in our [3 part series](https://blog.gitbutler.com/git-tips-and-tricks/) on "Stuff you may not know about Git", we have **New Stuff**!
+
+Here I'm going to cover 5 relatively new things in Git that you may not have heard about, because _why would you_?
+
+We'll cover:
+
+* [Git Branch Stuff](#some-git-branch-stuff)
+* [Safe Force Pushing](#safe-force-pushing)
+* [SSH Commit Signing](#ssh-commit-signing)
+* [Push Signing](#push-signing)
+* [Git Maintenance](#git-maintenance)
+
+Let's dig in!
+
+## Some Git Branch Stuff
+
+This is pretty minor, but one thing that's always bugged me about Git is that I run `git branch` a lot to view what branches I have, but they're in the dumbest possible order (alphabetic) and there are a million of them after a while.
+
+At some point I started naming my branches in a way to partially cope with this. Every branch would be something like `sc-0831-my-thing` meaning that the branch topic was "my thing", it was created on August 31st and the `sc` are my initials so I can group them by whose branch. It's a lot of stupid metadata to try to cram into a branch name just because of how it's listed.
+
+However, now we can ask Git to do two things that help with this. We can ask it to sort by `objectsize`, `authordate`, `committerdate`, `creatordate`, or `taggerdate` with the `--sort` option and we can set it as a default with the `branch.sort` config setting.
+
+So for example, if I want to sort by last commit date descending, I can run:
+
+```routeros
+$ git config --global branch.sort -committerdate
+```
+
+And now the default will show the branch that I last committed to at the top.
+
+💡
+
+Important note: the `-committerdate` has a leading `-` but __not_ a double dash. It's just a negative. I've seen people mess this up and then things break.
+
+However, now if I have a bunch of branches, that will scroll off the screen. Sad. But now Git also has a way to take a list of branches and try to split it into columns to make better use of the screen real estate. You can do this either with the new `--column` option, or with the `column.ui` setting.
+
+Check it out:
+
+
+
+Nice sorted columns for my branch output
+
+As another sort of funny thing, in order to help with this, Git implemented it's own list to column terminal command that is sort of completely independent of anything else in Git and is it's own command called `git column`.
+
+
+
+Just in case there is anything else you need to convert into columns that isn't Git related.
+
+## Safe Force Pushing
+
+The next interesting thing that Git has added somewhat recently is a way to do much safer forced pushes.
+
+Generally most of us don't love doing forced pushes, because there is always a chance that you're overwriting someone else's commits. Let's take a scenario:
+
+* You commit and push something to GitHub
+* Someone else pulls it down, commits something and pushes it back up.
+* You amend a commit, rewriting the history, and force push it, not knowing that anyone had based something off your work.
+* This effectively removes what the other person had done.
+
+What you really want to do is check to see if anyone else had pushed and only force push if the answer is no. However, there is always a bit of a race condition here because even if you check first, in the second it takes you to then push, something else could have landed from elsewhere in the meantime.
+
+==So, Git has created a new force pushing option called== `==--====force====-====with====-lease==` ==that will essentially check that what you last pushed is still what's on the server before it will force the new branch update.==
+
+
+
+A failed --force-with-lease push
+
+If someone has updated the remote ref (pushed in the meantime), then push now fails with a "stale info" error.
+
+If you're amending and rebasing stuff a lot, it may be worth setting up a nice little alias for this, because it's almost _always_ better than running `--force`
+
+```routeros
+$ git config --global alias.fpush push --force-with-lease
+```
+
+May the force be with you.
+
+## Commit Signing with SSH
+
+We [wrote about this](https://blog.gitbutler.com/signing-commits-in-git-explained/) a few months ago in mind-numbing detail, because the GitButler client does this automatically for you with the flip of a config setting, but if you want to do this on the command line, read on.
+
+Git has supported signing your commits with GPG for a while, but GPG is often pretty difficult to get working properly and completely understand if you've never used it before. Recently, OpenSSH provided a new way to sign data using your existing SSH key and Git has integrated this as an option to use instead of GPG to do the same thing. Also, importantly, GitHub and GitLab support verifying these signatures if you upload your public signing key to your user account there.
+
+==It's pretty easy to do. Just set== `==gpg====.format==` ==to== `==ssh==` ==and tell it where your signing key is:==
+
+```routeros
+$ git config gpg.format ssh
+$ git config user.signingKey ~/.ssh/id_rsa.pub
+```
+
+==Now if you run== `==git commit -S==` ==it will try to sign your commit with this key. If it succeeds and you upload that public key to GitHub here (under "Signing Keys"), then you'll get pretty "verified" badges on your commits:==
+
+
+
+Stay vigilant.
+
+## Push Signing
+
+I won't go into a ton of detail here because this isn't really widely used, but it might be interesting to some. Git can also now sign _pushes_, not just commits.
+
+Since none of the major Git hosting solutions (GitHub, GitLab, Bitbucket) support this, it's only really possible to do this if you run your own server. However, if you do, you can run `git push --signed` in order to sign the ref update on the server and have the server save a transparency log with verifiable signatures somewhere.
+
+If you're interested in this, there is a very nice [writeup](https://people.kernel.org/monsieuricon/signed-git-pushes?ref=blog.gitbutler.com) by over at kernel.org.
+
+Push it real good.
+
+## Git Maintenance
+
+The final fun new thing I'll cover is `git maintenance`.
+
+The maintenance command was introduced in Git 2.30 I believe. It essentially ==provides a way to add cronjobs that run daily, hourly and weekly maintenance tasks on your Git repositories.==
+
+==You can turn it on for your Git repository by simply running:==
+
+```crmsh
+$ git maintenance start
+```
+
+This will modify your `.git/config` file to add a `maintenance.strategy` value set to `incremental` which is a shorthand for the following values:
+
+* `gc`: disabled.
+* `commit-graph`: hourly.
+* `prefetch`: hourly.
+* `loose-objects`: daily.
+* `incremental-repack`: daily.
+
+==This means that every hour it will rebuild your commit graph and do a prefetch (we will cover these concepts in the next post), and once per day it will clean up loose objects and put them in pack-files and also repack the object directory using the== `==multi-====pack====-====index==` ==feature (read more about that in an incredible blog post from GitHub's Taylor Blau== ==[here](https://github.blog/2021-04-29-scaling-monorepo-maintenance/?ref=blog.gitbutler.com#multi-pack-indexes)====).==
+
+==Basically it will just make lots of things faster in the background all the time automatically.==
+
+Git maintenance will schedule these cron jobs differently depending on the operating system. On Mac it will add some LaunchAgents like this:
+
+
+
+If you're curious what these plist files look like, it's something like this:
+
+
+
+You can read more about git maintenance and it's various options [here](https://git-scm.com/docs/git-maintenance?ref=blog.gitbutler.com).
+
+OK, now onto our next post where we cover those commit graph and prefetching topics. Let's get into [Really Big Repositories](https://blog.gitbutler.com/git-tips-3-really-large-repositories/).
+
+### Subscribe to new posts.
\ No newline at end of file
diff --git a/Omnivore/2024-02-18 - Git Tips 3- Really Large Repositories.md b/Omnivore/2024-02-18 - Git Tips 3- Really Large Repositories.md
new file mode 100644
index 0000000..5616fdd
--- /dev/null
+++ b/Omnivore/2024-02-18 - Git Tips 3- Really Large Repositories.md
@@ -0,0 +1,300 @@
+---
+id: 0f04cdaa-c871-4ba1-a882-7aecf65a2505
+title: |
+ Git Tips 3: Really Large Repositories
+status: ARCHIVED
+tags:
+ - read-later
+ - dotfiles
+ - git
+date_added: 2024-02-18 11:02:27
+url_omnivore: |
+ https://omnivore.app/me/git-tips-3-really-large-repositories-18dbc867c96
+url_original: |
+ https://blog.gitbutler.com/git-tips-3-really-large-repositories/
+---
+
+# Git Tips 3: Really Large Repositories
+
+## Highlights
+
+Git has had shallow clones. You could almost always run something like `git clone --depth=1` to get only the last commit and the objects it needs and then `git fetch --unshallow` to get the rest of the history later if needed. But it did break lots of things. You can't `blame`, you can't `log`, etc.
+
+[source](https://omnivore.app/me/git-tips-3-really-large-repositories-18dbc867c96#d319f349-d2ea-4aed-9558-d67e4b708d74)
+
+---
+
+If you want to do a blobless clone, you just pass `--filter=blob:none`
+
+[source](https://omnivore.app/me/git-tips-3-really-large-repositories-18dbc867c96#d296df77-d1f6-4a1b-99c6-9716824f2ee2)
+
+---
+
+If each of those subdirectories was huge, this could be annoying to manage. Instead, we can use sparse checkouts to filter the checkouts to just specified directories.
+
+To do this, we run `git sparse-checkout set [dir1] [dir2] ...`
+
+[source](https://omnivore.app/me/git-tips-3-really-large-repositories-18dbc867c96#d92785cc-9dde-46f8-9764-af2195722289)
+
+---
+
+[Scalar](https://git-scm.com/docs/scalar?ref=blog.gitbutler.com) is mostly just used to clone with the correct defaults and config settings (blobless clone, no checkout by default, setting up maintenance properly, etc).
+
+[source](https://omnivore.app/me/git-tips-3-really-large-repositories-18dbc867c96#96d0ab7b-1bf9-4b10-a08a-3d13c01bf56c)
+
+---
+
+## Original
+
+
+
+ Did you know that Git can handle enormous monorepos like Windows? Let's take a look at how.
+
+In our third and final section of our [Git Tips series](https://blog.gitbutler.com/git-tips-and-tricks/), we're going to talk about how well Git now handles **very large** repositories and monorepos.
+
+Do you want to use vanilla Git today to manage a 300GB repo of 3.5M files receiving a push every 20 seconds from 4000 developers without problems? **Read on!**
+
+Here is our blog agenda. Our blogenda.
+
+* [Prefetching](#prefetching)
+* [Commit Graph](#commit-graph)
+* [Filesystem Monitor](#filesystem-monitor)
+* [Partial Cloning](#partial-cloning)
+* [Sparse Checkouts](#sparse-checkouts)
+* [Scalar](#scalar)
+
+## First, Let's Thank Windows
+
+Before we get started though, the first thing we have to do is thank Microsoft for nearly all of this.
+
+In 2017, Microsoft successfully moved the Windows codebase to Git. Brian Harry wrote a really great blog post about it called [The Largest Git Repo on the Planet](https://devblogs.microsoft.com/bharry/the-largest-git-repo-on-the-planet/?ref=blog.gitbutler.com) that you should read if you're interested, but the size and scope of this repository is astounding.
+
+* **3.5M** files
+ * for reference, the Linux kernel is about 80k files, or 2% of that
+* **300GB** repository (vs \~4.5G Linux kernel)
+* **4,000** active developers
+* **8,421** pushes per day (on average)
+* **4,352** active topic branches
+
+In order to get that to work in any possible way, Microsoft had a lot of work to do. With vanilla Git at that time, a lot of commands (ie, `git status`) would take hours if they ever finished at all. They needed to make every command close to as fast as Source Depot was.
+
+The first solution to this problem was a new project called [VFS for Git](https://github.com/microsoft/VFSForGit?ref=blog.gitbutler.com) which was a virtual filesystem layer that did virtual checkouts and then requested files from a central server on demand.
+
+Eventually they moved more and more of the solutions they developed to the [Scalar](https://github.com/microsoft/scalar?ref=blog.gitbutler.com) project, which got rid of the virtualization layer, and would instead request file contents on checkout rather than on demand.
+
+Then they moved everything, piece by piece, into the [Microsoft Git](https://github.com/microsoft/git?ref=blog.gitbutler.com) fork and then finally every part of _that_ was moved into [core Git](https://git-scm.com/docs/scalar?ref=blog.gitbutler.com).
+
+So, as promised, if you want to use Git out of the box today to manage a 300GB repo of 3.5M files receiving a push every 20 seconds from 4000 developers, you can _100%_ do so.
+
+Let's get into everything they added for us.
+
+## Prefetching
+
+So, in the last blog post I talked about how running `git maintenance` on a repository will run prefetching and maintain your commit graph every hour. Let's cover the first of those. What is "prefetching"?
+
+One of the things that the Windows devs found annoying was that fetches would often be slow because there was _so much_ activity going on all the time. Whenever they would fetch, they have to get _all_ the data since whatever the last time they manually fetched.
+
+So in the cronjob, they added something called "prefetching", which will essentially run a fetch command every hour automatically for you.
+
+However, it does not update your remote references like it normally would, instead it populates a special `refs/prefetch` area of your references.
+
+
+
+These references aren't shown normally, even if you run something like `git log --all`, they are quite hidden from you. However, they are used in the remote server negotiation, which means that if you have this turned on, whenever you go to fetch, your computer is never more than 1 hour of pushes behind, data-wise.
+
+Basically it makes manual fetches fast.
+
+
+
+Joke stolen from Martin Woodward :)
+
+## Commit Graph
+
+The other thing that `git maintenance` does every hour is update your commit graph data. What does that mean exactly?
+
+Well, essentially, it makes walking your commit history faster.
+
+Instead of opening up one commit object at a time to see what it's parent is, then opening up that object to see what it's parent is, etc, the commit graph is basically an index of all that information that can be quickly read in one go. This makes things like `git log --graph` or `git branch --contains` much, much faster. For most repositories this probably isn't a horrible problem, but when you start getting into millions of commits, it makes a huge difference.
+
+Here's a benchmark of some log related subcommands run on the Linux kernel codebase with and without the commit graph data (from the [GitHub blog](https://github.blog/2022-08-30-gits-database-internals-ii-commit-history-queries/?ref=blog.gitbutler.com#the-commit-graph))
+
+| **Command** | **Withoutcommit-graph** | **Withcommit-graph** |
+| ------------------------- | ----------------------- | -------------------- |
+| git rev-list v5.19 | 6.94s | 0.98s |
+| git rev-list v5.0..v5.19 | 2.51s | 0.30s |
+| git merge-base v5.0 v5.19 | 2.59s | 0.24s |
+
+Here is a quick test that I did on the same Linux repo running `git log --graph --oneline` before and after writing a commit graph file.
+
+
+
+Again, if you have your `maintenance` cron jobs running, this is just magically done for you constantly, you don't really have to do anything explicit.
+
+## Filesystem Monitor
+
+One of the things that VFS for Git needed was a filesystem monitor so that it could detect when virtual file contents were being requested and fetch them from a central server if needed.
+
+This monitor was eventually utilized to speed up the `git status` command by updating the index based on filesystem modification events rather than running `stat` on every file, every time when you run it.
+
+While the former became unnecessary when the virtualization layer was abandoned, the latter was integrated into Git core. If you want much, much faster `git status` runs for very large working directories, the new Git filesystem monitor is a lifesaver.
+
+Basically you just set these config settings:
+
+```routeros
+$ git config core.fsmonitor true
+
+```
+
+What this will do is add a setting that the `git status` command will see when it runs, indicating that it should be using the [fsmonitor-daemon](https://git-scm.com/docs/git-fsmonitor--daemon?ref=blog.gitbutler.com). If this daemon is not running, it will start it.
+
+
+
+fsmonitor on Chromium makes status 20x faster
+
+So, the first time you run `status` after setting the config setting, it won't be much faster. But every time after that it will be massively faster.
+
+Again, there's nothing really to explicitly do after setting the value, things just get faster.
+
+## Partial Cloning
+
+Another big issue with large repositories is clone size. As you probably know, by default Git will fetch everything. You don't even need to have a 300GB repository for this to be a problem. [Linux](https://github.com/torvalds/linux?ref=blog.gitbutler.com) is over 4GB, [Chromium](https://github.com/chromium/chromium?ref=blog.gitbutler.com) is over 20GB. A full Chromium clone can easily take an hour, even over a pretty fast connection.
+
+Now, for a long time ==Git has had shallow clones. You could almost always run something like== `==git== ==clone== ==--depth=========1==` ==to get only the last commit and the objects it needs and then== `==git== ==fetch== ==--unshallow==` ==to get the rest of the history later if needed. But it did break lots of things. You can't== `==blame==`==, you can't== `==log==`==, etc.==
+
+However, now Git has both blobless and treeless clones. So you do get the whole history (all of the commits), but you don't locally have the actual content. Let's ignore the treeless clones for now because it's not generally recommended, but the blobless clone is.
+
+
+
+A full clone of the Linux repository is 4.6G, or (for me) a 20 min process
+
+==If you want to do a blobless clone, you just pass== `==--filter=====blob:none==`
+
+This will change the process a little. It will download all the commits and trees, which in the case of cloning the Linux kernel reduces 4.6G to 1.4G, and it will then do a _second_ object fetch for just the blobs that it needs in order to populate the checkout.
+
+
+
+So you can see that instead of 20 minutes for the clone, it took me 4.5 minutes. You can also see that it did two fetches, one for the 1.4GBs of commit and tree data, and a second for the 243MB of files it needs for my local checkout.
+
+Now, there are downsides to this too. If you want to run a command that needs data that is not there, Git will have to go back to the server and request those objects. Luckily, it does this on-demand as it needs the objects, but it can make something like `blame` do a bunch of roundtrips.
+
+
+
+round and round we go
+
+In the case of Linux, my tests showed that a normal file blame might take 4 seconds now takes 45 seconds. But that's only the first time you need to do it.
+
+## Sparse Checkouts
+
+The last big thing to look at is not only useful for large repositories, but specifically for monorepos. That is, repositories that contain multiple projects in subdirectories.
+
+For example, at GitButler, our web services are in a monorepo, with each service we run on AWS in a subdirectory.
+
+```reasonml
+❯ tree -L 1
+.
+├── Gemfile
+├── Gemfile.lock
+├── README.md
+├── auth-proxy
+├── butler
+├── chain
+├── check.rb
+├── copilot
+└── git
+
+6 directories, 4 files
+```
+
+==If each of those subdirectories was huge, this could be annoying to manage. Instead, we can use sparse checkouts to filter the checkouts to just specified directories.==
+
+==To do this, we run== `==git== ==sparse-checkout== ==set [dir1] [dir2] ...==`
+
+```smali
+❯ git sparse-checkout set butler copilot
+❯ tree -L 1
+.
+├── Gemfile
+├── Gemfile.lock
+├── README.md
+├── butler
+├── check.rb
+└── copilot
+```
+
+So we still have the top level files, but only the two subdirectories that we specified. This is called "cone mode" and tends to be pretty fast. It also makes `status` and related commands faster because there are fewer files to care about. You can also however, set patterns rather than subdirectories, but it's more complicated.
+
+Here's a local test I did with the Chromium repository:
+
+```sql
+❯ time git status
+On branch main
+Your branch is up to date with 'origin/main'.
+
+nothing to commit, working tree clean
+
+real 0m5.931s
+
+❯ git sparse-checkout set build base
+
+❯ time git status
+On branch main
+Your branch is up to date with 'origin/main'.
+
+You are in a sparse checkout with 2% of tracked files present.
+
+nothing to commit, working tree clean
+
+real 0m0.386s
+```
+
+This is without the `fsmonitor` stuff. You can see that `status` went from 6 seconds to run down to 0.3 seconds because there just aren't as many files.
+
+If you're using large monorepos, this means you can do a blobless clone to have a much smaller local database (you can also run `clone --no-checkout` to skip the initial checkout), then do a `sparse-checkout` to filter to the directories you need and everything is massively faster.
+
+## Scalar
+
+Finally, Git now (since Oct 2022, Git 2.38) ships with an _alternative_ command line invocation that wraps some of this stuff.
+
+This command is called `scalar`. Just go ahead and type it:
+
+```fsharp
+❯ scalar
+usage: scalar [-C <directory>] [-c <key>=<value>] <command> [<options>]
+
+Commands:
+ clone
+ list
+ register
+ unregister
+ run
+ reconfigure
+ delete
+ help
+ version
+ diagnose
+```
+
+==[Scalar](https://git-scm.com/docs/scalar?ref=blog.gitbutler.com)== ==is mostly just used to clone with the correct defaults and config settings (blobless clone, no checkout by default, setting up maintenance properly, etc).==
+
+If you are managing large repositories, cloning with this negates the need to run `git maintenance start` and send the `--no-checkout` command and remember `--filter=tree:0` and whatnot.
+
+Now you're ready to scale! ...-ar.
+
+## Some More Reading
+
+If you want to read about all of this in great detail, GitHub has done an amazing job covering lots of this too:
+
+* [The Commit Graph](https://github.blog/2022-08-30-gits-database-internals-ii-commit-history-queries/?ref=blog.gitbutler.com#the-commit-graph)
+* [Sparse checkout](https://github.blog/2020-01-17-bring-your-monorepo-down-to-size-with-sparse-checkout/?ref=blog.gitbutler.com)
+* [Filesystem Monitor](https://github.blog/2022-06-29-improve-git-monorepo-performance-with-a-file-system-monitor/?ref=blog.gitbutler.com)
+* [Sparse index](https://github.blog/2021-11-10-make-your-monorepo-feel-small-with-gits-sparse-index/?ref=blog.gitbutler.com)
+* [Partial and shallow clone](https://github.blog/2020-12-21-get-up-to-speed-with-partial-clone-and-shallow-clone/?ref=blog.gitbutler.com)
+* [The Story of Scalar](https://github.blog/2022-10-13-the-story-of-scalar/?ref=blog.gitbutler.com)
+
+There is also a ton more fascinating information on this from [Derrick Stolee](https://stolee.dev/?ref=blog.gitbutler.com), who did a lot of work on these projects.
+
+Ok, that's it for our Git Tips series! Hope you enjoyed it and let us know in Discord if you have any questions or comments, or would like to see us do any other topics in Git land.
+
+Thanks!
+
+### Subscribe to new posts.
\ No newline at end of file
diff --git a/Omnivore/2024-02-21 - How to Use the JavaScript Map and Set Objects – Explained with Code Examples.md b/Omnivore/2024-02-21 - How to Use the JavaScript Map and Set Objects – Explained with Code Examples.md
new file mode 100644
index 0000000..cd161c5
--- /dev/null
+++ b/Omnivore/2024-02-21 - How to Use the JavaScript Map and Set Objects – Explained with Code Examples.md
@@ -0,0 +1,462 @@
+---
+id: 75f0d58e-d13c-11ee-abe1-23b9fd5ced9a
+title: |
+ How to Use the JavaScript Map and Set Objects – Explained with Code Examples
+status: ARCHIVED
+tags:
+ - read-later
+ - RSS
+date_added: 2024-02-21 18:39:50
+url_omnivore: |
+ https://omnivore.app/me/how-to-use-the-java-script-map-and-set-objects-explained-with-co-18dcf1d24bb
+url_original: |
+ https://www.freecodecamp.org/news/javascript-map-and-set-objects-explained/
+---
+
+# How to Use the JavaScript Map and Set Objects – Explained with Code Examples
+
+## Highlights
+
+Under the hood, the `Map` object performs better when you need to add and remove keys, so you might consider using it when your data changes frequently.
+
+Also, the Map object has many useful methods for data manipulation, such as `has()` to see if the Map contains a specific key, `keys()` to get all keys defined in the `Map`, `values` to get all values, and `entries()` to get all key/value pairs.
+
+[source](https://omnivore.app/me/how-to-use-the-java-script-map-and-set-objects-explained-with-co-18dcf1d24bb#9c807b39-b9c0-49de-895e-1d7f6b095ab4)
+
+---
+
+The `Set` object allows you to store a collection of elements, just like an Array. The differences between a `Set` and an array are:
+
+* A `Set` requires all elements to be unique
+* A `Set` has fewer methods for data manipulation
+
+[source](https://omnivore.app/me/how-to-use-the-java-script-map-and-set-objects-explained-with-co-18dcf1d24bb#52f87526-14bc-40fb-b821-493da97dd7e3)
+
+---
+
+Aside from the regular methods above, `Set` also has composition methods that you can use to perform various set theory operations such as difference, union, and intersection.
+
+[source](https://omnivore.app/me/how-to-use-the-java-script-map-and-set-objects-explained-with-co-18dcf1d24bb#cb2eebdd-f9f4-4a83-b298-f65c5556f842)
+
+---
+
+## Original
+
+
+
+Map and Set are two JavaScript data structures you can use to store a collection of values, similar to Objects and Arrays. They are specialized data structures that can help you store and manipulate related values.
+
+In this tutorial, we will see how Map and Set work in detail and when to use them. We will also explore the Set object composition methods that were recently added to the JavaScript standard.
+
+## Table of Contents
+
+* [The Map Object Explained](#the-map-object-explained)
+ * [How to Create a Map Object](#how-to-create-a-map-object)
+ * [Map Object Methods and Properties](#map-object-methods-and-properties)
+ * [Other Ways to Create a Map Object](#other-ways-to-create-a-map-object)
+ * [Iterate Over Map Object Data](#iterate-over-map-object-data)
+ * [When to Use the Map Object](#when-to-use-the-map-object)
+* [Set Object Explained](#set-object-explained)
+ * [How to create a Set Object](#how-to-create-a-set-object)
+ * [Set Object Methods and Properties](#set-object-methods-and-properties)
+ * [Set Composition Methods](#set-composition-methods)
+ * [Iterate Over a Set Object](#iterate-over-a-set-object)
+ * [When to Use the Set Object](#when-to-use-the-set-object)
+* [Conclusion](#conclusion)
+
+## The Map Object Explained
+
+The `Map` object stores data in a key/value pair structure, just like an Object. The main differences between a regular object and a `Map` are:
+
+* A `Map` can have any type of data as the key value
+* A `Map` maintains the order of data added to the object
+
+### How to Create a Map Object
+
+To create a `Map` object, you can call the `Map()` constructor as follows:
+
+```dart
+const myMap = new Map();
+```
+
+Create a Map object in JavaScript
+
+The code above creates a new empty `Map` object.
+
+### Map Object Methods and Properties
+
+A `Map` object has the following methods and properties:
+
+* `set(key, value)` – Adds a key/value pair to a Map
+* `get(key)` – Retrieves a value from a Map (returns `undefined` if key doesn't exist)
+* `has(key)` – Checks if a Map has a specific key
+* `delete(key)` – Removes a specific key from a Map
+* `clear()` – Removes all items from a Map
+* `keys()` – Returns all keys in a Map
+* `values()` – Returns all values in a Map
+* `entries()` – Returns all keys and values in a Map
+* `size` – Returns the number of items in Map
+
+To insert data into the `Map` object, you can use the `set()` method:
+
+```dart
+const myMap = new Map();
+
+myMap.set(1, 'Jack');
+myMap.set(2, 'Jill');
+myMap.set('animal', 'Elephant');
+```
+
+Inserting values to the Map object
+
+The code above creates a `Map` object with 3 entries as follows:
+
+```dart
+Map(3)
+0: {1 => "Jack"}
+1: {2 => "Jill"}
+2: {"animal" => "Elephant"}
+```
+
+The Map object entries
+
+To retrieve a value from the `Map` object, you need to use the `get()` method and pass the key as its argument:
+
+```livecodeserver
+console.log(myMap.get(1)); // Jack
+
+console.log(myMap.get('animal')); // Elephant
+
+
+```
+
+Retrieving Map object values
+
+ To see how many key/value pairs a `Map` has, you can access the `size` property:
+
+```arduino
+myMap.size; // 3
+```
+
+Accessing the Map.size property
+
+To see if a certain key exists in a `Map` object, you can use the `has()` method. See the example below:
+
+```angelscript
+myMap.has(1); // true
+
+myMap.has(10); // false
+```
+
+Using the Map.has() method
+
+To remove a key/value pair from a `Map` object, you can use the `delete()` method and pass the key of the pair you want to remove as follows:
+
+```awk
+myMap.delete(1);
+
+console.log(myMap);
+// 0: {2 => "Jill"}
+// 1: {"animal" => "Elephant"}
+```
+
+Deleting an entry from the Map object
+
+If you want to remove all key/value pairs, you can use the `clear()` method instead:
+
+```arduino
+myMap.clear();
+
+console.log(myMap); // Map(0) {size: 0}
+```
+
+Clearing a Map object
+
+### Other Ways to Create a Map Object
+
+You can also create a `Map` object from an Array as follows:
+
+```prolog
+const myMap = new Map([
+ [1, 'Jack'],
+ [2, 'Jill'],
+ ['animal', 'Elephant'],
+]);
+```
+
+Creating a Map from an Array
+
+When creating a `Map` from an Array, you need to create a two-dimensional array and specify two elements in each array.
+
+The first element will be the key, the second element will be the value. Any extra value in the array will be ignored.
+
+In the example below, the value 'Johnson' from the first array will be ignored by the `Map()` constructor:
+
+```dart
+const myMap = new Map([
+ [1, 'Jack', 'Johnson'], // the value 'Johnson' is ignored
+ [2, 'Jill'],
+ ['animal', 'Elephant'],
+]);
+```
+
+Creating a Map from an array with more than two values
+
+Because you can create a `Map` object from an array, you can also create one from an object. You need to transform the object into an array first using the `Object.entries()` method.
+
+The following example shows how to use an object to create a `Map`:
+
+```javascript
+const person = {
+ 'name': 'Jack',
+ 'age': 20,
+}
+
+const myMap = new Map(Object.entries(person));
+
+console.log(myMap); // Map(2) { 'name' => 'Jack', 'age' => 20 }
+```
+
+Creating a Map from an object
+
+### Iterate Over Map Object Data
+
+To iterate over a `Map` object data, you can use either the `forEach()` method or the `for .. of` loop:
+
+```javascript
+const myMap = new Map([
+ [1, 'Jack'],
+ [2, 'Jill'],
+ ['animal', 'Elephant'],
+]);
+
+// iterate using the forEach() method
+myMap.forEach((value, key) => {
+ console.log(`${key}: ${value}`);
+});
+
+// or using the for .. of loop
+
+for (const [key, value] of myMap) {
+ console.log(`${key}: ${value}`);
+}
+```
+
+Both methods give the same output:
+
+```http
+1: Jack
+2: Jill
+animal: Elephant
+```
+
+### When to Use the Map Object
+
+You can think of the `Map` object as an upgraded version of the regular Object. It can use any type of data as the key value, while an object can only use string values as keys.
+
+==Under the hood, the== `==Map==` ==object performs better when you need to add and remove keys, so you might consider using it when your data changes frequently.==
+
+==Also, the Map object has many useful methods for data manipulation, such as== `==has====()==` ==to see if the Map contains a specific key,== `==keys====()==` ==to get all keys defined in the== `==Map==`==,== `==values==` ==to get all values, and== `==entries====()==` ==to get all key/value pairs.==
+
+But if you only want to create an object without further manipulation, then you don't need to use the `Map` object.
+
+One example is when you send a network request using the `fetch()` method. You would create an object and convert it into a JSON string, so using a `Map` object won't give any benefit.
+
+## Set Object Explained
+
+==The== `==Set==` ==object allows you to store a collection of elements, just like an Array. The differences between a== `==Set==` ==and an array are:==
+
+* ==A== `==Set==` ==requires all elements to be unique==
+* ==A== `==Set==` ==has fewer methods for data manipulation==
+
+### How to Create a Set Object
+
+To create a new `Set` object, you need to call the `Set()` constructor as follows:
+
+```dart
+const mySet = new Set();
+```
+
+Creating a new Set object
+
+The code above will create a new empty set.
+
+### Set Object Methods and Properties
+
+A `Set` object has the following methods and properties:
+
+* `add(value)` – Adds a value to a Set
+* `has(value)` – Checks if a Set contains a specific value
+* `delete(value)` – Removes a specific value from a Set
+* `clear()` – Removes all items from a Set
+* `keys()` – Returns all values in a Set
+* `values()` – Returns all values in a Set
+* `entries()` – Returns all values in a Set as `[value, value]` array
+* `size` – Returns the number of items in Set
+
+Note that the `keys()` and `values()` methods in a Set object return the same output.
+
+There's also the `entries()` method which returns an array as follows:
+
+```javascript
+const mySet = new Set(['Jack', 'Jill', 'John']);
+
+console.log(mySet.entries());
+```
+
+Running Set entries() method
+
+Output:
+
+```prolog
+[Set Entries] {
+ [ 'Jack', 'Jack' ],
+ [ 'Jill', 'Jill' ],
+ [ 'John', 'John' ]
+}
+```
+
+Output of Set entries() method
+
+Notice how the values are repeated once in each array above. The `entries()` method is created to make `Set` similar to the `Map` object, but you probably don't need it.
+
+There are extra methods that you can use to interact with another `Set` object. We'll discuss them in the next section.
+
+To add an element to the Set object, you can use the add method:
+
+```processing
+const mySet = new Set();
+
+mySet.add(1);
+mySet.add(2);
+mySet.add(3);
+
+console.log(mySet); // [1, 2, 3]
+```
+
+Adding new elements to the Set object
+
+To get all values stored in a `Set`, call the `values()` method:
+
+```pgsql
+mySet.values(); // [Set Iterator] { 'Jack', 'Jill', 'John' }
+```
+
+Getting all values from a Set object
+
+To check if the `Set` has a specific value, use the `has()` method:
+
+```elixir
+mySet.has('Jack'); // true
+
+mySet.has('Michael'); // false
+```
+
+Check if a Set has a specific value
+
+To remove a single value, call the `delete()` method. To remove all values, use the `clear()` method:
+
+```less
+mySet.delete('Jill');
+
+mySet.clear();
+```
+
+Delete a single value or clear all from Set
+
+### Set Composition Methods
+
+==Aside from the regular methods above,== `==Set==` ==also has composition methods that you can use to perform various set theory operations such as difference, union, and intersection.==
+
+The following table is from [MDN Set documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global%5FObjects/Set#set%5Fcomposition):
+
+
+
+A List of Set Composition Methods
+
+For example, you can get a set containing the differences between two other sets as follows:
+
+```angelscript
+const setA = new Set([1, 2, 3, 4, 5]);
+
+const setB = new Set([4, 5, 6, 7, 8]);
+
+const diffsA = setA.difference(setB); // Set(3) {1, 2, 3}
+const diffsB = setB.difference(setA); // Set(3) {6, 7, 8}
+
+```
+
+Example of using the Set difference() method
+
+Here, the `setA.difference(setB)` returns a `Set` containing values unique to the `setA` object.
+
+The opposite values are returned when you run `setB.difference(setA)` method.
+
+Note that these methods are new additions to the JavaScript standard, and as of this writing, only Safari 17 and Chrome 122 support these methods.
+
+Most likely, these methods will be included in Node.js soon.
+
+### Iterate Over a Set Object
+
+To iterate over a `Set` object, you can use either the `forEach()` method or the `for .. of` loop:
+
+```pgsql
+const mySet = new Set(['Jack', 'Jill', 'John']);
+
+// iterate using the forEach() method
+mySet.forEach(value => {
+ console.log(value);
+});
+
+// or using the for .. of loop
+
+for (const value of mySet) {
+ console.log(value);
+}
+```
+
+Output:
+
+```mipsasm
+Jack
+Jill
+John
+```
+
+### When to Use the Set Object
+
+You can think of the `Set` object as the alternative version of the regular Array.
+
+Because a `Set` object ignores duplicate values, you can use this object to purge duplicates from an Array, then turn the `Set` object back to an Array:
+
+```angelscript
+const myArray = [1, 1, 2, 2, 3, 3];
+
+const uniqueArray = [...new Set(myArray)];
+
+console.log(uniqueArray); // [ 1, 2, 3 ]
+```
+
+Creating a unique array with the help of Set
+
+Another reason you may want to use a `Set` is when you need to compose multiple set objects using the composition methods, such as `union()` and `difference()`. These methods are not available in an Array.
+
+## Conclusion
+
+In this article, you've learned how the Map and Set objects work and when to use them in your code.
+
+If you enjoyed this article and want to take your JavaScript skills to the next level, I recommend you check out my new book __Beginning Modern JavaScript_ [here](https://codewithnathan.com/beginning-modern-javascript).
+
+[](https://codewithnathan.com/beginning-modern-javascript)
+
+The book is designed to be easy for beginners and accessible to anyone looking to learn JavaScript. It provides a step-by-step gentle guide that will help you understand how to use JavaScript to create a dynamic web application.
+
+Here's my promise: __You will actually feel like you understand what you're doing with JavaScript._
+
+See you later!
+
+---
+
+---
+
+ 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/)
\ No newline at end of file
diff --git a/Omnivore/2024-02-23 - The Life-Changing Magic of Tidying Up Your To-Do List.md b/Omnivore/2024-02-23 - The Life-Changing Magic of Tidying Up Your To-Do List.md
new file mode 100644
index 0000000..4366fdc
--- /dev/null
+++ b/Omnivore/2024-02-23 - The Life-Changing Magic of Tidying Up Your To-Do List.md
@@ -0,0 +1,45 @@
+---
+id: f5956559-3eb2-4717-93bd-3f3a2f0c5549
+title: |
+ The Life-Changing Magic of Tidying Up Your To-Do List
+status: ARCHIVED
+tags:
+ - read-later
+date_added: 2024-02-23 20:22:03
+url_omnivore: |
+ https://omnivore.app/me/https-todoist-com-inspiration-life-changing-magic-tidying-todois-18bf18e00a2
+url_original: |
+ https://todoist.com/inspiration/life-changing-magic-tidying-todoist
+---
+
+# The Life-Changing Magic of Tidying Up Your To-Do List
+
+## Notes
+
+Before you even start looking at your tasks, write down what having a neatly organized and prioritized to-do list would mean for your life. Maybe you want to run a successful business, get in shape, be more present with your family, have closer relationships with friends, or lead a more adventurous life.
+
+Find a medium that lets you truly envision the details. You can describe it in words, mind map it, draw it out, create a Pinterest board, collect YouTube videos, or brainstorm in whatever form suits you.
+
+Why do you want to get in shape? The answer might be "to have more energy and feel more confident." Why do you want to have more energy and feel more confident? Maybe the answer is "to be more fully yourself and stop worrying about what other people think of you." Ask yourself "why" 3-5 times for every item in your vision.
+## Original
+
+<DIV id="readability-content"><DIV data-omnivore-anchor-idx="1" class="page" id="readability-page-1"><article data-omnivore-anchor-idx="2"><div data-omnivore-anchor-idx="3"><header data-omnivore-anchor-idx="4"><p data-omnivore-anchor-idx="5">Your to-do list should spark joy, not dread. </p></header><figure data-omnivore-anchor-idx="6"><img data-omnivore-anchor-idx="7" data-omnivore-original-src="https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FErickMRamos_Thumbnail.jpg" alt="" fetchpriority="high" width="1056" height="600" decoding="async" data-nimg="1" sizes="(max-width: 1056px) 100vw, 1056px" srcset="https://proxy-prod.omnivore-image-cache.app/360x0,s2pPzWVwDdpoMzmcla1WY3YTiuziGGtvFiaKsR9dYQho/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_360/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FErickMRamos_Thumbnail.jpg 360w,https://proxy-prod.omnivore-image-cache.app/384x0,sk3KXBW_fLMf3iAUIQLlLsS99Ia1UrigJNiZNQ5WwMqI/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_384/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FErickMRamos_Thumbnail.jpg 384w,https://proxy-prod.omnivore-image-cache.app/480x0,sNx_OBUxyxjW0FgILdJMcQE8LFI5KlWZXQxmHQ95NNUU/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_480/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FErickMRamos_Thumbnail.jpg 480w,https://proxy-prod.omnivore-image-cache.app/768x0,sZk_Wau5hexgvBE_8RYd3pAp8y_IxVDIbe4wALFiEgQY/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_768/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FErickMRamos_Thumbnail.jpg 768w,https://proxy-prod.omnivore-image-cache.app/960x0,s2RNWKFuW-d2B3vG2H5Um8pkhpAnWnnH3qIZyEZx4ls0/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_960/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FErickMRamos_Thumbnail.jpg 960w,https://proxy-prod.omnivore-image-cache.app/1120x0,s_Kwh_LE5N7dGe4E5fjB6T_UliHFavZBkOJy5C6sSXfQ/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_1120/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FErickMRamos_Thumbnail.jpg 1120w,https://proxy-prod.omnivore-image-cache.app/1536x0,snehhqjYLiPURZHBj3ln6VQ3IxHxVA-23g6yx3QGc-ks/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_1536/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FErickMRamos_Thumbnail.jpg 1536w,https://proxy-prod.omnivore-image-cache.app/2240x0,sJaL5to7RhRJhrXlDPLKfPKeb0uKJNOnEjsYHI9OYOt4/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2240/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FErickMRamos_Thumbnail.jpg 2240w,https://proxy-prod.omnivore-image-cache.app/2624x0,sk4WpINf3s30tasmHaMd37_FtxGMQlKll5UKfizfjYOY/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FErickMRamos_Thumbnail.jpg 2624w," src="https://proxy-prod.omnivore-image-cache.app/1056x600,suQwzWvR6LVntj5cL6lQ3l9zjBVrYKQ9sR3VVBMJZXl0/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FErickMRamos_Thumbnail.jpg"><figcaption data-omnivore-anchor-idx="8"><span data-omnivore-anchor-idx="9">Illustration by <a data-omnivore-anchor-idx="10" href="https://www.instagram.com/erickmramos/" target="_blank" rel="noopener noreferrer">Erick M. Ramos</a></span></figcaption></figure></div><div data-omnivore-anchor-idx="11"><div data-omnivore-anchor-idx="12"><p data-omnivore-anchor-idx="13">Your to-do list is an extension of your mind. It’s the spare room where you keep tomorrow’s work tucked away so you can focus on what’s in front of you today.</p><p data-omnivore-anchor-idx="14">But just like a spare room, if you don’t regularly tidy up your list, things get cluttered. Instead of being a reliable source of to-dos, it becomes a task in itself to sort through the mess and figure out what to work on next. A tidy task list does more than just improve productivity — it benefits your mental clarity, decision-making, and even your mood.</p><p data-omnivore-anchor-idx="15">Taking a cue from Marie Kondo’s excellent <a data-omnivore-anchor-idx="16" href="http://konmari.com/" target="_blank" rel="noopener noreferrer"><em data-omnivore-anchor-idx="17">The Life-Changing Magic of Tidying Up</em></a>, you can declutter your task list in the same way she tidies physical belongings: by establishing a few simple, organizational habits.</p><p data-omnivore-anchor-idx="18">So get started by following along with Marie’s <em data-omnivore-anchor-idx="19">Konmari</em> system: The to-do list edition.</p><h2 data-omnivore-anchor-idx="20" id="1-before-you-start-visualize-your-destination">1. Before you start, visualize your destination</h2><p data-omnivore-anchor-idx="21"><button data-omnivore-anchor-idx="22"><span data-omnivore-anchor-idx="23"><figure data-omnivore-anchor-idx="24"><img data-omnivore-anchor-idx="25" data-omnivore-original-src="https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-1_blog.png" alt=""The question of what you want to own is actually the question of how you want to live your life." – Marie Kondo" loading="lazy" width="512" height="451" decoding="async" data-nimg="1" sizes="(max-width: 512px) 100vw, 512px" srcset="https://proxy-prod.omnivore-image-cache.app/360x0,sYtVB_fNdJjInbK2bMuv1K0eSiQpdkMWcijLvghKnFk8/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_360/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-1_blog.png 360w,https://proxy-prod.omnivore-image-cache.app/384x0,sp_8QKA9E6zyh35Hfz_toPfKZPnUybnCea5sjE69aLng/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_384/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-1_blog.png 384w,https://proxy-prod.omnivore-image-cache.app/480x0,s29MtbakKYQUV0yFrIKEVEf2Cj36305zQB0JyejU41PQ/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_480/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-1_blog.png 480w,https://proxy-prod.omnivore-image-cache.app/768x0,svAV0g1bGcpN3BiyrpxQ2WyW91fypAdR6ZP4_qvJZsFc/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_768/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-1_blog.png 768w,https://proxy-prod.omnivore-image-cache.app/960x0,sPCoLsvuqpLhKfuURcP7gM9J0FM7yc-ZSu7AqvzkzfqQ/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_960/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-1_blog.png 960w,https://proxy-prod.omnivore-image-cache.app/1120x0,s8lThAdKVjDYu2NWVM3LNiXMzRGXVnXLLloTpRQ7rJ7Y/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_1120/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-1_blog.png 1120w,https://proxy-prod.omnivore-image-cache.app/1536x0,sN-Geh1306ZlZD2ufBV-_jie2GSHFzCBuJ-cP-wFKH-8/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_1536/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-1_blog.png 1536w,https://proxy-prod.omnivore-image-cache.app/2240x0,sgdLE6KTBH1GJyHy5XSj6towetODbTWyO6v_Bamqfym0/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2240/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-1_blog.png 2240w,https://proxy-prod.omnivore-image-cache.app/2624x0,sWoShwTijmof-jGvBNy0n83-Jkz2Ob-oqJL4XI8fIvq8/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-1_blog.png 2624w," src="https://proxy-prod.omnivore-image-cache.app/512x451,sM8WI_ONTxFJTPMOzsZlJpZ1bE59mBTxeDNah1Q9UxjA/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-1_blog.png"></figure></span></button></p><p data-omnivore-anchor-idx="26">How can you know which tasks are worth doing if you don’t know where you want to go? How will you find the motivation to keep your to-do list clutter-free if you don't know why you're decluttering in the first place?</p><p data-omnivore-anchor-idx="27">Before touching any clutter, Marie asks her clients to envision the life they want to achieve by tidying up.</p><blockquote data-omnivore-anchor-idx="28"><p data-omnivore-anchor-idx="29">Think in concrete terms so that you can vividly picture what it would be like to live in a clutter-free space.</p></blockquote><p data-omnivore-anchor-idx="30">Or in this case, a clutter-free to-do list. Before you even start looking at your tasks, write down what having a neatly organized and prioritized to-do list would mean for your life. Maybe you want to run a successful business, get in shape, be more present with your family, have closer relationships with friends, or lead a more adventurous life.</p><p data-omnivore-anchor-idx="31">Find a medium that lets you truly envision the details. You can describe it in words, mind map it, draw it out, create a Pinterest board, collect YouTube videos, or brainstorm in whatever form suits you.</p><p data-omnivore-anchor-idx="32">But don't stop there. "[T]o prevent rebound you need to move ahead properly, step by step, as you launch into this once-in-a-lifetime event," Marie says. "Your next step is to identify why you want to live like that."</p><p data-omnivore-anchor-idx="33">Why do you want to get in shape? The answer might be "to have more energy and feel more confident." Why do you want to have more energy and feel more confident? Maybe the answer is "to be more fully yourself and stop worrying about what other people think of you." Ask yourself "why" 3-5 times for every item in your vision. Marie explains the importance of this step to prevent a relapse into messiness:</p><blockquote data-omnivore-anchor-idx="34"><p data-omnivore-anchor-idx="35">As you continue to explore the reasons behind your ideal lifestyle, you will come to a simple realization. The whole point in both discarding and keeping things is to be happy. It may seem obvious, but it is important to experience this realization for yourself and let it sink into your heart. Before you start tidying, look at the lifestyle you aspire to and ask yourself, “Why do I want to tidy?”</p></blockquote><p data-omnivore-anchor-idx="36">Keep your "why" top-of-mind as you tidy and after by creating <a data-omnivore-anchor-idx="37" href="https://todoist.com/help/articles/get-started-with-todoist-OgNNJR#add-your-first-task" target="_blank" rel="noreferrer noopener">a task</a> in your Todoist that represents your final vision. If you have an accompanying document or image, <a data-omnivore-anchor-idx="38" href="https://todoist.com/help/articles/how-to-format-text-e5dHw9" target="_blank" rel="noreferrer noopener">link</a> to it from your task or <a data-omnivore-anchor-idx="39" href="https://todoist.com/help/articles/introduction-to-comments-and-file-uploads-CwiA50">attach</a> it to your task comments. This is the True North that will help you determine whether a task is worth doing. If you’ve written out an all-encompassing vision, break it down into <a data-omnivore-anchor-idx="40" href="https://todoist.com/inspiration/goals-todoist/" target="_blank" rel="noopener">several goals for each area of your life</a>, and create a task for each.</p><p data-omnivore-anchor-idx="41"><button data-omnivore-anchor-idx="42"><span data-omnivore-anchor-idx="43"><figure data-omnivore-anchor-idx="44"><img data-omnivore-anchor-idx="45" data-omnivore-original-src="https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FComments%402x.png" alt="" loading="lazy" width="550" height="569" decoding="async" data-nimg="1" sizes="(max-width: 550px) 100vw, 550px" srcset="https://proxy-prod.omnivore-image-cache.app/360x0,sgGZ_AeCPQTv8XHZIxzb6qKwPVDra7KLlD1Sm84QNRJc/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_360/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FComments%402x.png 360w,https://proxy-prod.omnivore-image-cache.app/384x0,s6fshfj0V5LQ-CeWfS9XhT4tBriGcT-60MLDgXmJL_qg/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_384/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FComments%402x.png 384w,https://proxy-prod.omnivore-image-cache.app/480x0,sX_zSJwY3wFtwYBjjjWokjNuCCxgmrT7TyRgcprIU73g/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_480/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FComments%402x.png 480w,https://proxy-prod.omnivore-image-cache.app/768x0,sNrUzgRe1FXrmd3WU946E4VT7JMzHqi_uHO26LbUKcow/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_768/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FComments%402x.png 768w,https://proxy-prod.omnivore-image-cache.app/960x0,s_ErgtmwijFDXRfKc9h5weCEphxtuicErARuJX0mCVI8/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_960/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FComments%402x.png 960w,https://proxy-prod.omnivore-image-cache.app/1120x0,s1-KofsMPrnIOEMHsjcAXB5pTYgz3swUywrAbK96BdkE/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_1120/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FComments%402x.png 1120w,https://proxy-prod.omnivore-image-cache.app/1536x0,syRUFQ3fxpHOsWhokCizEsInOTPWi60tELFzfJpvmrE4/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_1536/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FComments%402x.png 1536w,https://proxy-prod.omnivore-image-cache.app/2240x0,sxUKIBgUc80wiA7VHEYLSyVSg3rtYNZlhnC1vY4Nqpac/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2240/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FComments%402x.png 2240w,https://proxy-prod.omnivore-image-cache.app/2624x0,sOZwEEZ1aKbqdW8PZ-G_aprj6Ocu0bS2TPrc6o9fQHpQ/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FComments%402x.png 2624w," src="https://proxy-prod.omnivore-image-cache.app/550x569,sfJqF_nANYv2rphzJ6QLAMRB-ZB0qYcYx32eeZNGet-o/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FComments%402x.png"><figcaption data-omnivore-anchor-idx="46"><p data-omnivore-anchor-idx="47">Use your final goal to keep your tasks aimed in the right direction.</p></figcaption></figure></span></button></p><p data-omnivore-anchor-idx="48">You may want to give your task a <a data-omnivore-anchor-idx="49" href="https://todoist.com/help/articles/set-a-recurring-due-date-YUYVJJAV" target="_blank" rel="noreferrer noopener">recurring due date</a> to review the vision you set out for yourself at the start of each day.</p><p data-omnivore-anchor-idx="50">Once you're clear on <em data-omnivore-anchor-idx="51">why</em> you're tidying, you're ready to start tackling the hard decisions of what to keep on your to-do list and what to let go of.</p><h2 data-omnivore-anchor-idx="52" id="2-finish-discarding-first">2. Finish discarding first</h2><p data-omnivore-anchor-idx="53"><button data-omnivore-anchor-idx="54"><span data-omnivore-anchor-idx="55"><figure data-omnivore-anchor-idx="56"><img data-omnivore-anchor-idx="57" data-omnivore-original-src="https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-6_blog.png" alt="Quote by Marie Kondo "To truly cherish the things that are important to you, you must first discard those that have outlived their purpose."" loading="lazy" width="512" height="451" decoding="async" data-nimg="1" sizes="(max-width: 512px) 100vw, 512px" srcset="https://proxy-prod.omnivore-image-cache.app/360x0,s_QPzOUpT4f_8xqo0f0y7any8gzjLMRHF5GCywrjSgG8/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_360/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-6_blog.png 360w,https://proxy-prod.omnivore-image-cache.app/384x0,sldyCLD5Ma2tudL800GvlF35PZeJiDxEl5vpq9B1G5m0/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_384/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-6_blog.png 384w,https://proxy-prod.omnivore-image-cache.app/480x0,s47Px52UGW1PDAck4jS9Yqi5-I3XVtcAvqegSuNzu2eM/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_480/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-6_blog.png 480w,https://proxy-prod.omnivore-image-cache.app/768x0,sF-R3wPn8ekVRZEicoEgmLRB6C8yU0fiX_LkNAs8jwXo/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_768/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-6_blog.png 768w,https://proxy-prod.omnivore-image-cache.app/960x0,sXeTtbnQwNxIfXdIYfbLzILIKn7InertuydvIWLiIUXo/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_960/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-6_blog.png 960w,https://proxy-prod.omnivore-image-cache.app/1120x0,sbE6-mJ4nqFEHisCDUMP1ry6FICGYVKWvTuPcb3WGCIQ/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_1120/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-6_blog.png 1120w,https://proxy-prod.omnivore-image-cache.app/1536x0,s6-pLq62InWKsL-ZlxppuSjzNTQwD39oGYXDXMKOfl9U/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_1536/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-6_blog.png 1536w,https://proxy-prod.omnivore-image-cache.app/2240x0,sHKaHXeaX79uteFadehVQ_ey2SPAUrynsIqo2iK7ureg/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2240/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-6_blog.png 2240w,https://proxy-prod.omnivore-image-cache.app/2624x0,sgLjm7_xEvSBdUYQ11wN2GabG-HC-NZ4P9xPEZiiUyHc/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-6_blog.png 2624w," src="https://proxy-prod.omnivore-image-cache.app/512x451,srkQ-cyW-acfVMoEPkYIV2Ln5lxt7kINna3EngiQEgeo/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-6_blog.png"></figure></span></button></p><p data-omnivore-anchor-idx="58">Think of your task list like a physical space: when it's crammed with random stuff, it becomes too hard to find the things that you actually need.</p><p data-omnivore-anchor-idx="59">Right now, your Todoist may be stuffed with half-baked ideas, empty projects, and tasks you forgot to check off:</p><p data-omnivore-anchor-idx="60"><button data-omnivore-anchor-idx="61"><span data-omnivore-anchor-idx="62"><figure data-omnivore-anchor-idx="63"><img data-omnivore-anchor-idx="64" data-omnivore-original-src="https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FOverdue%402x.png" alt="" loading="lazy" width="550" height="460.5" decoding="async" data-nimg="1" sizes="(max-width: 550px) 100vw, 550px" srcset="https://proxy-prod.omnivore-image-cache.app/360x0,s_vZdeH5HeOajDzFjjJ795PO7DYAZ4bnbBWFFlJmfMPU/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_360/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FOverdue%402x.png 360w,https://proxy-prod.omnivore-image-cache.app/384x0,sBOuQBSFM-nCOOQAx-424b4COxnFvue7lEowFV0vPoJ4/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_384/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FOverdue%402x.png 384w,https://proxy-prod.omnivore-image-cache.app/480x0,sLEI0BzkI3Ydl571tFPvDBgD8MEAKpQPmLVz5GE7I5DQ/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_480/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FOverdue%402x.png 480w,https://proxy-prod.omnivore-image-cache.app/768x0,sUTKY-fFAyBIdEYTn63x1d8S5_hC4P8wu62qNMpaY7Ao/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_768/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FOverdue%402x.png 768w,https://proxy-prod.omnivore-image-cache.app/960x0,scSdVrlmLXOk1YkLTo8tyBrGj9xwbc-hf5mwSCXSPMLM/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_960/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FOverdue%402x.png 960w,https://proxy-prod.omnivore-image-cache.app/1120x0,spqlD8wDlIZXxRXozIgLShyHHOY0i2kQ5Thrpk8gjcbg/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_1120/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FOverdue%402x.png 1120w,https://proxy-prod.omnivore-image-cache.app/1536x0,sh4VbZWSJdw8geHRisy4hlGsduWOW7FKN_EypYCIKtUs/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_1536/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FOverdue%402x.png 1536w,https://proxy-prod.omnivore-image-cache.app/2240x0,sFUsPiaAOww9HLh6ZlnzVPsxHuEjG45f3suBnCA5_mzY/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2240/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FOverdue%402x.png 2240w,https://proxy-prod.omnivore-image-cache.app/2624x0,s_48-hkH3GwhBdWkQg-uUtHMYWS5UqjDiXOxK4SkwCKg/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FOverdue%402x.png 2624w," src="https://proxy-prod.omnivore-image-cache.app/550x0,sEBJk_XdlECWBpilyJg0I7XD_dq5ixyWIR-17GJPP1WA/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FOverdue%402x.png"><figcaption data-omnivore-anchor-idx="65"><p data-omnivore-anchor-idx="66">Discard first, organize second.</p></figcaption></figure></span></button></p><p data-omnivore-anchor-idx="67">Following Marie’s system, it’s time to do a <em data-omnivore-anchor-idx="68">task inventory.</em></p><div data-omnivore-anchor-idx="69"><p data-omnivore-anchor-idx="70">It’s not just Marie. David Allen, the author of Gettings Things Done, <a data-omnivore-anchor-idx="71" href="https://www.fastcompany.com/3046463/the-father-of-getting-things-done-youre-getting-me-all-wrong" target="_blank" rel="noopener noreferrer">believes</a> that organizing our life is actually a search for mental space: GTD is “more of a space management system.” Learn more about <a data-omnivore-anchor-idx="72" href="https://todoist.com/productivity-methods/getting-things-done" target="_blank" rel="noopener noreferrer">how to use GTD with Todoist</a>.</p></div><h3 data-omnivore-anchor-idx="73" id="do-a-complete-task-inventory">Do a complete task inventory</h3><p data-omnivore-anchor-idx="74"><button data-omnivore-anchor-idx="75"><span data-omnivore-anchor-idx="76"><figure data-omnivore-anchor-idx="77"><img data-omnivore-anchor-idx="78" data-omnivore-original-src="https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-2_blog.png" alt="Quote by Marie Kondo: "Once you learn to choose your belongings properly, you will be left with only the amount that fits perfectly in the space you own."" loading="lazy" width="512" height="451" decoding="async" data-nimg="1" sizes="(max-width: 512px) 100vw, 512px" srcset="https://proxy-prod.omnivore-image-cache.app/360x0,s1b4ahEKW9QAYpNSCr9QPgmMFkRKSg0RExLHx6uQrg3o/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_360/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-2_blog.png 360w,https://proxy-prod.omnivore-image-cache.app/384x0,sbQtqThbohaoCZ_QQ_LoI_gKc8ZEdR9nohx1vz_ze4c0/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_384/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-2_blog.png 384w,https://proxy-prod.omnivore-image-cache.app/480x0,s9LU78XxSHviGqiOhMSFB4TsZ5D4rKKwrnXZ6fWda_Cs/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_480/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-2_blog.png 480w,https://proxy-prod.omnivore-image-cache.app/768x0,s4twFWUMjVOLPutzkLqsQmNmdmsx7JNDBiqiZ_PAfkNE/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_768/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-2_blog.png 768w,https://proxy-prod.omnivore-image-cache.app/960x0,sNdY3SmFNTDKe0aYyvzWr9fhUdxqSyVZjvOnt74U3S6I/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_960/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-2_blog.png 960w,https://proxy-prod.omnivore-image-cache.app/1120x0,sl6mlrxUa4bP9Sbmbop6TLJ--UGLxWlZR8ahvKgKVruI/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_1120/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-2_blog.png 1120w,https://proxy-prod.omnivore-image-cache.app/1536x0,s_BK4kdBgyHwMtACHELgAogZaxdtTXTurp0rLuC0syag/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_1536/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-2_blog.png 1536w,https://proxy-prod.omnivore-image-cache.app/2240x0,sr2Fcp6fyFwAOpbkGLyjiQMXK0kD98fBMKcKccJ9MOBA/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2240/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-2_blog.png 2240w,https://proxy-prod.omnivore-image-cache.app/2624x0,sv5aDWVFsQ3Gou5CssXysKERlaPlkFw0jFx7nEPbk5Fs/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-2_blog.png 2624w," src="https://proxy-prod.omnivore-image-cache.app/512x451,sHggQbqdFgKuYQJqORPwVFqI91_BibCJrhaHcSZ2RD68/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-2_blog.png"></figure></span></button></p><p data-omnivore-anchor-idx="79">When Marie Kondo arrives at a house to tidy it up, she begins by kneeling on the floor in the center of the living room to show respect for all of its belongings. From there, she helps her client begin the journey, considering each and every item in turn.</p><p data-omnivore-anchor-idx="80">Take the same approach (kneeling optional) and do a full inventory of all the tasks and projects in your Todoist. Depending on how cluttered your to-do list is, you may want to dedicate a full day or even a weekend to this endeavor. Otherwise, as Marie says, "Tidy a little bit each day, and you'll be tidying forever."</p><p data-omnivore-anchor-idx="81">Remember, this exercise isn’t just about decluttering your to-do list — it’s about cutting away the nonessential so that the only tasks you have left are the ones that bring you closer to the life you want to live. Marie's famous standard is "Does it spark joy?" If the answer is yes, keep it. If not, get rid of it.</p><p data-omnivore-anchor-idx="82">For your to-do list, we recommend a slightly different criterion. As you do your inventory, ask yourself: </p><blockquote data-omnivore-anchor-idx="83"><p data-omnivore-anchor-idx="84">Does this task bring me closer to the life I want to live?</p></blockquote><p data-omnivore-anchor-idx="85">If the answer is yes, keep it. It not, <a data-omnivore-anchor-idx="86" href="https://todoist.com/help/articles/use-the-task-view-to-manage-tasks-in-todoist-eDeRDO0C" target="_blank" rel="noreferrer noopener">delete it</a> from your task list.</p><p data-omnivore-anchor-idx="87">You’re going to run into tasks that you <em data-omnivore-anchor-idx="88">want</em> to delete, but let’s face it, grunt work is necessary for any significant achievement. Try reframing the tasks that don’t excite you. While “run every day” may feel like a chore, “try to run a 10-minute mile today” may be a more specific and motivating challenge.</p><p data-omnivore-anchor-idx="89"><button data-omnivore-anchor-idx="90"><span data-omnivore-anchor-idx="91"><figure data-omnivore-anchor-idx="92"><img data-omnivore-anchor-idx="93" data-omnivore-original-src="https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FMotivatingTask%402x.png" alt="" loading="lazy" width="307" height="81" decoding="async" data-nimg="1" sizes="(max-width: 307px) 100vw, 307px" srcset="https://proxy-prod.omnivore-image-cache.app/360x0,sEYW8AI-ePrQlsuwviaS0HWBYD3F5Pk9LAAEZPPo6jbk/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_360/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FMotivatingTask%402x.png 360w,https://proxy-prod.omnivore-image-cache.app/384x0,sf1ug0T4_PuPoFlBKgr7lzNn6W6MnGIzYKyf6f-HFexg/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_384/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FMotivatingTask%402x.png 384w,https://proxy-prod.omnivore-image-cache.app/480x0,sWz7aBa6HBnzO-0cmLZbjbl4oQ8COx-dmNoIU1uQCUH0/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_480/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FMotivatingTask%402x.png 480w,https://proxy-prod.omnivore-image-cache.app/768x0,sqrbxeVznQBCkjH-JPHkAByXiDG3qROiW7JS2LBahiFw/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_768/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FMotivatingTask%402x.png 768w,https://proxy-prod.omnivore-image-cache.app/960x0,scUn8ZGmnh7rs-Amb1SbTiJAsrW5SjhCdu0Ys77cvhTI/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_960/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FMotivatingTask%402x.png 960w,https://proxy-prod.omnivore-image-cache.app/1120x0,sq0wwplbLARYdZhXHlcl3ft9p1JZCoHn_F6IAAN0X9xk/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_1120/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FMotivatingTask%402x.png 1120w,https://proxy-prod.omnivore-image-cache.app/1536x0,sJ9JTmQMlRf3o5wNpaU-roePGsgZpOzx-A5vdANhNwDg/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_1536/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FMotivatingTask%402x.png 1536w,https://proxy-prod.omnivore-image-cache.app/2240x0,sbkKTIXt-WxSpGarGa9Ei5srgqTLVXp3_SyAeCVk9SQ8/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2240/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FMotivatingTask%402x.png 2240w,https://proxy-prod.omnivore-image-cache.app/2624x0,sVpsD4lseNBL66hBuhJLqKLeTA9IB0WXB9SsJOl66jl8/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FMotivatingTask%402x.png 2624w," src="https://proxy-prod.omnivore-image-cache.app/307x81,sXqQWYFyc2KQq8Vz-Yo1L7klw17684NRRGL-dAoSLgec/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FMotivatingTask%402x.png"><figcaption data-omnivore-anchor-idx="94"><p data-omnivore-anchor-idx="95">Re-frame tasks in ways that make you remember why you want to do them in the first place.</p></figcaption></figure></span></button></p><p data-omnivore-anchor-idx="96">Even Marie concedes that there are items you have to keep even if they don't spark joy — like important documents. For work like taking out the trash or <a data-omnivore-anchor-idx="97" href="https://todoist.com/inspiration/manage-taxes-todoist" target="_blank" rel="noreferrer noopener">doing your taxes</a>, create a separate project called “responsibilities” and pare it down to the things that, while they don’t bring you joy, you just have to do anyway.</p><p data-omnivore-anchor-idx="98">This is a good exercise to check in on and see how much of your to-do list is things you <em data-omnivore-anchor-idx="99">get</em> to do vs. things you <em data-omnivore-anchor-idx="100">have</em> to do.</p><h3 data-omnivore-anchor-idx="101" id="let-things-go">Let things go</h3><p data-omnivore-anchor-idx="102"><button data-omnivore-anchor-idx="103"><span data-omnivore-anchor-idx="104"><figure data-omnivore-anchor-idx="105"><img data-omnivore-anchor-idx="106" data-omnivore-original-src="https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-5_blog.png" alt="Quote by Marie Kondo: "When we really delve int othe reasons for why we can't let something go, there are only two: an attachment to the past or a fear for the future."" loading="lazy" width="512" height="451" decoding="async" data-nimg="1" sizes="(max-width: 512px) 100vw, 512px" srcset="https://proxy-prod.omnivore-image-cache.app/360x0,sAv1s0zzBAon8R0IRGZ0znTmf-ncLVaDoSuNnCZs8zLA/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_360/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-5_blog.png 360w,https://proxy-prod.omnivore-image-cache.app/384x0,sir_hxaLKuGq_ENlOXhgvHHlgKrnMFMhEh_SiizN6AAc/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_384/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-5_blog.png 384w,https://proxy-prod.omnivore-image-cache.app/480x0,s8yktse9jw4BqZwZrX__zfqnpHG8PVy8voGTuWc_KVgo/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_480/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-5_blog.png 480w,https://proxy-prod.omnivore-image-cache.app/768x0,sVxuBNFvnmHm0wwQAH-WAlXl1gEV3eXVHecWvjNCJkYI/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_768/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-5_blog.png 768w,https://proxy-prod.omnivore-image-cache.app/960x0,s2KNs1RUWKA-XsIALmxOJMTP0rSC1g_vVa8Bs402NbPo/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_960/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-5_blog.png 960w,https://proxy-prod.omnivore-image-cache.app/1120x0,s2rJKOgtGSZtIxjMb6_xYWcsiurUVNbG6nyf2iIJ0AHE/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_1120/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-5_blog.png 1120w,https://proxy-prod.omnivore-image-cache.app/1536x0,sFNRjd4dbTIiEilTciM868AoFQC2hHTxYR2yxmThRLbU/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_1536/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-5_blog.png 1536w,https://proxy-prod.omnivore-image-cache.app/2240x0,s3mb_25ab-lD0cohA_KAmciUmzThKtii3eX7qSpPuiUA/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2240/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-5_blog.png 2240w,https://proxy-prod.omnivore-image-cache.app/2624x0,su90zzCIdpdKe-nb3dQzeJbEoeoFCHZg3vlcosfwEQ5w/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-5_blog.png 2624w," src="https://proxy-prod.omnivore-image-cache.app/512x451,sGEsJCfJ29_0xAobuDbv2M0ur6QjCSE_JAPWsXnKQZgk/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-5_blog.png"></figure></span></button></p><p data-omnivore-anchor-idx="107">You may have a tough time letting go of long-standing tasks on your list. Maybe you always envisioned yourself finishing that home renovation project yourself. Or maybe you don’t want to let go of your novel that hasn’t made it past the first chapter (or page). It can feel like giving up on the version of yourself you wanted to be when you added that task or project in the first place.</p><p data-omnivore-anchor-idx="108">Marie explains that even unfinished tasks serve a purpose. You’ve clarified what you actually care about and why:</p><blockquote data-omnivore-anchor-idx="109"><p data-omnivore-anchor-idx="110">Not every person you meet in life will become a close friend or lover. Some you will find hard to get along with or impossible to like. But these people, too, teach you the precious lesson of who you do like, so that you will appreciate those.</p></blockquote><p data-omnivore-anchor-idx="111">Letting go of old tasks and projects teaches you how to create space for what’s important to you now. As you go through your old tasks, acknowledge that there was a purpose when you added it, but it’s no longer relevant to the life you’re striving for today.</p><p data-omnivore-anchor-idx="112"><button data-omnivore-anchor-idx="113"><span data-omnivore-anchor-idx="114"><figure data-omnivore-anchor-idx="115"><img data-omnivore-anchor-idx="116" data-omnivore-original-src="https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FDeleteTask%402x.png" alt="" loading="lazy" width="548" height="286" decoding="async" data-nimg="1" sizes="(max-width: 548px) 100vw, 548px" srcset="https://proxy-prod.omnivore-image-cache.app/360x0,swhD0W-K02U-kKej36UdVi0E9KA_RDZEBejsPQAl7N6g/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_360/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FDeleteTask%402x.png 360w,https://proxy-prod.omnivore-image-cache.app/384x0,sggi7jDXHxWmZgT1VzTvgKTHD1FIQ3uui62jwUqY2mDY/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_384/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FDeleteTask%402x.png 384w,https://proxy-prod.omnivore-image-cache.app/480x0,sM45gUOsCf2dDBW2CeUonjKCw46HK56cyOc4lHzLdp2k/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_480/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FDeleteTask%402x.png 480w,https://proxy-prod.omnivore-image-cache.app/768x0,sLlU9pN9bRRBCeVixSO-3EvkbND7B8PlmiEtrTHfqlAc/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_768/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FDeleteTask%402x.png 768w,https://proxy-prod.omnivore-image-cache.app/960x0,sK4mKXmbE7ddhybsfYOfSS0aH4p7HSkP_G3dplLhh3Sg/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_960/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FDeleteTask%402x.png 960w,https://proxy-prod.omnivore-image-cache.app/1120x0,sfool1qkApvF88d5sKOoIyyHQYmRLi9aUXzq7MFbv49w/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_1120/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FDeleteTask%402x.png 1120w,https://proxy-prod.omnivore-image-cache.app/1536x0,sFv9WlNexyLsizbVRe0992-m7VmChbIY9sYDTkwWKDhk/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_1536/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FDeleteTask%402x.png 1536w,https://proxy-prod.omnivore-image-cache.app/2240x0,sKP8LVETpvtkWctrkg_Od47ZYIkwFXEpSggLWfDRQvNg/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2240/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FDeleteTask%402x.png 2240w,https://proxy-prod.omnivore-image-cache.app/2624x0,sP9OE9z2LMVqb_Jvd_xDFyfNC_3p3ZWaf6-IKz__0xbQ/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FDeleteTask%402x.png 2624w," src="https://proxy-prod.omnivore-image-cache.app/548x286,sakOhS_K1Dh3j94G42NzFWfndG9dKwEgqPQzCrLrFzCo/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FDeleteTask%402x.png"><figcaption data-omnivore-anchor-idx="117"><p data-omnivore-anchor-idx="118">Don't be afraid to delete tasks that are no longer relevant to the life you want to live.</p></figcaption></figure></span></button></p><p data-omnivore-anchor-idx="119">If you just can’t bring yourself to hit delete on a task and banish it from your life forever, you have the option to save it in a temporary project in Todoist. (Marie would strongly disapprove: “Storage is nothing but a cosmetic solution. You must begin by discarding!” But you should do what works best for you.)</p><p data-omnivore-anchor-idx="120">If you’re intent on saving tasks, <a data-omnivore-anchor-idx="121" href="https://todoist.com/help/articles/get-started-with-todoist-OgNNJR#start-with-a-project" target="_blank" rel="noreferrer noopener">create</a> a project named “Maybe later” and hide it from view by <a data-omnivore-anchor-idx="122" href="https://todoist.com/help/articles/archive-a-project-r2KEeYV2" target="_blank" rel="noreferrer noopener">archiving it</a>. You can always come back and <a data-omnivore-anchor-idx="123" href="https://todoist.com/help/articles/unarchive-a-project-in-todoist-FHs9r6CY">unarchive it</a> later.</p><p data-omnivore-anchor-idx="124"><button data-omnivore-anchor-idx="125"><span data-omnivore-anchor-idx="126"><figure data-omnivore-anchor-idx="127"><img data-omnivore-anchor-idx="128" data-omnivore-original-src="https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FArchiveProject%402x.png" alt="" loading="lazy" width="550" height="355" decoding="async" data-nimg="1" sizes="(max-width: 550px) 100vw, 550px" srcset="https://proxy-prod.omnivore-image-cache.app/360x0,sZYq4udJKWK_HGV-QdEeKEbaGab6Frg5164WJyJq0ICc/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_360/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FArchiveProject%402x.png 360w,https://proxy-prod.omnivore-image-cache.app/384x0,sx4EIypKmbEyDtKveH1YMIbK-U3HE5Ha9SBtKU2uFVBE/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_384/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FArchiveProject%402x.png 384w,https://proxy-prod.omnivore-image-cache.app/480x0,sOIh8TfIWLdWQ-qPwn1iHoElIEgyudCOfxPnCuy5km4o/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_480/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FArchiveProject%402x.png 480w,https://proxy-prod.omnivore-image-cache.app/768x0,sTEnZfpGuV0zWV69tTxxl-dLOQMUvTp-G5iWzB519Buk/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_768/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FArchiveProject%402x.png 768w,https://proxy-prod.omnivore-image-cache.app/960x0,sHRgldWehFQCGx3QY_K1VJFwMvk0wELvNYoyuBm8FL_M/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_960/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FArchiveProject%402x.png 960w,https://proxy-prod.omnivore-image-cache.app/1120x0,sxorlAQFsauOY3TUKV6vRZT7b_c8VCsiDhdBmG5GM0xU/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_1120/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FArchiveProject%402x.png 1120w,https://proxy-prod.omnivore-image-cache.app/1536x0,sud-Dh27c9eBhDiUCRiY1bw5KvGwBv7w8nKl6apsGZRM/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_1536/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FArchiveProject%402x.png 1536w,https://proxy-prod.omnivore-image-cache.app/2240x0,s30Jjcr7riSLuLAlNOP1U2tWMuE4of5QYqD9NMKzfAik/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2240/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FArchiveProject%402x.png 2240w,https://proxy-prod.omnivore-image-cache.app/2624x0,szk8lHpMP346Iz5BO88iMdza4D8WVAYmkHh-LGfN3BO4/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FArchiveProject%402x.png 2624w," src="https://proxy-prod.omnivore-image-cache.app/550x355,swJsdoEek9cPsCS_XwB-tAhsuC1i5byyaZ6cRnyeQjlc/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FArchiveProject%402x.png"></figure></span></button><a data-omnivore-anchor-idx="129" id="place"></a></p><h2 data-omnivore-anchor-idx="130" id="3-give-every-task-a-place">3. Give every task a place</h2><p data-omnivore-anchor-idx="131"><button data-omnivore-anchor-idx="132"><span data-omnivore-anchor-idx="133"><figure data-omnivore-anchor-idx="134"><img data-omnivore-anchor-idx="135" data-omnivore-original-src="https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-7_blog.png" alt="Quote by Marie Kondo "Visible mess helps distract us from the true source of the disorder."" loading="lazy" width="512" height="451" decoding="async" data-nimg="1" sizes="(max-width: 512px) 100vw, 512px" srcset="https://proxy-prod.omnivore-image-cache.app/360x0,sL7TTyo6GOakuVJkrsahwmDIstQM4PHAS0b9E-TLWuUg/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_360/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-7_blog.png 360w,https://proxy-prod.omnivore-image-cache.app/384x0,s8vx7C8PboFDKTXR11Zmt4E3-UF9qEhNeLIhp89OP0Wc/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_384/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-7_blog.png 384w,https://proxy-prod.omnivore-image-cache.app/480x0,snnb9kw2yLmLYhHS-xX9Mc7JAwgqFYtfJo22y0T2unPE/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_480/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-7_blog.png 480w,https://proxy-prod.omnivore-image-cache.app/768x0,sCnCn-JMchRdNTL803CjBUNJaxId7i26m4SMyio5Cv6s/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_768/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-7_blog.png 768w,https://proxy-prod.omnivore-image-cache.app/960x0,siY8891-6eA-0pxMF24rWtzEVASLa03u3-AGSXJ8FXuI/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_960/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-7_blog.png 960w,https://proxy-prod.omnivore-image-cache.app/1120x0,s87jqmRVHuminAYwJEoYY_gkAUDKGjtVdXdvPksjfcm4/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_1120/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-7_blog.png 1120w,https://proxy-prod.omnivore-image-cache.app/1536x0,sIHLALRhUPO5C_HGIlmEJ3UN8yyEu4bl_NyGNZ9UtGVo/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_1536/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-7_blog.png 1536w,https://proxy-prod.omnivore-image-cache.app/2240x0,sdGZSBVggGN02S7yjDQ6OCWGi_XRh-_kRM3z0eSUzaDI/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2240/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-7_blog.png 2240w,https://proxy-prod.omnivore-image-cache.app/2624x0,sBSRTamtU2hUs0WRK-ueBjkCqo8T2j9XaRm8x9yVYCD8/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-7_blog.png 2624w," src="https://proxy-prod.omnivore-image-cache.app/512x451,sc8i8gXbl8DPHStqKVSUgxtOREiTV8F48bTAWPRglaSI/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-7_blog.png"></figure></span></button></p><p data-omnivore-anchor-idx="136">Ok, you’ve got the right tasks — now it’s time to sort and organize. Similar to Marie’s rule that every physical item should have its place, every task on your to-do list should have its project. Group your tasks together in ways that feel intuitive to you.</p><p data-omnivore-anchor-idx="137">For instance, if your goal is to get in shape, you could begin with the “fitness” category and create a project with that name. Find every task related to your goal and move those tasks to the project.</p><p data-omnivore-anchor-idx="138"><button data-omnivore-anchor-idx="139"><span data-omnivore-anchor-idx="140"><figure data-omnivore-anchor-idx="141"><img data-omnivore-anchor-idx="142" data-omnivore-original-src="https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FProject%402x.png" alt="" loading="lazy" width="550" height="384" decoding="async" data-nimg="1" sizes="(max-width: 550px) 100vw, 550px" srcset="https://proxy-prod.omnivore-image-cache.app/360x0,sgo1XIAMSBt31af5KuKhYB1X9dQUY3GJSc_h6EiJ52Lw/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_360/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FProject%402x.png 360w,https://proxy-prod.omnivore-image-cache.app/384x0,s9p8QqIMnF-mrG2sQuGUzMPmd_d59nnTSP7yjqgejVYs/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_384/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FProject%402x.png 384w,https://proxy-prod.omnivore-image-cache.app/480x0,sl1YmCfvrmGYwZrC9kjWnB53XaAJQNfTxkub4XEgDKUM/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_480/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FProject%402x.png 480w,https://proxy-prod.omnivore-image-cache.app/768x0,sTZIIuHnJ3aiv-scM4--ejJ9rIgynS_X7zBpeU5HB6Uo/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_768/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FProject%402x.png 768w,https://proxy-prod.omnivore-image-cache.app/960x0,skmHEr0_UkoaQmUdHEaaBfNd235N6v6kv-SP89FK2J1E/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_960/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FProject%402x.png 960w,https://proxy-prod.omnivore-image-cache.app/1120x0,sGBCbTZYcU6fS9bTP5vqKC7861h156m7cewLkthE1mQc/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_1120/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FProject%402x.png 1120w,https://proxy-prod.omnivore-image-cache.app/1536x0,s8RgkzmyP8hphJkkF2IjQU2pBBYji2qyMQ6ikRL9wGfA/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_1536/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FProject%402x.png 1536w,https://proxy-prod.omnivore-image-cache.app/2240x0,s5a4C0Q0Qml2XVkiL-4uJ5ynxQCER0pKYVillxQC-zA4/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2240/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FProject%402x.png 2240w,https://proxy-prod.omnivore-image-cache.app/2624x0,seTTQ7QJRQXPwVWKR-_0GknZvnr3YW74pve2DdJux9KM/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FProject%402x.png 2624w," src="https://proxy-prod.omnivore-image-cache.app/550x384,s8qOC_K8GNPSq-S3MJn_oFf6r0eATCqFa24oSrHoqBEo/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FProject%402x.png"><figcaption data-omnivore-anchor-idx="143"><p data-omnivore-anchor-idx="144">Think of each project as a "room" in the life you want to build.</p></figcaption></figure></span></button></p><p data-omnivore-anchor-idx="145">Repeat this for every category until your Todoist is organized into projects. For tasks that don’t fit into any of the categories you’ve identified as important, ask yourself if it still belongs on your to-do list.</p><p data-omnivore-anchor-idx="146"><strong data-omnivore-anchor-idx="147">Keep your projects visible</strong></p><p data-omnivore-anchor-idx="148">At this point, it’s tempting to start creating a bunch of <a data-omnivore-anchor-idx="149" href="https://todoist.com/help/articles/create-a-sub-project-in-todoist-aTA15C70" target="_blank" rel="noreferrer noopener">sub-projects</a> that you can hide from view (like seasonal storage), but Marie advises her clients to keep everything visible all year round. Just as seeing every physical object you own keeps you from accumulating too much stuff, seeing every project you’ve committed to can be a helpful reminder to stay focused on what’s important and not let new tasks and projects clutter up your list.</p><p data-omnivore-anchor-idx="150"><strong data-omnivore-anchor-idx="151">Sequence your tasks</strong></p><p data-omnivore-anchor-idx="152">A great way to stay in the flow of a project is to finish one task and immediately move on to the next. Take the time to sequence your tasks in a logical order before you get to work.</p><p data-omnivore-anchor-idx="153">Rearrange tasks by dragging the handlebar to the left of each task (Web, Mac, Windows) or tapping, holding, and dragging (iOS, Android) to the right place on the list. You can do the same thing daily while <a data-omnivore-anchor-idx="154" href="https://todoist.com/inspiration/how-to-plan-your-day/" target="_blank" rel="noopener">planning your Today view</a> so that all your tasks due today are in the right order.</p><p data-omnivore-anchor-idx="155"><strong data-omnivore-anchor-idx="156">Add priorities<br data-omnivore-anchor-idx="157"></strong></p><p data-omnivore-anchor-idx="158">There are some tasks that are more essential to your goal than others. Set <a data-omnivore-anchor-idx="159" href="https://todoist.com/help/articles/introduction-to-priorities-Wy82Jp" target="_blank" rel="noreferrer noopener">task priorities</a> to keep track of which is which. In Todoist, priorities range from highest to lowest as P1 (red), P2 (orange), P3 (yellow), or P4 (no color). Here’s an example of how to evaluate a task’s priority level:</p><p data-omnivore-anchor-idx="160"><strong data-omnivore-anchor-idx="161">P1 </strong>— Must finish.</p><p data-omnivore-anchor-idx="162"><strong data-omnivore-anchor-idx="163">P2</strong> — Nice to have.</p><p data-omnivore-anchor-idx="164"><strong data-omnivore-anchor-idx="165">P3</strong> — Finish if there is time available.</p><p data-omnivore-anchor-idx="166"><strong data-omnivore-anchor-idx="167">P4 </strong>— Unnecessary. These may have snuck in through your task inventory. Delete them now.</p><p data-omnivore-anchor-idx="168"><button data-omnivore-anchor-idx="169"><span data-omnivore-anchor-idx="170"><figure data-omnivore-anchor-idx="171"><img data-omnivore-anchor-idx="172" data-omnivore-original-src="https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FPriorities%402x-1.png" alt="" loading="lazy" width="550" height="384" decoding="async" data-nimg="1" sizes="(max-width: 550px) 100vw, 550px" srcset="https://proxy-prod.omnivore-image-cache.app/360x0,spjJLHHMm_bXVDgJ9EM7V6AwctfpS_P_u4eLmbVoSVhM/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_360/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FPriorities%402x-1.png 360w,https://proxy-prod.omnivore-image-cache.app/384x0,s2SDwSRfDGudSCc6IpflKg6mMCmBbZu4OE5muWqpPgTc/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_384/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FPriorities%402x-1.png 384w,https://proxy-prod.omnivore-image-cache.app/480x0,ssFh9dVBmvo257Zuz-NjN4q5DS0CuLYOiBgZNAAHKtws/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_480/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FPriorities%402x-1.png 480w,https://proxy-prod.omnivore-image-cache.app/768x0,ssG79iMoQ4x5rRBeMvFEdlZSOY0PY4VKGUIHFk9_6mAI/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_768/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FPriorities%402x-1.png 768w,https://proxy-prod.omnivore-image-cache.app/960x0,smho-AQjj9AoJGOpNfVXZbbgOGKTwrKAXjQppZhMWLqc/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_960/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FPriorities%402x-1.png 960w,https://proxy-prod.omnivore-image-cache.app/1120x0,sK8z2NjBM7_qJUXtd_b7-Sf-ZsgZfOAINCZMD6dp6N3I/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_1120/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FPriorities%402x-1.png 1120w,https://proxy-prod.omnivore-image-cache.app/1536x0,s4YGwg6zCwVlKxQ1ZZgcUgT8Xm8dTiVsTwOygUgxCsrk/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_1536/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FPriorities%402x-1.png 1536w,https://proxy-prod.omnivore-image-cache.app/2240x0,sIRnI2KInGJnEwfVJfGpDwkYk8bJopibi8FdE_1ifLdY/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2240/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FPriorities%402x-1.png 2240w,https://proxy-prod.omnivore-image-cache.app/2624x0,sJzHdFeATxaewT4wpd22eutxNUlo-rhJCSipE3SJsWjc/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FPriorities%402x-1.png 2624w," src="https://proxy-prod.omnivore-image-cache.app/550x384,sglHiKYm_7iDYMTwwQW7t0oTH4oYt8jVAegQ6n_VZZdY/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FPriorities%402x-1.png"><figcaption data-omnivore-anchor-idx="173"><p data-omnivore-anchor-idx="174">Use priority levels to automatically order tasks from most to least important.</p></figcaption></figure></span></button></p><p data-omnivore-anchor-idx="175"><strong data-omnivore-anchor-idx="176">Give each task a due date<br data-omnivore-anchor-idx="177"></strong></p><p data-omnivore-anchor-idx="178">Finally, <a data-omnivore-anchor-idx="179" href="https://todoist.com/help/articles/introduction-to-due-dates-and-due-times-q7VobO">set a date</a> to complete each task. A handy tip is to make an estimate for how long a task will take to complete and then double it. It’s better to overestimate and finish early than to underestimate and finish late. Give each task a due date and schedule repeating tasks with a <a data-omnivore-anchor-idx="180" href="https://todoist.com/help/articles/introduction-to-due-dates-and-due-times-q7VobO" target="_blank" rel="noreferrer noopener">recurring due date</a>.</p><p data-omnivore-anchor-idx="181"><button data-omnivore-anchor-idx="182"><span data-omnivore-anchor-idx="183"><figure data-omnivore-anchor-idx="184"><img data-omnivore-anchor-idx="185" data-omnivore-original-src="https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FQuickAdd%402x.png" alt="" loading="lazy" width="598" height="298" decoding="async" data-nimg="1" sizes="(max-width: 598px) 100vw, 598px" srcset="https://proxy-prod.omnivore-image-cache.app/360x0,sO11zHxEkc5HTBqxbWU0Pim1Bek4AsuO2Bm0UEHTAKLY/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_360/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FQuickAdd%402x.png 360w,https://proxy-prod.omnivore-image-cache.app/384x0,ssJBvuzXbby_Va59XBSvDr7HWdHf2ik1oExO6vPHgJ6k/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_384/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FQuickAdd%402x.png 384w,https://proxy-prod.omnivore-image-cache.app/480x0,sr7l-KKjGM3wmIEOH0rAocjn7xQ038lS3Z986lv9gbb0/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_480/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FQuickAdd%402x.png 480w,https://proxy-prod.omnivore-image-cache.app/768x0,srxJfugNT105KiuKyCLpLCKdrr_dbgKg9BGCAq2hrfGU/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_768/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FQuickAdd%402x.png 768w,https://proxy-prod.omnivore-image-cache.app/960x0,s4zOVdo59p1SxX4wA8mf9TYz-orXn09k1cfh6__VMIk0/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_960/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FQuickAdd%402x.png 960w,https://proxy-prod.omnivore-image-cache.app/1120x0,sByeaY-40LOPuvgN6wa1jwCRNNAIx87gBgImUS8Jq7_E/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_1120/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FQuickAdd%402x.png 1120w,https://proxy-prod.omnivore-image-cache.app/1536x0,sjHJwvunI3v_WG3Y6GWcaY199TOhL7XD_Q3wH5knzO2E/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_1536/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FQuickAdd%402x.png 1536w,https://proxy-prod.omnivore-image-cache.app/2240x0,syKBNwnONzlViaQotXoCUY2y0ic1cVBB0y1pcVStaPfQ/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2240/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FQuickAdd%402x.png 2240w,https://proxy-prod.omnivore-image-cache.app/2624x0,sOz9mQw7yVkjRZ57lJME9TOCVbF44K_qL-goYLRT2olI/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FQuickAdd%402x.png 2624w," src="https://proxy-prod.omnivore-image-cache.app/598x298,sw0vLsLYn2Ux6irOLxaCN21Gpy5GhNa-Dubu94R9Q_6A/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2023%2F11%2FQuickAdd%402x.png"></figure></span></button></p><h3 data-omnivore-anchor-idx="186" id="make-sure-your-to-do-list-sparks-joy">Make sure your to-do list “sparks joy”</h3><p data-omnivore-anchor-idx="187">Aesthetics affect our mindset. When Marie does her inventory, she shows up dressed to the nines. She has carefully picked out every part of her appearance to suit the needs of the day. She takes the same approach to the space she’s reviewing:</p><blockquote data-omnivore-anchor-idx="188"><p data-omnivore-anchor-idx="189">"Imagine what it would be life to have a bookshelf filled only with books that you really love. Isn't that image spellbinding? For someone who loves books, what greater happiness could there be?"</p></blockquote><p data-omnivore-anchor-idx="190">Give Todoist a style that will put you in a positive mindset whenever you open it. To borrow Marie’s signature phrase, make your digital task space “spark joy.” Here are a few tips:</p><ul data-omnivore-anchor-idx="191">
+<li data-omnivore-anchor-idx="192">Write clear, specific, and motivating project and task titles. For example, instead of naming your task “Go for a jog,” try “Take a morning jog through the forest” or “Explore a new running route today”</li>
+
+
+
+<li data-omnivore-anchor-idx="193">Add <a data-omnivore-anchor-idx="194" href="https://todoist.com/help/articles/how-to-format-text-e5dHw9">text formatting and emojis</a> to give them life: “Take a morning jog through the forest 🌅🏃🌲”</li>
+
+
+
+<li data-omnivore-anchor-idx="195">Use a <a data-omnivore-anchor-idx="196" href="https://todoist.com/help/articles/change-color-themes-zD0N5K" target="_blank" rel="noreferrer noopener">color theme</a> that matches your style or mood</li>
+
+
+
+<li data-omnivore-anchor-idx="197">Arrange your projects in an intuitive way</li>
+
+
+
+<li data-omnivore-anchor-idx="198">Continually let go of the projects and tasks that don't excite you</li>
+</ul>
+<p data-omnivore-anchor-idx="199">Your Todoist is ready for action. Simply log in every day, and your Today view will let you know what to work on. When things get busy, you’ll have clarity on what you <del data-omnivore-anchor-idx="200">have to</del> get to focus on next.</p><h2 data-omnivore-anchor-idx="201" id="4-change-your-mindset-then-your-habits">4. Change your mindset, then your habits</h2><p data-omnivore-anchor-idx="202"><button data-omnivore-anchor-idx="203"><span data-omnivore-anchor-idx="204"><figure data-omnivore-anchor-idx="205"><img data-omnivore-anchor-idx="206" data-omnivore-original-src="https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FMarie-Kondo-quote.png" alt="Quote by Marie Kondo "People cannot change their tidying habits without first changing their way of thinking."" loading="lazy" width="512" height="451" decoding="async" data-nimg="1" sizes="(max-width: 512px) 100vw, 512px" srcset="https://proxy-prod.omnivore-image-cache.app/360x0,snXo_UpBx-50QqRI09V_HoLbSXmX9hBQQ9v6_WGe4Xnw/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_360/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FMarie-Kondo-quote.png 360w,https://proxy-prod.omnivore-image-cache.app/384x0,sKmGeViMMwE8aGoHpRGzmVn9oSGcf0ejh-19GefbouNI/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_384/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FMarie-Kondo-quote.png 384w,https://proxy-prod.omnivore-image-cache.app/480x0,soDaHRuOVVWmvkNvBMA9i03LUkk_I3aXF_bJPbr98LmE/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_480/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FMarie-Kondo-quote.png 480w,https://proxy-prod.omnivore-image-cache.app/768x0,sQ0JMVn7mMRx_VTZrz64YafVB8D0SKZ9-m5_JdIl8Tq0/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_768/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FMarie-Kondo-quote.png 768w,https://proxy-prod.omnivore-image-cache.app/960x0,s7kMxIMfjoj3xCjoWO1hO072jR_VuzbNE-e_5ECvKZAc/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_960/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FMarie-Kondo-quote.png 960w,https://proxy-prod.omnivore-image-cache.app/1120x0,s0X8KHskkXQtWYpZfZb4rGisKeW3nTRdZV9fNKMW1vok/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_1120/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FMarie-Kondo-quote.png 1120w,https://proxy-prod.omnivore-image-cache.app/1536x0,s7_n60jvbwjfPtPg8g9EU7c-SCupDHXhPheCIsvjVWEk/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_1536/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FMarie-Kondo-quote.png 1536w,https://proxy-prod.omnivore-image-cache.app/2240x0,sIn2_gHFul5Hp51PtSwzysaemtSOaSjfGZLKluVDGujc/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2240/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FMarie-Kondo-quote.png 2240w,https://proxy-prod.omnivore-image-cache.app/2624x0,sJQ26VYH2jF5gpRmK2zFICWivUUQTP1IPpwSzuEH9OR4/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FMarie-Kondo-quote.png 2624w," src="https://proxy-prod.omnivore-image-cache.app/512x451,siFSWtDt9govf6WdYk1qAt4mplDJqRD_hX_4eQqYdvX0/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FMarie-Kondo-quote.png"></figure></span></button></p><p data-omnivore-anchor-idx="207">You’ve revamped your task list to be cleaner, simpler, and more aligned with your goals. But don’t expect the work to be finished overnight.</p><p data-omnivore-anchor-idx="208">At this point, Marie has noticed that many people lose faith — “I’m just a messy person!” But that’s not the case. Being tidy is an acquired mindset, she says.</p><p data-omnivore-anchor-idx="209">With your to-do list, this translates to asking that essential question for every new task coming into your Todoist: Does it lead to your vision? If not, discard it on the spot. If the answer is yes, add it to the proper spot on your list.</p><p data-omnivore-anchor-idx="210">Of course, unhelpful tasks are bound to sneak in from time to time. Weed them out with a <a data-omnivore-anchor-idx="211" href="https://todoist.com/inspiration/weekly-review/" target="_blank" rel="noopener noreferrer">weekly review,</a> so you start each week with a clearly prioritized to-do list. Discard tasks that don't bring you closer to your goals. Organize the spare tasks that have ended up in your <a data-omnivore-anchor-idx="212" href="https://todoist.com/help/articles/how-to-best-use-the-inbox-HwHvYErS" target="_blank" rel="noreferrer noopener">inbox</a> into the right projects. Have certain tasks or projects fallen out of line with your goal? Discard those, too.</p><p data-omnivore-anchor-idx="213">Finally, check in on your big-picture goals every few months. It’s natural for priorities to shift as you grow and learn more about what tasks and projects truly motivate you.</p><p data-omnivore-anchor-idx="214"><button data-omnivore-anchor-idx="215"><span data-omnivore-anchor-idx="216"><figure data-omnivore-anchor-idx="217"><img data-omnivore-anchor-idx="218" data-omnivore-original-src="https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-3_blog.png" alt="Quote by Marie Kondo: "From the moment you start tidying, you will be compelled to reset your life. As a result, your life will start to change."" loading="lazy" width="512" height="451" decoding="async" data-nimg="1" sizes="(max-width: 512px) 100vw, 512px" srcset="https://proxy-prod.omnivore-image-cache.app/360x0,skALcjcaHAdqblfxBIwouIs5eOsGmHvLWeECpxvV5VYY/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_360/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-3_blog.png 360w,https://proxy-prod.omnivore-image-cache.app/384x0,sy2Yd5mWuBHWdQjhLZsMjeKxcAdQBlV_bwdv5QtKOmew/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_384/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-3_blog.png 384w,https://proxy-prod.omnivore-image-cache.app/480x0,sWjvvHwHnTfF2IltUU-FBTfFWv30kbj9rBgF7o4f4yJk/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_480/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-3_blog.png 480w,https://proxy-prod.omnivore-image-cache.app/768x0,sB7e0KPwbEru5Yw9usaf3LcbUCmze7P2CRiar2QkKxl8/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_768/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-3_blog.png 768w,https://proxy-prod.omnivore-image-cache.app/960x0,sLgsP-Z4NoEOlW3FaQEAeAOEc0pM8ywmI2QYXYvalOk0/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_960/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-3_blog.png 960w,https://proxy-prod.omnivore-image-cache.app/1120x0,sJCr_2T01n0wtF-GSb8t3dIAkjuqrQFyP4sF7Apashg8/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_1120/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-3_blog.png 1120w,https://proxy-prod.omnivore-image-cache.app/1536x0,szAvphV1fMF7VqGSaZuqPVAy8G8GlxVxqe1YYmyxxEM4/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_1536/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-3_blog.png 1536w,https://proxy-prod.omnivore-image-cache.app/2240x0,sWSAJ_Y3WYCl22fFTPoDuBgFvTnuPnW0MxHQz3WbniO0/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2240/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-3_blog.png 2240w,https://proxy-prod.omnivore-image-cache.app/2624x0,s1x5wMCbkH_5jOAIdTbFr1yrpN8eAt5CpcraKUqGVtUA/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-3_blog.png 2624w," src="https://proxy-prod.omnivore-image-cache.app/512x451,sg30SjuWfbydy7rwalDcVQSETRcRmoziILNaI7RoKEmg/https://res.cloudinary.com/imagist/image/fetch/q_auto,f_auto,c_scale,w_2624/https%3A%2F%2Ftdinspiration.wpengine.com%2Fwp-content%2Fuploads%2F2018%2F02%2FQuote-3_blog.png"></figure></span></button></p><p data-omnivore-anchor-idx="219">If your goals change, update your "life vision" task to document and do a mini-inventory to re-tidy your Todoist. Over time, the goals that stand the test of time will be valuable to you, and now you’ll have the tools to achieve them in an organized way.</p><hr data-omnivore-anchor-idx="220" aria-orientation="horizontal"><p data-omnivore-anchor-idx="221">We spend a lot of time in digital spaces. Luckily, we can take a page from Marie Kondo’s ideas about physical space to keep our digital environment — and, by extension, our minds and lives — tidy. It’s not just a productivity boost; in a world of constant interruptions and information overload, healthy organizational habits will help you stay balanced and carve out time for the things that bring you joy, all the while making progress toward what matters to you most.</p></div><div data-omnivore-anchor-idx="222"><p data-omnivore-anchor-idx="223">Neil Vidyarthi</p><p data-omnivore-anchor-idx="224"><span data-omnivore-anchor-idx="225">Neil Vidyarthi is a product marketer and mindfulness evangelist at Doist.</span></p></div></div></article></DIV></DIV>
\ No newline at end of file
diff --git a/Omnivore/2024-02-26 - How to Learn the Hard Parts of React – and Tips to Conquer Them.md b/Omnivore/2024-02-26 - How to Learn the Hard Parts of React – and Tips to Conquer Them.md
new file mode 100644
index 0000000..e846f47
--- /dev/null
+++ b/Omnivore/2024-02-26 - How to Learn the Hard Parts of React – and Tips to Conquer Them.md
@@ -0,0 +1,598 @@
+---
+id: 085bfd7c-d52a-11ee-bfc7-b34a261d031c
+title: |
+ How to Learn the Hard Parts of React – and Tips to Conquer Them
+status: ARCHIVED
+tags:
+ - read-later
+ - RSS
+date_added: 2024-02-26 18:07:53
+url_omnivore: |
+ https://omnivore.app/me/how-to-learn-the-hard-parts-of-react-and-tips-to-conquer-them-18de8db4244
+url_original: |
+ https://www.freecodecamp.org/news/hard-parts-of-react/
+---
+
+# How to Learn the Hard Parts of React – and Tips to Conquer Them
+
+## Highlights
+
+The first instinct for many developers when faced with creating dynamic lists is to use the index property as the key. It seems like a convenient solution, as the index provides a unique identifier for each element in the array – but it isn’t the best approach for the following reasons:
+
+* **Non-Persistent**: If the order or number of items changes, React may get confused. For example, if an item is added or removed from the beginning of the list, all the subsequent indices change, causing potential re-rendering issues.
+* **Array Mutations**: Operations like sorting or filtering can alter the order of items, breaking the association between the index and the actual item.
+* **Performance Concerns**: React relies on keys for efficient updates. Using the index as a key might impact performance when dealing with large lists or frequent updates.
+
+Some of the better alternatives include:
+
+* **Use a Unique ID**: If each item in your array has a unique identifier, such as an `id` property, use that as the key.
+
+[source](https://omnivore.app/me/how-to-learn-the-hard-parts-of-react-and-tips-to-conquer-them-18de8db4244#e912d65e-4c82-41f1-94d4-56c151254c3e)
+
+---
+
+Generate a Unique Key: In cases where items lack a natural unique identifier, consider using a function like `crypto.randomUUID()` to generate a unique key.
+
+[source](https://omnivore.app/me/how-to-learn-the-hard-parts-of-react-and-tips-to-conquer-them-18de8db4244#9074fe2d-d95d-4fc6-af45-be052bb24de5)
+
+---
+
+To ensure your component behaves as expected and follows React's principles, always use the setter function (`setNames`) to update the state.
+
+[source](https://omnivore.app/me/how-to-learn-the-hard-parts-of-react-and-tips-to-conquer-them-18de8db4244#a42adf04-e7ec-4612-a7ea-c179bfce9163)
+
+---
+
+To safeguard your component from unexpected errors, incorporate optional chaining (`?.`) when accessing nested properties in API data.
+
+[source](https://omnivore.app/me/how-to-learn-the-hard-parts-of-react-and-tips-to-conquer-them-18de8db4244#7ef6781d-7b8b-496d-bd2d-2974995be502)
+
+---
+
+* **Put data outside components**: Move things like lists and groups of information outside the main part of a component when possible. This helps avoid extra updates and makes it simpler to handle data without using special functions like `useCallback`.
+* **Be careful with `React.memo`**: Using `React.memo` can help your components run better, but it's not always needed. If a component changes a lot with new information, using `React.memo` might not be as helpful. Use it wisely.
+* **Create your own custom React hooks**: I also like making my own special tools with custom React hooks. It's a bit advanced, but it helps keep my code neat and organized.
+
+[source](https://omnivore.app/me/how-to-learn-the-hard-parts-of-react-and-tips-to-conquer-them-18de8db4244#eb5d0b4b-a153-4551-a3a4-522a590854b5)
+
+---
+
+## Original
+
+
+
+Have you started learning React, only to face bugs that made you contemplate a career in goat herding? Don't worry – we've all been there.
+
+In this guide, you'll join me on a quest through the quirky wonders of React. I'll help you navigate the perplexing moments, ensuring you never have to ask yourself, "What’s up with React?"
+
+Whether you're a seasoned React adventurer or unearthing the mysteries of virtual DOMs, fear not. I'm here to share the tales of my early struggles, demystify the enigmatic bugs, and pave the way for a smoother journey.
+
+### Prerequisites
+
+* Fundamentals of HTML and CSS
+* Fundamentals of ES6 JavaScript and React
+
+## ****What We'll Cover:**
+
+1. [Quick Recap of React Fundamentals](#what-we-ll-cover-)
+– [Components: The Web Building Blocks](#components-the-web-building-blocks)
+– [JSX: Where HTML Meets JavaScript](#jsx-where-html-meets-javascript)
+– [State and Props: The Dynamic Duo](#state-and-props-the-dynamic-duo)
+2. [The Good, the Bad, and the Challenging Parts of React](#the-good-the-bad-and-the-challenging-parts-of-react)
+– [The Good Parts of React](#the-good-parts-of-react)
+– [The Bad Parts of React](#the-bad-parts-of-react)
+– [The Challenging Parts of React](#the-challenging-parts-of-react)
+ – [Key Prop Mishaps](#key-prop-mishaps)
+ – [Mutating States Directly](#mutating-states-directly)
+ – [Mysterious Bugs with Conditional Rendering](#mysterious-bugs-with-conditional-rendering)
+ – [Ignoring Dependency Arrays in React Hooks](#ignoring-dependency-arrays-in-react-hooks)
+ – [Neglecting Optional Chaining for API Data](#neglecting-optional-chaining-for-api-data)
+ – [Ignoring React Fragments for Grouping JSX Elements](#ignoring-react-fragments-for-grouping-jsx-elements)
+3. [Opinionated Approaches to React](#opinionated-approaches-to-react)
+4. [Wrapping Up the Quirky Journey with React](#wrapping-up-the-quirky-journey-with-react)
+
+## Quick Recap of React Fundamentals
+
+The React library revolves around 3 building blocks: Components, JSX, and State & Props.
+
+### Components: The Web Building Blocks
+
+Imagine components as the LEGO bricks of your user interface—a single, reusable piece that contributes to the grand structure. They encapsulate functionality, styling, and behavior, making your UI both modular and scalable.
+
+From a simple button to an elaborate sidebar, components are the heart and soul of React development.
+
+### JSX: Where HTML Meets JavaScript
+
+JSX, or JavaScript XML, may seem like an odd fusion of HTML and JavaScript at first, but it’s quite straightforward. It's the secret sauce that makes React's syntax so expressive and dynamic.
+
+With JSX, you write your UI components using a syntax that resembles HTML, but underneath, it's pure JavaScript.
+
+### State and Props: The Dynamic Duo
+
+The dynamic duo of state and props bring React pages to life as they add interactivity to your web applications.
+
+#### State: Granting Memory to Components
+
+State provides memory to components, allowing them to remember past events and alter their behavior over time. It's the key to making your UI responsive and dynamic.
+
+Picture a form that remembers the user's input or a counter that increments with each click. That's the magic of state.
+
+#### Props: Enabling Communication
+
+Props (short for properties) facilitate communication between components. They allow parent components to pass data down to their children, creating a seamless flow of information.
+
+Think of props as messengers, ensuring that each component knows its role and receives the necessary information to perform it.
+
+## The Good, the Bad, and the Puzzling Parts of React
+
+Before we delve into the puzzling aspects of React, it's essential to shine a spotlight on the treasures that make React a true hero in your arsenal.
+
+### The Good Parts of React
+
+#### Virtual DOM and its Advantages
+
+The virtual DOM is a revolutionary concept that gives React its speed and efficiency.
+
+When changes occur in your app, React doesn't immediately update the actual DOM. Instead, it works with a lightweight copy, the Virtual DOM, making minimal, lightning-fast adjustments. This not only optimizes performance but also provides a smoother user experience.
+
+```reasonml
+ReactDOM.createRoot(document.getElementById("root")).render(
+ <App />
+ );
+
+```
+
+This process leverages [React's diffing algorithm](https://legacy.reactjs.org/docs/reconciliation.html) in the Virtual DOM. It identifies the minimal set of changes needed in the actual DOM to reflect the updated state.
+
+
+
+Explaining how React updates the UI using the virtual DOM
+
+#### Reusable Components
+
+In React, the guiding principle is reusability. Components, the fundamental building blocks we discussed above, can be crafted and employed across your application. This not only fosters a modular and organized code structure but also frees you from the burden of reinventing the wheel.
+
+```hsp
+// Reusable Button Component
+const Button = ({ label, onClick }) => (
+ <button onClick={onClick}>{label}</button>
+);
+
+// Usage
+<Button label="Click me" onClick={() => console.log("Button Clicked")} />
+
+```
+
+#### One-way Data Binding for a Predictable Flow
+
+React enforces a unidirectional data flow, ensuring predictability and maintainability.
+
+Parent components convey data down to their children through props, and any modifications are overseen by the parent component. This one-way street prevents the chaos with 2-way data binding seen in other frameworks.
+
+```kotlin
+const ParentComponent = () => {
+ const [data, setData] = useState("Hello from Parent!");
+
+ return <ChildComponent data={data} />;
+};
+
+const ChildComponent = ({ data }) => <div>{data}</div>;
+
+```
+
+### The Bad Parts of React
+
+There are some parts of React that aren't ideal, though. Let's go through them briefly now so you can be aware of them.
+
+#### Steep Learning Curve for Beginners
+
+Starting with React can be tough, especially if you're new to web development. Concepts like JSX, components, and state management might seem like a maze. But don't worry! With some practice and patience, it gets easier, and React becomes more familiar.
+
+#### JSX Might Puzzle You at First
+
+JSX, the special mix of HTML and JavaScript, can be a bit confusing at the beginning. It's like learning a new language that blends the two. But as you get the hang of it, you'll see how it makes your code shorter and clearer.
+
+#### State Management Challenges
+
+Using state in React is powerful, but it can also be tricky. Handling state across lots of different pieces, especially in big projects, can create complex setups and potential problems. Luckily, tools like [Redux](https://redux.js.org/) exist to help manage this complexity.
+
+## The Challenging Parts of React
+
+### Key Prop Mishaps
+
+When building your applications, you may often have repeating elements which show similar information or share the same styles. The logical step would be to loop over them to create a list of elements.
+
+```xquery
+function ListComponent() {
+ const people = [{ name: "Mitchelle" }, { name: "July" }, { name: "David" }];
+ return (
+ <ul>
+ {/ Looping over the people array to create list items /}
+ {people.map((person) => (
+ <li>{person.name}</li>
+ ))}
+ </ul>
+ );
+}
+
+```
+
+Everything seems fine until you notice a warning in your console or, worse, strange behaviour in how your list renders.
+
+
+
+The console an error due to missing key prop
+
+React uses keys to update and reorder elements in a list. When you forget to provide a key prop or if the keys are not unique, React gets a bit lost. It's like trying to keep track of items in the array without any specific identifiers – things get mixed up, and you might end up with unexpected bugs in your UI.
+
+#### How to solve it
+
+==The first instinct for many developers when faced with creating dynamic lists is to use the index property as the key. It seems like a convenient solution, as the index provides a unique identifier for each element in the array== ==– but it isn’t the best approach for the following reasons:==
+
+* **==Non-Persistent==**==: If the order or number of items changes, React may get confused. For example, if an item is added or removed from the beginning of the list, all the subsequent indices change, causing potential re-rendering issues.==
+* **==Array Mutations==**==: Operations like sorting or filtering can alter the order of items, breaking the association between the index and the actual item.==
+* **==Performance Concerns==**==: React relies on keys for efficient updates. Using the index as a key might impact performance when dealing with large lists or frequent updates.==
+
+==Some of the better alternatives include:==
+
+* **==Use a Unique ID==**==: If each item in your array has a unique identifier, such as an== `==id==` ==property, use that as the key.==
+
+```clojure
+{people.map((person) => (
+ <li key={person.id}>{person.name}</li>
+))}
+
+```
+
+* ==Generate a Unique Key: In cases where items lack a natural unique identifier, consider using a function like== `==crypto====.randomUUID====()==` ==to generate a unique key.==
+
+```clojure
+ {people.map((person) => (
+ <li key={crypto.randomUUID()}>{person.name}</li>
+ ))}
+
+```
+
+By choosing one of these alternatives, you provide React with stable and unique keys, helping it manage and update your dynamic lists,
+
+**Note**: You may be thinking “If `crypto.randomUUID` generates a unique ID, (`Math.random()` \* some big number) would work the same, right”?
+
+
+
+Nope gif
+
+`Math.random()` could also suffice as a key, but it's a bad idea because the generated keys won't be stable across re-renders, leading to potential performance issues and rendering inconsistencies.
+
+### Mutating States Directly
+
+Imagine you're working on a component that manages an array of names. Rather than using the appropriate setter method to update the state, you decide to directly mutate the state.
+
+```javascript
+const MutableStateComponent = () => {
+ const [names, setNames] = useState(["David", "John", "Steph", "Anthony"]);
+
+ const removeLastName = () => {
+ console.log(names);
+ // Direct mutation of state using pop()
+ names.pop();
+ setNames(names); // This won't trigger a re-render
+ };
+
+ return (
+ <div>
+ <p>Names: {names.join(", ")}</p>
+ <button onClick={removeLastName}>Remove Last Name</button>
+ </div>
+ );
+};
+
+```
+
+To your surprise, the UI doesn't update as expected, and you find yourself stuck in a scenario where the list of names seems frozen. Make no mistake, the array is getting updated as seen below:
+
+
+
+Array getting mutated with UI being updated
+
+#### What's the Problem?
+
+React relies on an immutable state for efficient updates, and when you bypass this mechanism, it disrupts the unidirectional data flow.
+
+In this case, using `pop()` mutates the original array in place, and React loses track of the changes. This leads to an inaccurate rendering of the component.
+
+#### How to Solve it
+
+==To ensure your component behaves as expected and follows React's principles, always use the setter function (==`==setNames==`==) to update the state.==
+
+```javascript
+const MutableStateComponent = () => {
+ const [names, setNames] = useState(["David", "John", "Steph", "Anthony"]);
+
+ const removeLastName = () => {
+ // Use setNames to update state
+ setNames((prevNames) => prevNames.slice(0, -1));
+ console.log(names);
+ };
+
+ return (
+ <div>
+ <p>Names: {names.join(", ")}</p>
+ <button onClick={removeLastName}>Remove Last Name</button>
+ </div>
+ );
+};
+
+```
+
+By using `setNames` and creating a new array with the desired changes (in this case, using `slice` to remove the last element), you ensure that React can accurately track and update the state, resulting in the expected UI behavior.
+
+
+
+Result of mutating states with the correct method
+
+### Mysterious Bugs with Conditional Rendering
+
+Conditional rendering, while powerful, can introduce subtle bugs when not handled with care. Understanding common pitfalls, particularly those related to truthy and falsy evaluations, is crucial for preventing mysterious rendering behaviour.
+
+Consider the following example:
+
+```javascript
+const IncorrectConditionalComponent = ({ showContent }) => (
+ {showContent && <div>Show me if true!</div>}
+);
+
+```
+
+#### The Bug: Unexpected Rendering with Falsy Values
+
+In this code snippet, if `showContent` happens to be a falsy value, such as `0`, the component will render an unexpected result. Instead of gracefully not rendering the content, it will display `0` on the screen due to the direct inclusion of curly braces.
+
+
+
+I gotcha gif
+
+#### What's the Problem?
+
+The issue lies in the mismanagement of truthy and falsy values. The direct use of curly braces creates an object wrapper (`[object Object]`), causing the component to render whatever value is present, even if it's falsy.
+
+#### How to Solve it
+
+To catch rendering bugs related to truthy and falsy values, use a more explicit conditional check.
+
+```javascript
+const CorrectConditionalComponent = ({ showContent }) => (
+ showContent ? <div>Show me if true!</div> : null
+);
+
+```
+
+In this corrected version, the ternary operator ensures a clear check for truthiness, preventing unexpected rendering issues. By explicitly handling truthy and falsy values, you build robust components that behave predictably in various scenarios.
+
+### Ignoring Dependency Arrays in React Hooks
+
+Imagine working on a component that relies on an effect to perform some logic when a certain state, let's say `count`, changes. But even though you're incrementing the count, the effect doesn't seem to run, and you're left wondering why your logic isn't taking effect.
+
+```javascript
+const Counter = () => {
+ const [count, setCount] = useState(0);
+
+ const handleClick = () => {
+
+ setCount((count) => count + 1);
+ };
+
+ useEffect(() => {
+ console.log("The current count value is ", count);
+ }, []);
+
+ return (
+ <div>
+ <p>Count: {count}</p>
+ <button onClick={handleClick}>Increment</button>
+ </div>
+ );
+};
+
+```
+
+
+
+Testing the count component without fixing the useEffect dependency array
+
+#### What's the Problem?
+
+The issue lies in neglecting the dependency array in your `useEffect`. When you omit the dependencies, React might not recognize that the effect is tied to a specific piece of state, leading to stale data and unexpected behavior.
+
+#### How to Solve it
+
+To get your effect back on track, include the relevant dependencies in the dependency array. It's like setting up triggers – you're telling React, "Hey, run this effect whenever these specific pieces of data change."
+
+```coffeescript
+useEffect(() => {
+ console.log("The current count value is ", count);
+ }, [count]);
+
+```
+
+Which now fires the `useEffect` hook:
+
+
+
+Testing the count component after fixing the useEffect dependency array
+
+### Neglecting Optional Chaining for API Data
+
+You're working on a component that displays user data fetched from an API. Everything seems fine until you encounter an unexpected runtime error. The culprit? A missing optional chaining operator.
+
+#### What's the Problem?
+
+API responses can be unpredictable, and not all data structures match your expectations. Neglecting optional chaining, especially when accessing deeply nested properties (looking at you Strapi response data 👀) can lead to runtime errors if a property is undefined.
+
+#### How to Solve it
+
+==To safeguard your component from unexpected errors, incorporate optional chaining (==`==?.==`==) when accessing nested properties in API data.==
+
+As an example, say you want to read a deeply nested property (label) from this data:
+
+```dts
+const data = {
+ id: 1,
+ title: "First Item",
+ content: "Content for the first item",
+ category: {
+ id: 101,
+ name: "Category A",
+ description: "Description of Category A",
+ tags: [
+ {
+ id: 1001,
+ label: "Tag 1",
+ },
+ {
+ id: 1002,
+ label: "Tag 2",
+ },
+ ],
+ },
+ author: {
+ id: 201,
+ name: "John Doe",
+ email: "john.doe@example.com",
+ },
+ };
+
+```
+
+The correct way would be to use optional chaining to retrieve that data:
+
+```ebnf
+ const firstLabel = data?.category?.tags?.[0]?.label;
+
+```
+
+Rather than accessing those properties directly:
+
+```angelscript
+const firstLabel = data.category.tags[0].label;
+
+```
+
+This prevents you from seeing a white screen error and a flooded console if the data structure changes. It's like putting on a safety net – if a property is missing, your app won't come crashing down like so:
+
+
+
+Error occurring when optional chaining isn't applied
+
+### Ignoring React Fragments for Grouping JSX Elements
+
+When working with React components, you may encounter a scenario where you want to return multiple JSX elements from a function, only to be met with a syntax error.
+
+#### What's the Problem?
+
+This is due to a limitation in JavaScript, as it doesn't allow the return of adjacent elements without a common parent.
+
+Consider the following problematic code:
+
+```javascript
+function User() {
+ return <div> David Jaja</div>
+ <div>Twitter: https://twitter.com/JajaDavid8</div>;
+}
+
+```
+
+This code results in an error: “Adjacent JSX elements must be wrapped in an enclosing tag.”
+
+
+
+Error occurring when JSX returns 2 direct adjacent elements
+
+#### How to Solve it
+
+I know what you might be thinking—why not simply wrap the elements in a div and move on?
+
+
+
+Spongebob bored gif
+
+While this seems like a quick fix, it introduces a potential downside. By adding a div, you create an unnecessary parent element in the DOM.
+
+This additional markup, though resolving the immediate error, can lead to unintended consequences, such as affecting styles or layout, and may not align with optimal coding practices.
+
+And I’m sure you don’t want to end up with a "divpocalipse".
+
+
+
+A divpocalpse
+
+To overcome both the syntax error and the unnecessary DOM markup, React introduced an optimized solution: React Fragments.
+
+React Fragments are used to address the need for returning multiple JSX elements without introducing unnecessary parent elements in the DOM.
+
+Here's how you can utilize React Fragments:
+
+```javascript
+import React from "react";
+function User() {
+ return (
+ <React.Fragment>
+ <div> David Jaja</div>
+ <div>Twitter: https://twitter.com/JajaDavid8</div>
+ </React.Fragment>
+ );
+}
+
+```
+
+Or using the shorthand syntax:
+
+```javascript
+function User() {
+ return (
+ <>
+ <div> David Jaja</div>
+ <div>Twitter: https://twitter.com/JajaDavid8</div>
+ </>
+ );
+}
+
+
+```
+
+By using React Fragments, you maintain clean and concise JSX code without introducing unnecessary elements to the DOM, enhancing code readability.
+
+
+
+Showing the DOM tree after using fragments without any extra elements
+
+## Opinionated Approaches to React
+
+I've found some handy ways to make working with React more enjoyable. Instead of strict rules, think of these as my personal choices to make code easier to read, improve how it works, and make sure it stays in good shape.
+
+1. **==Put data outside components==**==: Move things like lists and groups of information outside the main part of a component when possible. This helps avoid extra updates and makes it simpler to handle data without using special functions like== `==useCallback==`==.==
+2. **==Be careful with== `==React====.====memo==`**==: Using== `==React====.====memo==` ==can help your components run better, but it's not always needed. If a component changes a lot with new information, using== `==React====.====memo==` ==might not be as helpful. Use it wisely.==
+3. **==Create your own custom React hooks==**==: I also like making my own special tools with custom React hooks. It's a bit advanced, but it helps keep my code neat and organized.==
+
+
+
+Just my opinion gif
+
+## Wrapping Up the Quirky Journey with React
+
+React's journey is a blend of smooth sailing and bumpy rides. We've seen the strength of reusable components and virtual DOM and tackled puzzling moments like missing key props and conditional rendering bugs and so on.
+
+As you continue your journey with React, may your code be clean, your components reusable, and your "What's Up with React?" moments turn into "Aha!" revelations. Happy coding! 🚀
+
+### **Contact Information**
+
+Want to connect or contact me? Feel free to hit me up on the following:
+
+* Twitter: [@jajadavid8](https://twitter.com/JajaDavid8)
+* LinkedIn: [David Jaja](https://www.linkedin.com/in/david-jaja-8084251b4/)
+* Email: Jajadavidjid@gmail.com
+
+---
+
+---
+
+ 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/)
\ No newline at end of file
diff --git a/Omnivore/2024-03-06 - How to Build a Basic CMS with Google Sheets and React.md b/Omnivore/2024-03-06 - How to Build a Basic CMS with Google Sheets and React.md
new file mode 100644
index 0000000..6c59c89
--- /dev/null
+++ b/Omnivore/2024-03-06 - How to Build a Basic CMS with Google Sheets and React.md
@@ -0,0 +1,267 @@
+---
+id: 39278362-dbfc-11ee-8a2b-139ebfa11748
+title: |
+ How to Build a Basic CMS with Google Sheets and React
+status: ARCHIVED
+tags:
+ - read-later
+ - RSS
+date_added: 2024-03-06 14:55:48
+url_omnivore: |
+ https://omnivore.app/me/how-to-build-a-basic-cms-with-google-sheets-and-react-18e158f0d8c
+url_original: |
+ https://www.freecodecamp.org/news/how-to-build-a-basic-cms-with-google-sheets-and-reactjs/
+---
+
+# How to Build a Basic CMS with Google Sheets and React
+
+## Highlights
+
+### Step 1: Set Up Your Google Sheets
+
+1. Go to your Google Sheets
+2. Open the sheet you want to use or create a new one
+3. Click on `Extensions` in the menu
+4. Then click on `Apps Script`
+
+In the Apps Script editor, you can write a script to serve as your endpoint. Here's a script that returns the contents of a Google Sheet in JSON format:
+
+```kotlin
+function convertRangeToJson(data) {
+ var jsonArray = [];
+
+ // Check if data is empty or doesn't contain enough rows for headers and at least one data row
+ if (!data || data.length < 2) {
+ // Return an empty array or a meaningful message as needed
+ return jsonArray; // or return 'No data available';
+ }
+
+ var headers = data[0];
+ for (var i = 1, length = data.length; i < length; i++) {
+ var row = data[i];
+ var record = {};
+
+ for (var j = 0; j < row.length; j++) {
+ record[headers[j]] = row[j];
+ }
+
+ jsonArray.push(record);
+ }
+
+ return jsonArray;
+}
+```
+
+Then:
+
+1. Click `File` \> `Save`, and give your project a name
+2. Click on `Deploy` \> `New deployment`.
+3. Click on `Select type` and choose `Web app`.
+4. Fill in the details for your deployment. Under `Execute as`, choose whether the script should run as your account or as the user accessing the web app. Under `Who has access`, choose who can access your web app.
+5. Click `Deploy`.
+
+[source](https://omnivore.app/me/how-to-build-a-basic-cms-with-google-sheets-and-react-18e158f0d8c#d5dee3e3-c455-4623-952d-2b11f076c3fa)
+
+---
+
+## Original
+
+
+
+In today's digital landscape, creating a content management system (CMS) that is both cost-effective and easy to maintain can be difficult, especially if you're operating on a tight budget.
+
+This tutorial will show you a solution that leverages Google Sheets as a makeshift database and React to build the frontend. This will let you effectively bypass the need for a dedicated server or traditional database system.
+
+This approach not only reduces the overhead costs associated with web development, but also simplifies content updates and management. It's an ideal solution if you're looking to launch your own simple CMS without substantial investment.
+
+This solution is suitable for freelancers at the beginning of their career and for clients who cannot invest much in their website.
+
+## Why Google Sheets?
+
+Opting for Google Sheets as the backbone of your CMS comes down to its simplicity, flexibility, and cost-effectiveness.
+
+Traditional web development requires a backend server to process data, a database to store information, and a frontend to display content. But each layer adds complexity and cost.
+
+Google Sheets, on the other hand, acts as a highly accessible and intuitive interface that eliminates the need for a server and a database. It lets your users update content in real-time, much like any CMS, but without the usual setup and maintenance costs. This makes it an excellent choice for individuals, small businesses, or anyone looking to deploy a web application quickly and with minimal expense.
+
+## Getting Started
+
+Before diving into the code, ensure you have Node.js and npm installed on your system. These tools will allow us to create a React application and manage its dependencies.
+
+Let's start with Google Sheets now.
+
+### ==Step 1: Set Up Your Google Sheets==
+
+1. ==Go to your Google Sheets==
+2. ==Open the sheet you want to use or create a new one==
+3. ==Click on== `==Extensions==` ==in the menu==
+4. ==Then click on== `==Apps== ==Script==`
+
+==In the Apps Script editor, you can write a script to serve as your endpoint. Here's a script that returns the contents of a Google Sheet in JSON format:==
+
+```kotlin
+function convertRangeToJson(data) {
+ var jsonArray = [];
+
+ // Check if data is empty or doesn't contain enough rows for headers and at least one data row
+ if (!data || data.length < 2) {
+ // Return an empty array or a meaningful message as needed
+ return jsonArray; // or return 'No data available';
+ }
+
+ var headers = data[0];
+ for (var i = 1, length = data.length; i < length; i++) {
+ var row = data[i];
+ var record = {};
+
+ for (var j = 0; j < row.length; j++) {
+ record[headers[j]] = row[j];
+ }
+
+ jsonArray.push(record);
+ }
+
+ return jsonArray;
+}
+```
+
+==Then:==
+
+1. ==Click== `==File==` ==>== `==Save==`==, and give your project a name==
+2. ==Click on== `==Deploy==` ==>== `==New== ==deployment==`==.==
+3. ==Click on== `==Select== ==type==` ==and choose== `==Web app==`==.==
+4. ==Fill in the details for your deployment. Under== `==Execute== ==as==`==, choose whether the script should run as your account or as the user accessing the web app. Under== `==Who has== ==access==`==, choose who can access your web app.==
+5. ==Click== `==Deploy==`==.==
+
+You may be asked to authorize the script to access your Google Sheets. Follow the prompts to do so.
+
+After deploying, you'll be given a URL for your web app. This is your API endpoint.
+
+To give you an idea of what you have done so far, this is your sheet structure:
+
+
+
+How your sheet should currently look
+
+And this is the JSON you get when you call the endpoint:
+
+
+
+JSON
+
+### Step 2: Create Your React App
+
+With your Google Sheets API ready, it's time to create the React app that will fetch and display this data.
+
+First, go ahead and create a React app. Run the following command in your terminal to create a new React application:
+
+```dsconfig
+npx create-react-app google-sheets-cards
+cd google-sheets-cards
+npm start
+```
+
+You can also [use modern build tools like Vite](https://www.freecodecamp.org/news/get-started-with-vite/) for this purpose, as CRA is no longer the recommended way of building a React app.
+
+Next, create the card component. Inside the `src` directory, create a file named `Card.js`. This component will be responsible for displaying each data record:
+
+```javascript
+// src/Card.js
+function Card({ title, content }) {
+ return (
+ <div className="card">
+ <h1>{title}</h1>
+ <p>{content}</p>
+ </div>
+ );
+}
+
+export default Card;
+```
+
+Now it's time to fetch and display your data in App.js. Modify the `App.js` file to include logic for fetching the data from your Google Sheets API and using the Card component to display it:
+
+```javascript
+// src/App.js
+import React, { useEffect, useState } from 'react';
+import Card from './Card';
+import './App.css'; // Make sure to create some basic styles for the cards in App.css
+
+function App() {
+ const [data, setData] = useState([]);
+
+ useEffect(() => {
+ fetch('YOUR_ENDPOINT_URL') // Replace with your actual endpoint URL
+ .then(response => response.json())
+ .then(data => setData(data))
+ .catch(error => console.error('Error fetching data:', error));
+ }, []);
+
+ return (
+ <div className="App">
+ <h1>Data from Google Sheets</h1>
+ <div className="cards-container">
+ {data.map((item, index) => (
+ <Card key={index} title={item.Title} content={item.Content} />
+ ))}
+ </div>
+ </div>
+ );
+}
+
+export default App;
+```
+
+Next, you can style your cards. Go ahead and add the below CSS in `App.css` for basic card styling:
+
+```css
+.card {
+ box-shadow: 0 4px 8px rgba(0, 0, 0, 0.2);
+ margin: 10px;
+ padding: 10px;
+ display: inline-block;
+ background: #f9f9f9;
+}
+
+.cards-container {
+ display: flex;
+ flex-wrap: wrap;
+ justify-content: center;
+}
+```
+
+### Step 3: Run Your React App
+
+With everything set up, you can now run your React application and see the data from Google Sheets displayed in your browser. To do this, follow these steps:
+
+First, start the React app. In your terminal, navigate to the root directory of your React app if you're not already there. Run the following command to start the development server:
+
+```coffeescript
+npm start
+```
+
+This command compiles your React application and opens it in your default web browser. You should see a webpage with a title "Data from Google Sheets", and below that, a series of cards, each displaying a title and content fetched from your Google Sheets data.
+
+Here's, in fact, what we get:
+
+
+
+Data from Google Sheets and Card 1, Card 2, and Card 3 displayed on the screen
+
+Now you can view your data. Each card on the page corresponds to a row in your Google Sheets, with the title and content fields displayed as specified in your Card component. If you make any updates to your Google Sheets data, you can refresh the web page to see the changes reflected immediately.
+
+You can deploy your React app to one of the many services you can find online such as Github Actions or Netlify. This is a simple and effective way to host your frontend application for free with significant performance.
+
+## Conclusion
+
+Congratulations! You've created a dynamic web application that fetches data from a Google Sheet and displays it using React.
+
+This approach offers a flexible and straightforward way to manage your application's content without needing a backend server or database.
+
+Google Sheets serves as an accessible and collaborative platform for managing data, while React allows you to build a responsive and interactive user interface. Together, they provide a powerful combination for creating web applications that can be quickly updated and easily maintained.
+
+---
+
+---
+
+ 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/)
\ No newline at end of file
diff --git a/Omnivore/2024-03-11 - How to Do a Digital Detox - Everyday Health.md b/Omnivore/2024-03-11 - How to Do a Digital Detox - Everyday Health.md
new file mode 100644
index 0000000..d9ce1dc
--- /dev/null
+++ b/Omnivore/2024-03-11 - How to Do a Digital Detox - Everyday Health.md
@@ -0,0 +1,155 @@
+---
+id: b342d646-2ec3-4e27-a72d-dac0d46219d3
+title: |
+ How to Do a Digital Detox | Everyday Health
+status: ARCHIVED
+tags:
+ - read-later
+date_added: 2024-03-11 09:49:55
+url_omnivore: |
+ https://omnivore.app/me/https-www-everydayhealth-com-emotional-health-how-to-do-a-digita-18e2d8fec8e
+url_original: |
+ https://www.everydayhealth.com/emotional-health/how-to-do-a-digital-detox-without-unplugging-completely/
+---
+
+# How to Do a Digital Detox | Everyday Health
+
+## Highlights
+
+“When something is consuming a lot of your thoughts and conditioning your behaviors, and when it is interfering with your life — like your job or schoolwork or your relationships — it may be time to consider cutting back on its use,”
+
+[source](https://omnivore.app/me/https-www-everydayhealth-com-emotional-health-how-to-do-a-digita-18e2d8fec8e#e757b03d-61d5-413d-b9b9-47019876445c)
+
+---
+
+cutting back on anything that makes you feel worse or stressed, or that takes away from your life rather than adding to it.
+
+[source](https://omnivore.app/me/https-www-everydayhealth-com-emotional-health-how-to-do-a-digita-18e2d8fec8e#07a0c2b4-39f7-43bd-a39c-9f4da9933354)
+
+---
+
+“There’s no magic amount of screen time that is good or bad,”
+
+[source](https://omnivore.app/me/https-www-everydayhealth-com-emotional-health-how-to-do-a-digita-18e2d8fec8e#0614f527-dd2d-4377-aac5-e2fce661ef85)
+
+---
+
+Set up time in your calendar or with an alarm on your phone to remind you to go for a walk or to eat lunch away from your desk, Becker says. And remember to leave your phone behind.
+
+[source](https://omnivore.app/me/https-www-everydayhealth-com-emotional-health-how-to-do-a-digita-18e2d8fec8e#81332fd1-2e6c-4292-97c1-42077bdaddd9)
+
+---
+
+“If the Facebook app is something that you click on often and find yourself scrolling through for long periods of time, getting rid of the app and having to go through the search browser takes an extra step and allows for a moment to pause and decide if it is a good time to engage in this activity,”
+
+[source](https://omnivore.app/me/https-www-everydayhealth-com-emotional-health-how-to-do-a-digita-18e2d8fec8e#3ff32057-315b-4fb7-8a34-8db8528990d8)
+
+---
+
+eliminate the distractions by replacing your smartphone with a simple cell phone that cannot support apps.
+
+[source](https://omnivore.app/me/https-www-everydayhealth-com-emotional-health-how-to-do-a-digita-18e2d8fec8e#d64ced03-c9fb-4217-abc0-090512cb6b07)
+
+---
+
+Try powering down before dinner and until the next morning.
+
+[source](https://omnivore.app/me/https-www-everydayhealth-com-emotional-health-how-to-do-a-digita-18e2d8fec8e#5cc985b9-75ac-4988-8637-c5d11336e657)
+
+---
+
+Apple iPhone users can set limits with [Screen Time](https://support.apple.com/en-us/HT208982) (find it in your phone’s settings) and schedule Downtime, when only phone calls or specific apps are allowed and specified apps have a time limit. [Digital Wellbeing](https://play.google.com/store/apps/details?id=com.google.android.apps.wellbeing&hl=en%5FUS&gl=US) works similarly for Google devices.
+
+[source](https://omnivore.app/me/https-www-everydayhealth-com-emotional-health-how-to-do-a-digita-18e2d8fec8e#8d60c80d-2d5f-410a-a901-435de882e3c6)
+
+---
+
+setting limits on certain apps doesn’t always work. Instead, she suggests removing yourself from device use completely.
+
+[source](https://omnivore.app/me/https-www-everydayhealth-com-emotional-health-how-to-do-a-digita-18e2d8fec8e#7ca00f44-692d-4435-bed2-8d742e634aed)
+
+---
+
+## Original
+
+
+
+Your phone doesn’t have to be on lockdown for you to preserve your peace of mind.Adobe Stock
+
+Life during the most connected era in human history has many positives — faraway family members are just a FaceTime session away, and the answer to nearly any question that pops into your mind is at your fingertips.
+
+But too much technology — whether it’s time spent on smartphones, social media, or in front of other digital screens — can have unintended consequences. That may signal the need for a digital [detox](https://www.everydayhealth.com/diet-and-nutrition/diet/detox-cleanses-most-popular-types-what-know/).
+
+“Excessive technology use can take away time from activities such as sleep, exercise, and socializing, which are all important for well-being,” says [Carol Vidal, MD, PhD, MPH](https://www.hopkinsmedicine.org/profiles/details/carolina-vidal), an assistant professor of psychiatry and behavioral sciences at the Johns Hopkins University School of Medicine in Baltimore.
+
+A [research review](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC7366948/) noted that frequent technology use has been linked to heightened attention-deficit symptoms, impaired emotional and social intelligence, technology addiction, social isolation, impaired brain development, and disrupted sleep in some cases.
+
+**RELATED:** [**Are the Stresses of Social Media Too Much for Teens and Young Adults?**](https://www.everydayhealth.com/emotional-health/under-pressure/are-the-stresses-of-social-media-too-much-for-teens-and-young-adults/)
+
+Technology is not inherently bad, says [Madeleine George, PhD](https://www.rti.org/expert/madeleine-george), a public health research analyst at RTI International, a nonprofit research institute, in Durham, North Carolina. “Technology and social media can have positive or negative effects, depending on what someone is doing online and who they are.”
+
+Other research suggests, for example, that social media use can help you build and maintain connections when you’re more actively interacting with others, but tends to have the opposite effect when people use it more passively, such as when scrolling through an Instagram or Facebook feed without interacting with the content, [according to research](https://journals.sagepub.com/doi/full/10.1177/0963721417730833#%5Fi5%20%5Fi6)_._
+
+You’ll know you’re overdoing it and may need a digital detox if technology interferes with your work, relationships, mental and physical health, or finances, according to [Brittany Becker](https://thedorm.com/team/brittany-becker/), a licensed mental health counselor based in New York City and the director of the Dorm, a holistic treatment center for mental health.
+
+**RELATED:** [**Are the Virtual Interactions of Social Media Busting or Boosting Your Stress?**](https://www.everydayhealth.com/wellness/united-states-of-stress/social-media-busting-boosting-your-stress/)
+
+Dr. Vidal agrees. ==“When something is consuming a lot of your thoughts and conditioning your behaviors, and when it is interfering with your life — like your job or schoolwork or your relationships — it may be time to consider cutting back on its use,”== Vidal says.
+
+Scaling back through a digital detox may have positive effects.
+
+A [study from 2021](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC7717533/) found that students who completed a social media detox reported positive changes to their mood, sleep, and anxiety. And [another study](https://pubmed.ncbi.nlm.nih.gov/31851833/) found that women who quit Instagram reported higher life satisfaction and more positive effects than women who continued using the social media app. (It should be noted that both studies were small, with 68 and 80 participants, respectively.)
+
+## **7 Ways to** Do a Digital Detox **(Without Pulling the Plug Entirely)**
+
+For most people, ditching technology altogether isn’t going to happen. “Cutting down seems like a more realistic approach,” Vidal says.
+
+To do this, make a plan, Becker says. Pinpoint your unhealthy habits and then decide which ones you want to change. “I think it is really helpful to get a clear picture of your tech use and review the time spent on your phone,” Becker says. “How that time is divided up with different applications is a great place to start, and then you can identify which areas to begin to limit.”
+
+Dr. George suggests ==cutting back on anything that makes you feel worse or stressed, or that takes away from your life rather than adding to it.== And remember, what constitutes healthy technology use varies from person to person. “There’s no magic amount of screen time that is good or bad,” George says. “You have to find out what works for you and your family.”
+
+Here are seven strategies to help you manage your technology use and experiment with your own personal digital detox.
+
+### **1\. Schedule Time Away From Screens Throughout the Day**
+
+If you work at a computer, it’s hard to avoid screens, which means it’s all the more important to prioritize breaking away. ==Set up time in your calendar or with an alarm on your phone to remind you to go for a walk or to eat lunch away from your desk, Becker says. And remember to leave your phone behind.==
+
+### **2\. Take Periodic Breaks From Technology**
+
+Breaks can reduce stress, particularly among heavy users, Vidal says. She says more research is needed on digital abstinence before there can be specific recommendations on what this looks like and how long it should last. But it could mean joining others who are committed to disconnecting through events like those run by [Digital Detox](https://www.digitaldetox.com/) (a company that leads tech-free retreats) or deleting problematic apps from your phone, temporarily or for good.
+
+==“If the Facebook app is something that you click on often and find yourself scrolling through for long periods of time, getting rid of the app and having to go through the search browser takes an extra step and allows for a moment to pause and decide if it is a good time to engage in this activity,”== Becker says.
+
+### **3\. Downgrade Your Phone**
+
+If you’re having trouble staying present, ==eliminate the distractions by replacing your smartphone with a simple cell phone that cannot support apps.== “It can absolutely be helpful to downgrade from a smartphone if that is possible,” says [Jennifer Kelman, LCSW](https://www.jenniferkelman.com/bio.html), a social worker based in Boca Raton, Florida. In fact, this is what she uses with her own children. “They have simple call or text features and that’s it,” she says.
+
+### **4\. Turn Off Your Phone at a Specific Time**
+
+==Try powering down before dinner and until the next morning.== Apple and Android users can enable do-not-disturb settings that can silence alerts, notifications, and calls. Becker says it’s a good idea to take advantage of the tools that are built into your devices.
+
+### **5\. Adjust Your Phone Settings to Limit Certain Apps**
+
+==Apple iPhone users can set limits with== ==[Screen Time](https://support.apple.com/en-us/HT208982)== ==(find it in your phone’s settings) and schedule Downtime, when only phone calls or specific apps are allowed and specified apps have a time limit.== ==[Digital Wellbeing](https://play.google.com/store/apps/details?id=com.google.android.apps.wellbeing&hl=en%5FUS&gl=US)== ==works similarly for Google devices.== People who didn’t use these features were more likely to experience problematic smartphone use and worse well-being than those who did use them, according to a [research analysis](https://pubmed.ncbi.nlm.nih.gov/32354288/)_._
+
+**RELATED:** [**How to Recognize When a Self-Care Practice Is No Longer Self-Care**](https://www.everydayhealth.com/self-care/how-to-recognize-when-a-self-care-practice-is-no-longer-self-care/)
+
+### **6\.** **Create No-Phone Areas**
+
+Kelman believes that ==setting limits on certain apps doesn’t always work. Instead, she suggests removing yourself from device use completely.== Banning phones and screens from the bedroom, for instance, can keep screens from interfering with your sleep, Becker says. And if you have to go into a different room or part of your home to use a device, it may deter you from mindlessly scrolling.
+
+### **7\. Consider Reaching Out to a Mental Health Professional**
+
+“We are all using technology constantly, and therefore it can be hard to always know the difference between having a problem or not,” Becker says. If your behaviors with or feelings regarding technology or certain apps and sites begin to interfere with your daily functioning, it may be time to seek professional help, Becker says. Kelman adds that if your self-esteem plummets or you find yourself dealing with anxiety or depression, it’s time to talk to someone.
+
+## Editorial Sources and Fact-Checking
+
+Everyday Health follows strict sourcing guidelines to ensure the accuracy of its content, outlined in our [editorial policy](https://www.everydayhealth.com/editorial-policies/). We use only trustworthy sources, including peer-reviewed studies, board-certified medical experts, patients with lived experience, and information from top institutions.
+
+#### Resources
+
+* Small GW, Lee J, Kaufman A, et al. Brain Health Consequences of Digital Technology Use. [_Dialogues in Clinical Neuroscience_](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC7366948/). June 2020.
+* Clark JL, Algoe SB, Green MC. Social Network Sites and Well-Being: The Role of Social Connection. [_Current Directions in Psychological Science_](https://journals.sagepub.com/doi/full/10.1177/0963721417730833#%5Fi5%20%5Fi6). February 2018.
+* El-Khoury J, Haidar R, Kanj RR, et al. Characteristics of Social Media ‘Detoxification’ in University Students. [_Libyan Journal of Medicine_](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC7717533/). December 2021.
+* Fioravanti G, Prostamo A, Casale S. Taking a Short Break From Instagram: The Effects on Subjective Well-Being. [_Cyberpsychology, Behavior, and Social Networking_](https://pubmed.ncbi.nlm.nih.gov/31851833/). February 2020.
+* Schmuck D. Does Digital Detox Work? Exploring the Role of Digital Detox Applications for Problematic Smartphone Use and Well-Being of Young Adults Using Multigroup Analysis. [_Cyberpsychology, Behavior, and Social Networking_](https://pubmed.ncbi.nlm.nih.gov/32354288/). August 2020.
\ No newline at end of file
diff --git a/Omnivore/2024-03-22 - How to Create a Great Personal Portfolio Page – a Handbook for Beginners.md b/Omnivore/2024-03-22 - How to Create a Great Personal Portfolio Page – a Handbook for Beginners.md
new file mode 100644
index 0000000..216dd28
--- /dev/null
+++ b/Omnivore/2024-03-22 - How to Create a Great Personal Portfolio Page – a Handbook for Beginners.md
@@ -0,0 +1,937 @@
+---
+id: 63939b9e-e8f0-11ee-8320-63f36465eb6d
+title: |
+ How to Create a Great Personal Portfolio Page – a Handbook for Beginners
+status: ARCHIVED
+tags:
+ - read-later
+ - RSS
+date_added: 2024-03-22 18:40:39
+url_omnivore: |
+ https://omnivore.app/me/how-to-create-a-great-personal-portfolio-page-a-handbook-for-beg-18e6a73ea11
+url_original: |
+ https://www.freecodecamp.org/news/how-to-create-a-great-personal-portfolio-page-a-step-by-step-guide/
+---
+
+# How to Create a Great Personal Portfolio Page – a Handbook for Beginners
+
+## Highlights
+
+### Tips for Choosing the Perfect Domain Name
+
+* **Keep It Simple**: Opt for a domain name that is easy to remember and type.
+* **Include Keywords**: If possible, incorporate relevant keywords related to your industry or profession.
+* **Consider Your Niche**: Ensure your domain name aligns with the type of work showcased on your portfolio.
+* **Avoid Numbers and Hyphens**: Numbers and hyphens can be confusing and are often forgotten when typing a domain name.
+* **Check Availability**: Verify that the domain name you want is not already taken and is available for purchase. You can use [namecheap.com](https://www.namecheap.com/), [godaddy.com](https://www.godaddy.com/nl-nl) and many other online hosting websites.
+
+[source](https://omnivore.app/me/how-to-create-a-great-personal-portfolio-page-a-handbook-for-beg-18e6a73ea11#1c688bb9-5b3e-41e4-8529-5902e0533fb7)
+
+---
+
+**Research Design Options**: Explore various design templates on platforms like Envato, ThemeForest, and Figma. These resources offer a wide array of designs suited to different professions, aiding in finding one that matches your vision.
+
+[source](https://omnivore.app/me/how-to-create-a-great-personal-portfolio-page-a-handbook-for-beg-18e6a73ea11#596a42c0-8fce-4a08-9a50-1278c860e160)
+
+---
+
+Showcase any recognitions, certifications, or contributions to open-source projects.
+
+[source](https://omnivore.app/me/how-to-create-a-great-personal-portfolio-page-a-handbook-for-beg-18e6a73ea11#478f7449-f350-4fab-8b67-cc05ad413267)
+
+---
+
+#### For Developers Seeking Employment
+
+If your primary goal is to attract potential employers, your portfolio needs to emphasize your technical skills, projects, and the professional value you bring. Here's how to tailor your site:
+
+* **Highlight Relevant Projects**: Showcase a selection of projects that are most relevant to the types of roles you're seeking. Include detailed case studies that walk through your problem-solving process, technologies used, and the outcomes achieved.
+* **Professional Narrative**: Use the "About Me" section to narrate your professional journey, emphasizing experiences and skills that align with your career aspirations. Mention any collaborative projects to demonstrate teamwork and communication skills.
+* **Testimonials from Colleagues**: Including endorsements from past colleagues, supervisors, or collaborators can add credibility and provide insight into your working style and contributions to a team.
+* **Technical Blog**: If you maintain a blog, focus on posts that highlight your expertise, insights into technology trends, and solutions to common problems in your field. This not only showcases your knowledge but also your ability to communicate complex ideas clearly.
+
+[source](https://omnivore.app/me/how-to-create-a-great-personal-portfolio-page-a-handbook-for-beg-18e6a73ea11#3549ac1f-0104-40fd-8981-85cce3d04184)
+
+---
+
+The tone of your brand voice can vary depending on the context and the platform, but it should always reflect your brand's personality.
+
+Whether it's confident and authoritative, friendly and conversational, or inspirational and aspirational, the tone should be consistent across all channels to maintain brand recognition and loyalty.
+
+[source](https://omnivore.app/me/how-to-create-a-great-personal-portfolio-page-a-handbook-for-beg-18e6a73ea11#12b06926-57b3-41b5-9e1b-492f82c163fe)
+
+---
+
+Incorporate feedback from previous clients or colleagues to highlight your skills and professionalism. Testimonials lend authenticity and foster trust in your portfolio.
+
+[source](https://omnivore.app/me/how-to-create-a-great-personal-portfolio-page-a-handbook-for-beg-18e6a73ea11#75d7bf6c-2a2a-44fb-a958-0c595a4a77ca)
+
+---
+
+Showcase your standout projects with comprehensive case studies. These narratives offer a deep dive into your creative process, problem-solving abilities, and the impact of your work.
+
+[source](https://omnivore.app/me/how-to-create-a-great-personal-portfolio-page-a-handbook-for-beg-18e6a73ea11#efeda449-8965-46a0-8884-c9fadb8f0f07)
+
+---
+
+A blog section can serve as a platform for sharing your expertise, industry insights, or personal reflections. It reflects your dedication to your craft and ensures your site remains vibrant with new content.
+
+[source](https://omnivore.app/me/how-to-create-a-great-personal-portfolio-page-a-handbook-for-beg-18e6a73ea11#c2a0e123-fd91-4e08-8509-55877613c299)
+
+---
+
+Offer a look into your creative journey through behind-the-scenes content like sketches, mood boards, or early designs. This transparency into your process can fascinate visitors and add depth to your work presentation.
+
+[source](https://omnivore.app/me/how-to-create-a-great-personal-portfolio-page-a-handbook-for-beg-18e6a73ea11#65a1c40b-4c6b-4d07-b581-5e8335064bf4)
+
+---
+
+Highlight any accolades or recognitions you've received. Showcasing your achievements adds prestige to your portfolio and distinguishes you from your peers.
+
+[source](https://omnivore.app/me/how-to-create-a-great-personal-portfolio-page-a-handbook-for-beg-18e6a73ea11#9a595a7c-8027-497f-89e5-f02166883e35)
+
+---
+
+For those whose work involves data, adding infographics or visualizations can compellingly present complex information. This not only showcases your ability to simplify intricate data but also your creative approach to visual communication.
+
+[source](https://omnivore.app/me/how-to-create-a-great-personal-portfolio-page-a-handbook-for-beg-18e6a73ea11#f421ea17-4988-4bf0-a817-18d653f3beae)
+
+---
+
+### Home Page: The Gateway to Your Professional Universe
+
+The home page serves as the initial welcome to your professional domain, providing a brief yet impactful overview of your identity and offerings. This first impression is vital, setting the tone for the visitor's experience on your site.
+
+
+
+My home page
+
+Your home page should emphasize:
+
+* **Engaging Introduction**: Introduce yourself with a quick mention of your professional designation and expertise.
+* **Visual Elements**: Incorporate captivating visuals or a portfolio reel to immediately draw attention to your work.
+* **Navigation Tips**: Direct visitors smoothly to different site sections with clear navigation aids.
+
+[source](https://omnivore.app/me/how-to-create-a-great-personal-portfolio-page-a-handbook-for-beg-18e6a73ea11#4b08a99c-131f-4d34-b7ff-fb992c2851ad)
+
+---
+
+### Portfolio Section: A Display of Your Expertise
+
+This core section is where you showcase your finest work. Organizing this area thoughtfully ensures that visitors can easily navigate through your projects. You should include:
+
+* **Organization by Category**: Group projects by theme, type, or sector for straightforward browsing.
+
+
+
+Projects organized by category on my personal portfolio page - Python, Statistics, Machine Learning, and NLP
+
+* **Project Summaries**: Provide a concise description of each project, outlining your role, the methodology, and the results.
+
+
+
+Example project summary on my portfolio
+
+* **High-Resolution Media**: Present your work with high-quality images or videos to fully convey its quality.
+
+
+
+[source](https://omnivore.app/me/how-to-create-a-great-personal-portfolio-page-a-handbook-for-beg-18e6a73ea11#50fc8ae9-03ea-4158-b0e9-9ab7baa63555)
+
+---
+
+### About Me Page: Your Professional Narrative
+
+This page allows you to forge a deeper connection with your audience by sharing your story, ambitions, and what makes you unique. It should cover:
+
+* **Professional Background**: Share your career path, educational achievements, and significant milestones.
+
+
+
+Some of my personal milestones
+
+* **Skills and Expertise**: Spotlight the abilities that distinguish you in your field.
+
+
+
+A page on my portfolio showing my "digital DNA" - the skills I'd like to showcase
+
+* **Personal Insights**: Offering a peek into your personal hobbies or interests can make you more approachable and relatable.
+
+[source](https://omnivore.app/me/how-to-create-a-great-personal-portfolio-page-a-handbook-for-beg-18e6a73ea11#26922385-6eda-4cc1-9885-70a965d69303)
+
+---
+
+### Contact Information: Simplifying Communication
+
+For potential collaborations, it’s essential to make reaching out as simple as possible. Your contact page should include:
+
+* **Various Contact Methods**: Provide a contact form, email, and possibly a phone number for easy communication.
+
+
+
+My contact information page on my personal portfolio site
+
+* **Social Media Profiles**: Guide visitors to your professional social media pages.
+* **Geographic Details**: If applicable, mention your location or time zone.
+
+[source](https://omnivore.app/me/how-to-create-a-great-personal-portfolio-page-a-handbook-for-beg-18e6a73ea11#82e27144-7f5b-4906-ba60-cd5b785a3797)
+
+---
+
+### Do's for a Captivating Homepage
+
+* **Be Concise**: Ensure your message is clear and to the point.
+* **Use Endorsement Logos**: Incorporate logos of companies you've appeared on to build trust.
+* **Display Technical Stack Logos**: Show the technologies you're proficient in using their logos.
+* **Showcase a Case Study Gallery**: Highlight your best work in an easily navigable gallery.
+* **Include a Dynamic Header**: Use an engaging hero section to make a strong first impression.
+* **Highlight Recent Work**: Give visitors a glimpse of your latest projects to show you're active and relevant.
+* **Use Testimonials Strategically**: Place client testimonials where they'll have the most impact, showcasing your reliability and skill.
+
+### Don'ts for Your Homepage
+
+* **Avoid Random Placement**: Structure your content logically – don't place information haphazardly.
+* **Steer Clear of Long Paragraphs**: Keep your homepage breezy and easy to read with short, impactful statements.
+* **Don't Overwhelm with Content**: Your homepage isn't the place to squeeze in every detail of your portfolio.
+* **Avoid Image Neglect**: Images are crucial for visual engagement, so don't omit them.
+* **Resist Clutter**: Keep the design clean and focused to improve user experience.
+* **Avoid Technical Jargon**: Use language that's accessible to all visitors, not just industry insiders.
+* **Skip the Hard Sell**: Present your skills and achievements without being overly aggressive.
+
+[source](https://omnivore.app/me/how-to-create-a-great-personal-portfolio-page-a-handbook-for-beg-18e6a73ea11#111959c1-8fee-47cb-a0e6-9088462bf6ac)
+
+---
+
+## Original
+
+
+
+As a developer, you'll want to create a digital space that mirrors your unique skills and persona. And a stellar personal portfolio website can help you make your mark in the digital universe.
+
+Imagine a space that not only highlights your finest achievements but also attracts potential clients and makes a memorable impact on every visitor.
+
+This guide will help you navigate creating an outstanding personal portfolio. We'll dissect the process from choosing an eye-catching layout to crafting content that tells your story. It'll all be aimed at building a page that resonates with who you are and the value you bring.
+
+But the journey doesn't end here. Diving deeper, you'll learn more strategies and insights to help you elevate your portfolio beyond the ordinary. Are you ready? Let's step into the realm of crafting a portfolio that's not just seen but remembered.
+
+## Table Of Contents
+
+1. [The Importance of a Personal Portfolio Website](#why-is-a-personal-portfolio-website-important)
+2. [How to Choose the Right Domain Name](#how-to-choose-the-right-domain-name)
+3. [How to Design Your Portfolio Site](#how-to-design-your-portfolio-site)
+4. [How to Pick the Right Tools](#how-to-pick-the-right-tools)
+5. [How to Showcase Your Best Work](#how-to-showcase-your-best-work)
+6. [How to Craft Your Brand Story and Unique Voice](#how-to-craft-your-brand-story-and-unique-voice)
+7. [How to Add Additional Content](#how-to-add-additional-content)
+8. [Essential Pages for Your Portfolio](#what-pages-you-need-in-your-portfolio)
+9. [How to Organize the Home Page](#how-to-organize-the-home-page)
+10. [How to Keep Your Portfolio Fresh](#how-to-keep-your-portfolio-fresh)
+11. [Conclusion](#11-conclusion)
+
+### Short Summary
+
+1. Building a great personal portfolio page is crucial for showcasing your skills and personality in the digital realm.
+2. This step-by-step guide will help you overcome common challenges like starting, structuring, and designing your portfolio effectively.
+3. Learn how to choose the right domain, design your site, showcase your best work, and craft a unique voice to make a lasting impression.
+4. Discover the essential elements, additional content options, social media strategies, and SEO techniques to maximize your portfolio's impact.
+
+
+
+Set against Doha's futuristic skyline, this image symbolizes the critical role of a personal portfolio in distinguishing yourself in the tech landscape - [lunartech.ai](https://lunartech.ai/)
+
+## Why is a Personal Portfolio Website Important?
+
+Your portfolio, much like a shop's facade or what you wear, communicates your personal style and standards, offering a reflection of your professional identity.
+
+The structure of your website, the projects you spotlight, and the narrative you weave about your journey play a pivotal role in this representation.
+
+While some have navigated their way to impressive careers without a digital footprint, these days it's become more and more important to have a solid personal portfolio. This is particularly true for tech professionals—ranging from software engineers to data scientists and AI experts.
+
+This digital domain gives you a place to show what sets you apart, embodying the core of your unique value proposition. Without this platform, you leave your professional narrative to chance, permitting others to assemble a fragmented view of your persona.
+
+Not having an online personal portfolio could well dictate whether you secure your dream position and successfully establish a strong personal brand, versus fading into the background. In the digital-first era we navigate, a personal portfolio transcends mere benefit—it emerges as an [essential instrument for personal branding](https://www.freecodecamp.org/news/personal-branding-for-devs-handbook/).
+
+### How a Personal Portfolio Helps You
+
+For engineers seeking to carve out a distinctive identity in the tech landscape, the quest to showcase what makes you unique is paramount. While GitHub serves as a testament to your technical abilities, it often speaks a language too specialized for a broader audience.
+
+Similarly, YouTube offers a platform for personality-driven exposure, but the prospect of speaking to a camera for hours may not align with your preferred mode of expression. Herein lies the unparalleled value of a personal portfolio page: it stands as one of the most effective mediums to represent yourself.
+
+When you're creating your personal portfolio, it's crucial to demonstrate your expertise and establish your credibility. This demands clear and concise communication, directly engaging potential clients or employers, showcasing your skills, and fostering an online presence.
+
+These are not mere suggestions but critical measures for contemporary professionals. By crafting a portfolio that not only displays your work but propels your career forward, you assert a distinctive presence in the competitive realm of technology, ensuring your unique contributions are both seen and valued.
+
+
+
+Choose the Right Domain Name - [lunartech.ai](https://lunartech.ai/)
+
+## How to Choose the Right Domain Name
+
+When setting up your personal portfolio website, selecting the perfect domain name is a crucial decision that can impact your online presence significantly.
+
+Your domain name is essentially your online identity, so it's important to choose wisely to make a lasting impression on your visitors and potential clients.
+
+
+
+Choosing my domain name - vaheaslanyan.com
+
+For my personal portfolio page, I like to keep it simple: firstname+lastname.com or just firstname.com. So for me it is: [vaheaslanyan.com](http://vaheaslanyan.com/). (My firstname + lastname.com)
+
+### Other examples are
+
+1. **JohnDoe.com**: This is the most direct approach, using both your first and last name. It's professional and clear for anyone looking for your work.
+2. **AlexJohnson.dev**: For those in the tech industry, using a domain extension like .dev can highlight your area of expertise.
+3. **MichaelRoberts.design**: Similar to the .dev extension, using .design can be a great choice for professionals in fields like graphic design, UX/UI, or related areas.
+4. **Elena.co**: If your first name is unique enough, or if you prefer a shorter URL, you might use just your first name with a less common extension like .co.
+5. **MaxCreates.com**: If "Max" is your nickname and you're in a creative industry, this domain clearly indicates what you do and who you are.
+
+
+
+My name coming up in Google search results
+
+### Importance of a Domain Name
+
+Your domain name is the first thing users see when they land on your website, so it should be memorable, easy to spell, and reflect your brand identity.
+
+Here's why it's critical:
+
+* **It Reflects Your Brand**: A well-chosen domain name can effectively convey your unique voice and what you have to offer. If it is your project portfolio website, then something that reflects your name or nickname is a great way to accomplish this.
+* **It Improves Search Engine Ranking**: Having relevant keywords in your domain name can positively impact your website's SEO.
+* **It Attracts Potential Clients**: A professional and catchy domain name can pique the interest of potential clients and make your website stand out.
+
+### ==Tips for Choosing the Perfect Domain Name==
+
+* **==Keep It Simple==**==: Opt for a domain name that is easy to remember and type.==
+* **==Include Keywords==**==: If possible, incorporate relevant keywords related to your industry or profession.==
+* **==Consider Your Niche==**==: Ensure your domain name aligns with the type of work showcased on your portfolio.==
+* **==Avoid Numbers and Hyphens==**==: Numbers and hyphens can be confusing and are often forgotten when typing a domain name.==
+* **==Check Availability==**==: Verify that the domain name you want is not already taken and is available for purchase. You can use== ==[namecheap.com](https://www.namecheap.com/)====,== ==[godaddy.com](https://www.godaddy.com/nl-nl)== ==and many other online hosting websites.==
+
+
+
+Here's a visual representation capturing a web designer in their workspace -[ lunartech.ai](https://lunartech.ai/)
+
+## How to Design Your Portfolio Site
+
+When selecting a design for your portfolio website, it’s important that the theme reflects your professional brand. For example, lawyers typically want a theme that suggests reliability and authority, while educators might choose a Learning Management System (LMS) to share courses.
+
+To find the right design, websites like Envato, ThemeForest, and Figma templates are useful. It's helpful to plan what you want on each page before deciding on a design.
+
+Here's how to approach this process:
+
+**Understand Your Brand**: First, define what your brand represents and the impression you want to make. Whether your style is modern and sleek or more traditional and professional, your website's design should align with this.
+
+
+
+My personal portfolio homepage
+
+**==Research Design Options==**==: Explore various design templates on platforms like Envato, ThemeForest, and Figma. These resources offer a wide array of designs suited to different professions, aiding in finding one that matches your vision.==
+
+
+
+Different site design options
+
+**Functionality and Features Needs**: Consider the features essential for showcasing your work effectively. For a digital artist, high-resolution galleries might be key, while a developer might need support for embedding code snippets.
+
+
+
+Press releases on my site
+
+**Sketch Your Layouts**: Draft a basic layout for each page of your website before committing to a design. This helps visualize how the design will accommodate your content.
+
+
+
+Example wireframes for creating a personal portfolio
+
+**Prioritize Simplicity and User Experience**: A design that's easy to navigate and not overly complicated will keep the focus on your portfolio and provide a better experience for your visitors.
+
+
+
+An example of a simple website design
+
+**Ensure Compatibility and Responsiveness**: The design should look good and function well across all devices and browsers. Responsiveness ensures your website adapts to any screen size.
+
+
+
+An example of a responsive site that looks good on both desktop and mobile
+
+**Customization Flexibility**: Look for a design that offers customization. Being able to adjust elements like colors, fonts, and layout means you can tailor the design to fit your brand perfectly.
+
+
+
+An example of a flexible design
+
+**Test and Gather Feedback**: If possible, test the design with some of your content and ask for feedback from colleagues or mentors. Their insights can help you gauge the design's effectiveness in presenting your work.
+
+By carefully choosing a design that represents your professional brand, you create a strong foundation for a portfolio website that effectively showcases your skills and communicates your unique value to visitors.
+
+
+
+Here's the visual representation capturing a tech professional in their early morning coding session - [lunartech.ai](https://lunartech.ai/)
+
+Choosing the right tools to build your portfolio involves understanding your needs, evaluating available options, and selecting solutions that align with your skills and goals.
+
+This chapter guides you through this process, from deciding between coding your own site vs using a no-code platform to selecting the perfect hosting provider.
+
+### Understand Your Needs
+
+First, it's important to identify your field: are you in the tech industry, or are you in some other line of work?
+
+Your field of work significantly influences your choice of portfolio tools. Tech professionals might lean towards custom-coded sites to showcase their coding prowess, while those in non-tech fields may prefer no-code builders for their convenience and ease of use.
+
+Next, you'll want to evaluate your skills to decide how to actually create the site. Do you want to code your own portfolio, or choose a no-code solution?
+
+Assess your skills honestly. If you're comfortable with coding, a custom-built site might be the best way to showcase your technical abilities. For those without coding skills or a desire to learn, no-code platforms offer a practical and efficient alternative.
+
+Then you'll want to set your website goals and objectives. Define what you want your portfolio to achieve. Are you looking to attract freelance clients, land a full-time job, or simply showcase your work? Your goals can influence the choice of platform, design, and content of your portfolio.
+
+### Options for Tech Professionals
+
+Coding your own portfolio from scratch offers complete control over design and functionality, allowing you to create a unique and personalized online presence. It also showcases what you can do with code.
+
+#### Benefits of Custom Coding
+
+* Customization: Tailor every aspect of your site to fit your personal brand.
+* Skill Demonstration: Showcase your coding ability to potential employers or clients.
+
+#### Recommended Technologies and Frameworks
+
+* **HTML, CSS, and JavaScript Basics**: The foundation of web development, essential for any custom-built portfolio.
+* **Advanced Frameworks**: Utilize React, Angular, or Vue to create dynamic and responsive sites.
+
+#### Hosting Solutions for Coders
+
+* **GitHub Pages**: A free option for hosting simple, static sites.
+* **Netlify and Vercel**: Provide more flexibility and support for dynamic sites built with advanced frameworks.
+
+### No-Code Solutions for Non-Tech Professionals
+
+No-code platforms have democratized web design, enabling anyone to create beautiful, functional websites without writing a single line of code.
+
+#### Comparing Popular No-Code Platforms
+
+* **WordPress**: Versatile and widely used, with extensive themes and plugins.
+* **Webflow**: Offers unparalleled customization and flexibility without requiring coding knowledge.
+* **Squarespace**: Known for its ease of use and stunning, design-forward templates.
+
+### How to Choose the Right Hosting Option
+
+Your hosting provider impacts your site's loading speed, uptime, and overall user experience, making it a crucial factor in your portfolio's success.
+
+#### Some Common Hosting Providers
+
+* **Namecheap**: Offers affordable, reliable hosting with excellent customer support.
+* **Alternative Options**: Explore other reputable providers like Bluehost and SiteGround based on your specific needs.
+
+Choosing the right tools for your personal portfolio requires a thoughtful evaluation of your needs, skills, and goals. Whether through custom coding or no-code platforms, the perfect portfolio is within reach.
+
+By carefully selecting the right tools and platforms, you can create a portfolio that not only showcases your work but also helps you achieve your career aspirations.
+
+
+
+Here's a visual representation capturing a software engineer as they organize their portfolio - [lunartech.ai](https://lunartech.ai/)
+
+## How to Showcase Your Best Work
+
+When setting up your portfolio page, it's essential to showcase projects that reflect your current focus in software engineering, data science, AI, or whatever area of tech you call home.
+
+Select projects that are recent and demonstrate your skills and interests in these areas, ensuring your portfolio aligns with the professional direction you're aiming for.
+
+### Categorize Your Projects
+
+Divide your projects into categories like software development, data analysis, or artificial intelligence to help visitors navigate your portfolio more easily.
+
+
+
+The project section on my personal portfolio site with clear sections for different topics
+
+This organization allows you to display a broad skill set, making it clear you're well-versed in multiple aspects of tech. It also helps visitors quickly find projects that align with their specific interests or needs.
+
+### Provide Detailed Project Descriptions
+
+For each project, write a brief description that outlines the project's goals, your role in its development, and the technology used. Highlight any unique challenges you encountered and how you overcame them, showcasing your problem-solving skills.
+
+
+
+Example of some project descriptions listing the challenge, goal, technologies used, etc.
+
+These descriptions give context to your work and help visitors understand the depth of your technical expertise and creativity.
+
+### Use High-Quality Visuals and Code Snippets
+
+Incorporate clear screenshots of your projects or UI designs, and consider including code snippets to illustrate the quality of your coding practices.
+
+
+
+A high quality visual
+
+Visuals help convey the complexity and functionality of your projects, while code snippets can give fellow tech professionals insight into your technical approach. Together, they provide a comprehensive view of your capabilities.
+
+### Include Client or Collaborator Testimonials
+
+Testimonials from clients, colleagues, or collaborators can add credibility to your portfolio. Positive feedback on your technical skills, work ethic, and ability to deliver solutions can significantly enhance your professional image.
+
+
+
+Examples from my testimonials page
+
+These testimonials act as a form of social proof, validating your expertise in your field.
+
+### Highlight Achievements and Contributions
+
+==Showcase any recognitions, certifications, or contributions to open-source projects.==
+
+For example, if you've received a "Developer of the Month" award from a well-known tech community, obtained a certification in Advanced Machine Learning from a reputable online platform, or contributed to open-source projects on GitHub like TensorFlow or Apache Spark, make sure these are prominently featured.
+
+
+
+Some of my own milestones throughout my career
+
+Highlighting such achievements, like winning a hackathon or being part of a team that developed a widely used software tool, showcases your commitment and active engagement in the tech community.
+
+It also positions you as a dedicated and accomplished professional, underlining your contributions and achievements within the fields of software engineering, data science, and AI.
+
+### Feature Interactive Demos
+
+Where possible, include interactive demos of your projects or links to live sites where visitors can see your work in action. This not only makes your portfolio more engaging but also lets visitors experience the usability and functionality of your creations firsthand.
+
+Interactive demos can be particularly compelling for projects in AI and data science, where results and data visualizations play a crucial role.
+
+To effectively include interactive demos or links to live sites in your portfolio, consider these approaches:
+
+1. **Embed Project Videos**: Create short video demonstrations of your projects and embed them directly into your portfolio. These videos can guide viewers through the functionality and features of your creations, providing a dynamic way to showcase your work.
+2. **Use GitHub Pages**: For software engineering projects, deploy your web applications or tools on [GitHub Pages](https://pages.github.com/), providing a direct link in your portfolio. This free hosting service allows you to present live versions of your projects, making them accessible to anyone.
+3. **Interactive Data Visualization Tools**: For data science projects, utilize tools like [Tableau Public](https://public.tableau.com/app/discover) or [D3.js](https://d3js.org/) to create interactive visualizations of your data analyses. Embed these visualizations in your portfolio to let visitors interact with the data, understand your analytical skills, and appreciate the insights you've uncovered.
+4. **Host on Cloud Platforms**: Use cloud platforms like [Heroku](https://www.heroku.com/) or [Netlify](https://www.netlify.com/) to deploy your projects and include the live links in your portfolio. These platforms support a wide range of programming languages and frameworks, making them suitable for showcasing both frontend and backend projects.
+5. **Demo Notebooks for AI Models**: Share Jupyter notebooks via platforms like GitHub or NBViewer that demonstrate the workings of your AI models. These notebooks can include code, visualizations, and explanations, offering a comprehensive view of your project's development process and results.
+6. **Create an Interactive Portfolio Section**: Design a specific area of your portfolio dedicated to interactive demos. This section can include thumbnails or icons representing each project, which visitors can click on to explore the demo or live site.
+7. **Use Code Sandboxes**: For smaller projects or code snippets, use online code editors like [CodePen](https://codepen.io/) or [JSFiddle](https://jsfiddle.net/) to create live previews. These platforms allow you to write HTML, CSS, and JavaScript in the browser and share interactive versions of your work.
+
+By incorporating these methods, you can make your portfolio more engaging and provide potential employers or clients with a hands-on understanding of your projects' usability, functionality, and the innovative solutions you bring to the table in software engineering, data science, and AI.
+
+### Regularly Update Your Portfolio
+
+Keep adding new projects and updating your portfolio to reflect your latest work and ongoing learning in the tech field. This demonstrates your commitment to staying current with technological advancements and your continuous professional development. An up-to-date portfolio shows you're actively involved in your field and passionate about your work.
+
+By tailoring your portfolio with these considerations in mind, you ensure it effectively showcases your expertise in software engineering, data science, and AI. This approach not only highlights your technical skills but also your adaptability and ongoing growth in these rapidly evolving fields.
+
+
+
+A marketing team brainstorming session - [lunartech.ai](https://lunartech.ai/)
+
+## **How to Craft Your Brand Story and Unique Voice**
+
+Crafting your brand's voice is a vital aspect of the brand's identity, serving as the embodiment of its personality across all forms of communication. A well-defined brand voice not only distinguishes a brand in a crowded market but also establishes a consistent and relatable presence that resonates with its target audience.
+
+This chapter delves into the intricate process of sculpting your brand's unique voice and narrative, ensuring it aligns with its core values, mission, and the expectations of its audience.
+
+### **Understanding Your Brand's Core**
+
+The journey to crafting your brand's voice begins with a deep dive into its essence. This involves clarifying your brand's mission, values, and the unique proposition it offers to its audience.
+
+A brand voice that is in harmony with these core aspects will not only be authentic but also compelling to your target audience.
+
+### **Identify Your Audience**
+
+Understanding and identifying your target audience as a developer is pivotal to creating a personal portfolio website that resonates with the right people, whether they are potential employers, clients, students for your courses, or collaborators. Here's how to refine your approach based on who you're speaking to most often:
+
+#### For Educators and Course Creators
+
+If analytics or feedback suggests that a significant portion of your visitors (like the 90% in the example) are potential students interested in your courses, your portfolio should position you as a subject matter expert and a capable educator. Here's how:
+
+* **Showcase Educational Content**: Highlight courses you've created, workshops you've conducted, and any educational materials you offer. Use clear, engaging descriptions and include student testimonials to underscore the value of your courses.
+* **Demonstrate Expertise**: Include a detailed "About Me" section that outlines your credentials, experience, and any awards or recognitions you've received in your field. This helps build trust and establish your authority.
+* **Provide Free Resources**: Offering free tutorials, blog posts, or downloadable resources can be a great way to showcase your knowledge and teaching style, encouraging visitors to engage with your paid courses.
+* **Engage with Interactive Demos**: Use interactive elements or demos related to your courses to engage visitors and give them a taste of what you offer, making your site and courses more memorable.
+
+#### ==For Developers Seeking Employment==
+
+==If your primary goal is to attract potential employers, your portfolio needs to emphasize your technical skills, projects, and the professional value you bring. Here's how to tailor your site:==
+
+* **==Highlight Relevant Projects==**==: Showcase a selection of projects that are most relevant to the types of roles you're seeking. Include detailed case studies that walk through your problem-solving process, technologies used, and the outcomes achieved.==
+* **==Professional Narrative==**==: Use the "About Me" section to narrate your professional journey, emphasizing experiences and skills that align with your career aspirations. Mention any collaborative projects to demonstrate teamwork and communication skills.==
+* **==Testimonials from Colleagues==**==: Including endorsements from past colleagues, supervisors, or collaborators can add credibility and provide insight into your working style and contributions to a team.==
+* **==Technical Blog==**==: If you maintain a blog, focus on posts that highlight your expertise, insights into technology trends, and solutions to common problems in your field. This not only showcases your knowledge but also your ability to communicate complex ideas clearly.==
+
+### General Tips for Identifying Your Audience
+
+* **Survey Your Visitors**: Simple surveys or feedback forms on your website can provide direct insights into who your visitors are and what they're looking for.
+* **Analyze Website Analytics**: Use tools like Google Analytics to understand the demographics, interests, and behavior of your site's visitors. Look for patterns in the pages visited, the content engaged with, and the referral sources.
+* **Social Media Insights**: If you use social media to share your work or insights, platforms like Twitter, LinkedIn, and Instagram provide analytics that can help you understand your followers' profiles and preferences.
+* **Competitor Analysis**: Look at the portfolios of peers in your field. Notice who their target audience seems to be and how they engage with them. This can offer clues about your own audience.
+
+Identifying and understanding your target audience allows you to craft a portfolio that speaks directly to their needs and interests. Whether you're teaching, seeking employment, or offering freelance services, a focused approach ensures that your portfolio resonates with the right people, making it a powerful tool in achieving your professional goals.
+
+### **Craft Your Brand Narrative**
+
+Once you have a clear understanding of your brand's core and its audience, the next step is to weave your brand narrative.
+
+This narrative should tell the story of your brand—where it comes from, what it stands for, and where it is headed.
+
+The narrative becomes the foundation upon which your brand voice is built, ensuring that every message you convey is coherent and aligned with your brand's story.
+
+### **Be Aware of the Tone of Your Voice**
+
+==The tone of your brand voice can vary depending on the context and the platform, but it should always reflect your brand's personality.==
+
+==Whether it's confident and authoritative, friendly and conversational, or inspirational and aspirational, the tone should be consistent across all channels to maintain brand recognition and loyalty.==
+
+### **Consistency Is Key**
+
+Maintaining consistency in your brand voice across all platforms and touchpoints is crucial. This consistency helps in building trust and credibility with your audience. It ensures that no matter where or how your audience encounters your brand, they receive the same experience and message.
+
+### **Evolve Your Voice**
+
+While consistency is essential, it's also important to allow your brand voice to evolve with your audience and the market. Stay open to feedback and be willing to adjust your voice as needed to ensure it remains relevant and engaging to your audience.
+
+Crafting your brand story and unique voice is not a one-time effort but an ongoing process of refinement and evolution.
+
+By staying true to your brand's core, understanding your audience, and being consistent yet flexible in your approach, you can create a brand voice that not only defines your brand's identity but also builds lasting connections with your audience.
+
+
+
+A web designer enhancing their portfolio website with a variety of content to showcase their capabilities - [lunartech.ai](https://lunartech.ai/)
+
+## How to Add Additional Content
+
+Enhancing your personal portfolio website with a variety of content not only enriches the visitor's experience but also showcases the breadth of your capabilities. Here are some key additions that can transform your site:
+
+### Client Testimonials and Peer Reviews
+
+==Incorporate feedback from previous clients or colleagues to highlight your skills and professionalism. Testimonials lend authenticity and foster trust in your portfolio.==
+
+**Example:** a section titled "What People Are Saying" can feature a carousel of quotes from past clients, such as: "Alex transformed our brand's vision into reality with exceptional design and attention to detail. Working with them was a game-changer!" – Jamie, Brand Manager
+
+### Detailed Case Studies
+
+==Showcase your standout projects with comprehensive case studies. These narratives offer a deep dive into your creative process, problem-solving abilities, and the impact of your work.==
+
+**Example:** a page dedicated to a rebranding project for a local café, including the challenge ("Revitalizing a beloved local brand"), the process (from initial sketches to final design choices), and the impact (increased customer engagement and sales).
+
+### Blog Insights
+
+==A blog section can serve as a platform for sharing your expertise, industry insights, or personal reflections. It reflects your dedication to your craft and ensures your site remains vibrant with new content.==
+
+**Example:** a series of posts under "Design Insights," with entries like "The Future of Web Design: Trends to Watch" or "My Creative Process: From Concept to Completion," providing readers with valuable knowledge and a peek into your creative world.
+
+### Behind-the-Scenes Glimpses
+
+==Offer a look into your creative journey through behind-the-scenes content like sketches, mood boards, or early designs. This transparency into your process can fascinate visitors and add depth to your work presentation.==
+
+**Example:** a gallery called "The Making of a Logo," featuring early sketches, revisions, and commentary on the thought process behind each stage, culminating in the final design.
+
+### Engaging Interactive Elements
+
+Incorporate dynamic features such as sliders, animations, or interactive galleries. These elements can make your portfolio more engaging and leave a lasting impression on visitors.
+
+**Example:** an interactive gallery for a photography portfolio, where visitors can filter images by theme or color. Hovering over an image reveals the project name and details, while clicking enlarges the photo with a detailed caption.
+
+### Awards and Honors
+
+==Highlight any accolades or recognitions you've received. Showcasing your achievements adds prestige to your portfolio and distinguishes you from your peers.==
+
+**Example:** a "Recognition" section displaying badges or trophies from design competitions, accompanied by a brief description of the award and the project that won it, such as "Winner of the 2023 Design Innovation Award for the Eco-Friendly Packaging Series."
+
+### Video Demonstrations
+
+Embedding video content, whether project walkthroughs or client feedback, can provide an immersive experience. Videos add a dynamic layer to your presentation, making your work more relatable and memorable.
+
+**Example:** a video walkthrough of a mobile app design process, starting from wireframes to the finished product, with voiceover explaining design choices, challenges overcome, and user feedback incorporated into the final version.
+
+### Infographics and Data Visualizations
+
+==For those whose work involves data, adding infographics or visualizations can compellingly present complex information. This not only showcases your ability to simplify intricate data but also your creative approach to visual communication.==
+
+**Example:** an infographic titled "The Impact of Good Design on User Engagement," showcasing statistics on user retention, satisfaction, and conversion rates before and after a website redesign, highlighting your ability to drive results through design.
+
+Diversifying the content on your personal portfolio website with additions like testimonials, in-depth case studies, and interactive elements enriches your online presence. Such enhancements not only amplify the appeal and credibility of your portfolio but also demonstrate your comprehensive skill set and creativity.
+
+
+
+A web developer planning for personal portfolio website - [lunartech.ai](https://lunartech.ai/)
+
+## What Pages You Need in Your Portfolio
+
+To make your personal portfolio website truly unforgettable, paying close attention to its structure and content is paramount.
+
+The goal is to showcase not just your work and abilities, but to establish a holistic online platform that mirrors your professional identity. Integrating specific essential pages is critical for a detailed presentation of your competencies to prospective employers or clients.
+
+Here’s a detailed guide on the essential pages that are fundamental to a standout personal portfolio:
+
+### ==Home Page: The Gateway to Your Professional Universe==
+
+==The home page serves as the initial welcome to your professional domain, providing a brief yet impactful overview of your identity and offerings. This first impression is vital, setting the tone for the visitor's experience on your site.==
+
+
+
+==My home page==
+
+==Your home page should emphasize:==
+
+* **==Engaging Introduction==**==: Introduce yourself with a quick mention of your professional designation and expertise.==
+* **==Visual Elements==**==: Incorporate captivating visuals or a portfolio reel to immediately draw attention to your work.==
+* **==Navigation Tips==**==: Direct visitors smoothly to different site sections with clear navigation aids.==
+
+### ==Portfolio Section: A Display of Your Expertise==
+
+==This core section is where you showcase your finest work. Organizing this area thoughtfully ensures that visitors can easily navigate through your projects. You should include:==
+
+* **==Organization by Category==**==: Group projects by theme, type, or sector for straightforward browsing.==
+
+
+
+==Projects organized by category on my personal portfolio page - Python, Statistics, Machine Learning, and NLP==
+
+* **==Project Summaries==**==: Provide a concise description of each project, outlining your role, the methodology, and the results.==
+
+
+
+==Example project summary on my portfolio==
+
+* **==High-Resolution Media==**==: Present your work with high-quality images or videos to fully convey its quality.==
+
+
+
+### ==About Me Page: Your Professional Narrative==
+
+==This page allows you to forge a deeper connection with your audience by sharing your story, ambitions, and what makes you unique. It should cover:==
+
+* **==Professional Background==**==: Share your career path, educational achievements, and significant milestones.==
+
+
+
+==Some of my personal milestones==
+
+* **==Skills and Expertise==**==: Spotlight the abilities that distinguish you in your field.==
+
+
+
+==A page on my portfolio showing my "digital DNA" - the skills I'd like to showcase==
+
+* **==Personal Insights==**==: Offering a peek into your personal hobbies or interests can make you more approachable and relatable.==
+
+### Services Offered: How You Can Assist Clients
+
+If your portfolio is meant to attract freelance or consulting work, clearly detail the services you provide. This section should convey:
+
+* **Services List**: Enumerate the services you offer, such as design, consulting, or writing.
+
+
+
+A section on my site describing the courses I offer/topics I teach about
+
+* **Unique Advantages**: Describe what sets your services apart from the competition.
+* **Workflow Description**: Outline your process from the initial contact to project completion, offering potential clients a glimpse into your working style.
+
+### ==Contact Information: Simplifying Communication==
+
+==For potential collaborations, it’s essential to make reaching out as simple as possible. Your contact page should include:==
+
+* **==Various Contact Methods==**==: Provide a contact form, email, and possibly a phone number for easy communication.==
+
+
+
+==My contact information page on my personal portfolio site==
+
+* **==Social Media Profiles==**==: Guide visitors to your professional social media pages.==
+* **==Geographic Details==**==: If applicable, mention your location or time zone.==
+
+### Client Testimonials: Evidence of Your Expertise
+
+Testimonials from previous clients or colleagues act as a strong endorsement of your skills and dependability. Consider featuring:
+
+* **Client Feedback**: Include concise, meaningful quotes from clients about their satisfaction with your work.
+
+
+
+Some of my client's testimonials
+
+* **Project Links**: Optionally, connect these testimonials to specific projects they refer to.
+* **Client Images or Logos**: Adding photos or logos of the client's company can add credibility to each testimonial.
+
+Incorporating these key pages into your personal portfolio website not only effectively showcases your skills but also offers a complete picture of your professional sphere.
+
+By meticulously designing each section, you can cultivate a digital presence that draws in potential clients or employers, showcases your proficiency, and distinguishes you in your industry.
+
+
+
+This illustration emphasizes a modern and inviting atmosphere, designed to pique the curiosity of visitors and encourage exploration of the portfolio. - [lunartech.ai](https://lunartech.ai/)
+
+## How to Organize the Home Page
+
+Now let's talk about how to strategically organize the homepage of your personal portfolio website. The essence of the homepage is to succinctly represent you and ignite the curiosity of visitors to delve into your portfolio page. Essential sections include:
+
+### 1\. Navigation Bar
+
+A well-designed navigation bar is your visitor's roadmap to your website. It should be intuitive and straightforward, guiding them through your site with ease.
+
+
+
+Navigation section of my site
+
+Include links to your portfolio, about page, services, and contact information. Ensure it's accessible from every page, providing a seamless browsing experience.
+
+Your header hero acts as the first impression and the hook that draws visitors in. This section should feature a striking, high-quality image or a dynamic slider that represents your work or persona.
+
+Accompany this visual with a bold, concise statement about who you are and what you do. This is your chance to make an impact, so choose words and images that resonate with your professional identity and goals.
+
+
+
+Homepage displaying the header hero image on my site
+
+My hero image has my name in large print, and informs viewers that I specialize in compter science, data science, and AI.
+
+### 3\. Your Skills
+
+Highlighting your skills is crucial in showcasing your competencies to potential clients or employers.
+
+Create a visually engaging section where you list your primary skills, perhaps using icons or progress bars for a more dynamic presentation. Focus on the skills that set you apart and are most relevant to the work you want to attract.
+
+
+
+Some of my skills listed on my site
+
+On my site, I emphasize that I've had experience managing teams, optimizing performance, and building AI-driven products, for example.
+
+### 4\. Your Case Studies
+
+Case studies are powerful testimonials of your work history and success stories. Dedicate a section to showcase selected projects that highlight your problem-solving skills, creativity, and the value you’ve brought to previous engagements.
+
+For each case study, provide context, your role, challenges, solutions, and results. Including impactful visuals or links to the projects can greatly enhance this section.
+
+### 5\. Your Milestones
+
+This section is a timeline or a list of significant achievements, awards, recognitions, or other milestones in your career. It's a narrative of your professional journey and successes.
+
+Presenting this information in a chronological timeline or a visually engaging infographic can help tell your story compellingly and succinctly.
+
+You can list achievements such as starting a company, graduating from a degree program, reaching a certain number of followers on social media, and so on.
+
+### 6\. Testimonials (What others say about you)
+
+Testimonials from past clients, colleagues, or employers lend credibility and trust to your professional image. Select quotes that reflect your work ethic, impact, and personality.
+
+Displaying these testimonials with the name, title, and, if possible, a photo of the person providing them adds authenticity and a personal touch.
+
+### 7\. Technical Skills
+
+In addition to your general skills, it's important to specifically highlight your technical skills. This section should detail the tools, technologies, software, and programming languages you are proficient in.
+
+Using logos or icons of these technologies can make this section more visually appealing and easier to scan for visitors who are quickly trying to gauge your technical capabilities.
+
+
+
+My "digital DNA"
+
+For example, my "digital DNA" is made up of C++, Java, JavaScript, Python, React, and other popular technologies.
+
+Beyond these, your homepage doesn't require additional content. It's vital to capture the visitor's attention quickly with compelling visuals and effective copywriting, given the short window to make an impact.
+
+### ==Do's for a Captivating Homepage==
+
+* **==Be Concise==**==: Ensure your message is clear and to the point.==
+* **==Use Endorsement Logos==**==: Incorporate logos of companies you've appeared on to build trust.==
+* **==Display Technical Stack Logos==**==: Show the technologies you're proficient in using their logos.==
+* **==Showcase a Case Study Gallery==**==: Highlight your best work in an easily navigable gallery.==
+* **==Include a Dynamic Header==**==: Use an engaging hero section to make a strong first impression.==
+* **==Highlight Recent Work==**==: Give visitors a glimpse of your latest projects to show you're active and relevant.==
+* **==Use Testimonials Strategically==**==: Place client testimonials where they'll have the most impact, showcasing your reliability and skill.==
+
+### ==Don'ts for Your Homepage==
+
+* **==Avoid Random Placement==**==: Structure your content logically – don't place information haphazardly.==
+* **==Steer Clear of Long Paragraphs==**==: Keep your homepage breezy and easy to read with short, impactful statements.==
+* **==Don't Overwhelm with Content==**==: Your homepage isn't the place to squeeze in every detail of your portfolio.==
+* **==Avoid Image Neglect==**==: Images are crucial for visual engagement, so don't omit them.==
+* **==Resist Clutter==**==: Keep the design clean and focused to improve user experience.==
+* **==Avoid Technical Jargon==**==: Use language that's accessible to all visitors, not just industry insiders.==
+* **==Skip the Hard Sell==**==: Present your skills and achievements without being overly aggressive.==
+
+Effective organization of your homepage is key to creating a memorable and professional personal portfolio website.
+
+By following these guidelines, you ensure that your homepage not only accurately represents your professional persona but also encourages further exploration of your portfolio, opening up new opportunities for engagement and collaboration.
+
+
+
+Here's a visual representation of a designer actively updating their online portfolio, highlighting their commitment to showcasing evolving skills and staying current. - <https://lunartech.ai/>
+
+## How to Keep Your Portfolio Fresh
+
+Keeping your portfolio updated is crucial for reflecting your evolving skills, expertise, and experiences. An engaging and current portfolio not only captivates potential clients and visitors but also illustrates your dedication to your profession. Here are strategies to ensure your portfolio remains fresh and appealing:
+
+### Continuously Update with New Work
+
+Regularly add your latest and greatest projects to your portfolio. This demonstrates your active involvement in your field and your commitment to quality and innovation. It's a way to showcase your growth and adaptability over time.
+
+### Revamp Your Portfolio's Design
+
+Periodically rejuvenating the design of your portfolio website can keep it looking modern and fresh. An updated design can better engage visitors and reflect your ability to stay in tune with the latest trends and technologies in design.
+
+### Showcase Testimonials and Recognitions
+
+Incorporate new testimonials from clients or colleagues, as well as any recent awards or honors you've received. This external validation of your work adds credibility and can significantly influence potential clients' perceptions of your expertise.
+
+### Maintain an Active Blog
+
+A blog can be a dynamic component of your portfolio, offering insights into your work process, industry observations, or detailed project breakdowns. Regular posts keep your site content fresh and can help establish you as a thought leader in your field.
+
+Use social media platforms to highlight recent projects, achievements, and updates from your portfolio. A robust social media presence can extend your reach, attract a broader audience, and keep your work in the spotlight.
+
+### Incorporate Interactive Elements
+
+Adding interactive elements, such as animations or interactive galleries, can refresh the user experience on your site. These elements can make your portfolio more memorable and engaging.
+
+### Feedback Loop
+
+Invite feedback on your work and website from peers and mentors. Implementing constructive feedback can improve your portfolio's effectiveness and demonstrate your commitment to excellence and continuous improvement.
+
+### Diversify Your Content
+
+Show a range of projects and skills, including collaborative works, to display the breadth of your capabilities. This diversity can attract a wider array of clients interested in different aspects of your expertise.
+
+### Stay Relevant with Trends
+
+Keep abreast of the latest trends in your industry and incorporate them into your work and portfolio presentation. This shows that you are forward-thinking and capable of adapting to change.
+
+By employing these strategies, you can ensure that your portfolio remains an accurate, engaging representation of your professional journey and capabilities. Regular updates and a proactive approach to showcasing your achievements can significantly enhance your portfolio's appeal, making it a powerful tool for attracting new opportunities and clients.
+
+## Conclusion
+
+When it comes to crafting a standout personal portfolio page, remember that simplicity and showcasing your best work are key. By following the step-by-step guide outlined in this blog, you can create a compelling portfolio that effectively highlights your skills and talents.
+
+Start by organizing your projects in a clean and visually appealing layout. Use high-quality images and concise descriptions to provide visitors with a clear understanding of your work. Remember, your portfolio is a reflection of you and your brand.
+
+Don't forget to include a call to action that prompts visitors to take the next step, whether it's contacting you for collaborations or viewing more of your work. Engage your audience with a clear message and encourage them to explore further. Ready to elevate your online presence? Take the first step and build that portfolio.
+
+### ****Resources**
+
+Kickstart your journey in technology with our specialized program that dives into Artificial Intelligence (AI) and machine learning. This initiative is crafted to build your programming expertise, supplemented with dedicated mentorship and career guidance to pave your way in the tech industry.
+
+### Propel your career forward with this curated list of resources, focused on tangible outcomes:
+
+* [How to Enter Gen AI in 2024:](https://downloads.tatevaslanyan.com/six-figure-data-science-ebook) This guide breaks down the essentials of emerging AI technologies and prepares you for future trends.
+* [Land Your Software Engineering Internship:](https://join.lunartech.ai/software-engineering-internship) This resource provides step-by-step instructions for finding and landing a valuable internship in software engineering, giving you a competitive edge.
+* [Machine Learning Fundamentals eBook:](https://join.lunartech.ai/machine-learning-fundamentals--3f64f) Begin your exploration of machine learning with this eBook, which provides a concise overview of its core principles and techniques.
+
+For access to these resources and detailed information about our program, visit [LunarTech's ](https://lunartech.ai/)website. Embark on your tech career path with the right tools and support from [LunarTech](https://lunartech.ai/).
+
+### ****Connect with Me:**
+
+* [Follow me on LinkedIn for a ton of Free Resources in CS, ML and AI](https://ca.linkedin.com/in/vahe-aslanyan)
+* [Visit my Personal Website](https://vaheaslanyan.com/)
+* Subscribe to my [The Data Science and AI Newsletter](https://tatevaslanyan.substack.com/)
+
+### ****About the Author**
+
+I'm Vahe Aslanyan, specializing in the world of computer science, data science, and artificial intelligence. Explore my work at [vaheaslanyan.com](https://www.vaheaslanyan.com/). My expertise encompasses robust full-stack development and the strategic enhancement of AI products, with a focus on inventive problem-solving.
+
+[Vahe Aslanyan - Crafting Code, Shaping FuturesDive into Vahe Aslanyan’s digital world, where each endeavor offers new insights and every hurdle paves the way for growth.Crafting Code, Shaping Futures](https://www.vaheaslanyan.com/)
+
+I've consistently aimed to revolutionize technical education, striving to set a new, universal standard. As we wrap up this handbook, I want to say a big thank you for spending time with it. Sharing what I've learned has made me think more about my work. I hope what we've gone through together helps you move forward in tech.
+
+---
+
+---
+
+ 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/)
\ No newline at end of file
diff --git a/Omnivore/2024-03-25 - noboilerplate-scripts-27-coping-mechanisms.md at main · 0atman-noboilerplate.md b/Omnivore/2024-03-25 - noboilerplate-scripts-27-coping-mechanisms.md at main · 0atman-noboilerplate.md
new file mode 100644
index 0000000..47a1b8f
--- /dev/null
+++ b/Omnivore/2024-03-25 - noboilerplate-scripts-27-coping-mechanisms.md at main · 0atman-noboilerplate.md
@@ -0,0 +1,725 @@
+---
+id: f2f6b3b5-b35c-49bf-ab94-61559888fe81
+title: |
+ noboilerplate/scripts/27-coping-mechanisms.md at main · 0atman/noboilerplate
+status: ARCHIVED
+tags:
+ - read-later
+date_added: 2024-03-25 17:12:00
+url_omnivore: |
+ https://omnivore.app/me/noboilerplate-scripts-27-coping-mechanisms-md-at-main-0-atman-no-18e773dc294
+url_original: |
+ https://github.com/0atman/noboilerplate/blob/main/scripts/27-coping-mechanisms.md
+---
+
+# noboilerplate/scripts/27-coping-mechanisms.md at main · 0atman/noboilerplate
+
+## Highlights
+
+If something comes to mind, or someone tells you something important, YOU MUST WRITE IT DOWN in a trusted system
+
+[source](https://omnivore.app/me/noboilerplate-scripts-27-coping-mechanisms-md-at-main-0-atman-no-18e773dc294#901e24a0-6646-4f53-9233-fa3a627f1289)
+
+---
+
+This theory is called Active Externalism.
+
+---
+
+[source](https://omnivore.app/me/noboilerplate-scripts-27-coping-mechanisms-md-at-main-0-atman-no-18e773dc294#1f3cdbf9-2b58-4a65-9f83-c055ecff679d)
+
+---
+
+Put EVENTS on your calendar.
+
+[source](https://omnivore.app/me/noboilerplate-scripts-27-coping-mechanisms-md-at-main-0-atman-no-18e773dc294#0ae3ba38-15fe-4264-85b9-a355e502dc1c)
+
+---
+
+Events are not tasks that have a due date - those things should go in a task management system.
+
+[source](https://omnivore.app/me/noboilerplate-scripts-27-coping-mechanisms-md-at-main-0-atman-no-18e773dc294#c091f165-7a83-42d6-bb28-7979d4d243c9)
+
+---
+
+If it can be done before the due date, it's a task, not an event.
+
+[source](https://omnivore.app/me/noboilerplate-scripts-27-coping-mechanisms-md-at-main-0-atman-no-18e773dc294#f8d8cb12-333a-44d4-82e5-124c2347f084)
+
+---
+
+Carry earplugs
+
+[source](https://omnivore.app/me/noboilerplate-scripts-27-coping-mechanisms-md-at-main-0-atman-no-18e773dc294#ea1eceab-55f2-4482-bad4-fcc08ad1f565)
+
+---
+
+What you're going to do is, at the first hint of confusion or misunderstanding, say "I'm sorry, I don't understand" and let them try again.
+
+[source](https://omnivore.app/me/noboilerplate-scripts-27-coping-mechanisms-md-at-main-0-atman-no-18e773dc294#87395a65-15a8-439b-a946-257d5e715d34)
+
+---
+
+You need context in communication like you're talking to a deep space probe Ask for what you need, which is for context to be included in what people ask of you.
+
+[source](https://omnivore.app/me/noboilerplate-scripts-27-coping-mechanisms-md-at-main-0-atman-no-18e773dc294#c2ce3a46-c55a-48b6-b60d-b030d551ffce)
+
+---
+
+All relevant information must be inside the message.
+
+[source](https://omnivore.app/me/noboilerplate-scripts-27-coping-mechanisms-md-at-main-0-atman-no-18e773dc294#259b5f32-a40a-4252-a9ea-346987131a80)
+
+---
+
+Use a Note-Taking System
+
+[source](https://omnivore.app/me/noboilerplate-scripts-27-coping-mechanisms-md-at-main-0-atman-no-18e773dc294#f0f29fde-8f78-43a8-aa02-c58d5f25225c)
+
+---
+
+This is important, Past Tris. Don't. Open. Your. Browser.
+
+[source](https://omnivore.app/me/noboilerplate-scripts-27-coping-mechanisms-md-at-main-0-atman-no-18e773dc294#5bc8f767-dc93-4f00-8723-dbb16e62af1b)
+
+---
+
+The first coping mechanism in this framework is eat the frog, which means to do the least pleasant or hardest task first.
+
+[source](https://omnivore.app/me/noboilerplate-scripts-27-coping-mechanisms-md-at-main-0-atman-no-18e773dc294#b5408b52-072f-498d-9520-f42856d150dd)
+
+---
+
+There's a good but boring book called Triggers by Marshall Goldsmith, that I recommend you read, or ideally get someone to summarise it for you.
+
+[source](https://omnivore.app/me/noboilerplate-scripts-27-coping-mechanisms-md-at-main-0-atman-no-18e773dc294#e9fe7791-4063-4aa6-9c9e-641d506560ae)
+
+---
+
+Pay attention to people who seem like they know what they are talking about and figure out what makes them so good at explaining their thoughts.
+
+[source](https://omnivore.app/me/noboilerplate-scripts-27-coping-mechanisms-md-at-main-0-atman-no-18e773dc294#96ab7872-b330-4a81-a5fe-0d6191720a0f)
+
+---
+
+Study, imitate and practice.
+
+[source](https://omnivore.app/me/noboilerplate-scripts-27-coping-mechanisms-md-at-main-0-atman-no-18e773dc294#378de782-f5e4-4fe3-baa0-4836b3a896bd)
+
+---
+
+Save your energy by focusing on the positives
+
+[source](https://omnivore.app/me/noboilerplate-scripts-27-coping-mechanisms-md-at-main-0-atman-no-18e773dc294#e79fffb1-82c5-4955-8964-cb780627117d)
+
+---
+
+Notice the negatives, but feel the positives.
+
+[source](https://omnivore.app/me/noboilerplate-scripts-27-coping-mechanisms-md-at-main-0-atman-no-18e773dc294#45a4b54b-2ed2-40f1-b6cf-215f963e0014)
+
+---
+
+You have to FOCUS.
+
+[source](https://omnivore.app/me/noboilerplate-scripts-27-coping-mechanisms-md-at-main-0-atman-no-18e773dc294#706cd560-3e18-4abf-b45c-19b220a270d8)
+
+---
+
+## 15\. Just do a bit
+
+[](#15-just-do-a-bit)
+
+> You put one word after another until its done. It's that easy, and that hard.
+
+— Neil Gaiman
+
+[source](https://omnivore.app/me/noboilerplate-scripts-27-coping-mechanisms-md-at-main-0-atman-no-18e773dc294#e41df1e5-9e90-4c91-809f-d2ae6e11c04d)
+
+---
+
+I trick my brain into doing this with Timers.
+
+[source](https://omnivore.app/me/noboilerplate-scripts-27-coping-mechanisms-md-at-main-0-atman-no-18e773dc294#52577fa3-2e0f-4f1d-af34-7d69308e3e15)
+
+---
+
+## 17\. humanize organize mechanize
+
+[](#17-humanize-organize-mechanize)
+
+notes: This is how I build systems, both in my life and professionally.
+
+**Humanise**
+Do everything manually, on paper if needed, for many iterations.
+
+**Organise**
+Notice the patterns that are creeping into your methods.
+
+**Mechanise**
+Automate those patterns in a system, either by writing checklists, flowcharts or software.
+
+[source](https://omnivore.app/me/noboilerplate-scripts-27-coping-mechanisms-md-at-main-0-atman-no-18e773dc294#26170aa1-0968-4106-819c-d090079d8379)
+
+---
+
+## One thing at a time
+
+[](#one-thing-at-a-time)
+
+## most important thing first
+
+[](#most-important-thing-first)
+
+## Start now
+
+[source](https://omnivore.app/me/noboilerplate-scripts-27-coping-mechanisms-md-at-main-0-atman-no-18e773dc294#cc6de1c2-538f-4cd2-b994-db98ed8bcdac)
+
+---
+
+## Original
+
+<style> :root {--r-code-font: "FiraCode Nerd Font";} .reveal .hljs {min-height: 50%;} </style>
+
+%%
+
+f7f7f7 background slide colour
+
+* title formatting
+
+%%
+
+!\[\[tri-hex-moon-white-transparent.png|300\]\]
+
+## Hacking your brain
+
+[](#hacking-your-brain)
+
+### With elaborate coping mechanisms
+
+[](#with-elaborate-coping-mechanisms)
+
+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.
+
+Some people seem to have life figured out don't they.
+
+I don't, I'm learning every day, but I do have some EXTREMELY elaborate coping mechanisms that make me productive, easier in social situations, and happier, i think, in life.
+
+Today I'm going to share them with you in the form of an open letter to my past self.
+
+Bear in mind that I am not an expert in anything really, certainly not the human brain. I can't even edit video, and I'm not very good at Rust.
+
+However I have managed to become highly productive with these coping mechanisms, and perhaps some of them will work for you.
+
+---
+
+## Public Domain Videos
+
+[](#public-domain-videos)
+
+[github.com/0atman/noboilerplate/](https://github.com/0atman/noboilerplate/)
+
+notes: Everything you see in this video from the script to the images are part of a markdown document available on github under a public domain license.
+
+---
+
+!\[\[newspaper-youtuber.jpg\]\]
+
+notes:
+
+Hello past Tris, it's me, Future Tris. Stop spending all of my money!
+
+I have some important things to tell you that will make your life easier. I wish I had learned these earlier, so I'm going to give you a head start.
+
+Also buy apple stock, don't sell those bitcoins in 2015, and you can break up with her, it's ok, you'll both be fine.
+
+---
+
+## 1\. Declare bankruptcy on your memory
+
+[](#1-declare-bankruptcy-on-your-memory)
+
+notes:
+
+Tris, we've given it a good go, you and I, haven't we.
+
+You will learn, as so many have done before you, that your brain is for HAVING ideas, not STORING ideas.
+
+That advice is probably valid for anyone, but it's ESPECIALLY valid for you and I.
+
+At this point in your life, you still think you can remember things like everyone else, I imagine? You can't. And maybe they can't either. The sooner you realise this, the sooner you can build systems to easily replace this missing ability. And I'll help you there.
+
+---
+
+## 2\. Carry a notebook
+
+[](#2-carry-a-notebook)
+
+!\[\[field-notes.png|700\]\]
+
+notes:
+
+When are you, about 2005? ew. So, no smartphone (you're gonna hate them) get a nice pocketable notebook. Field Notes are fine, but pricey If you can bear to have a notebook that doesn't have a ruler printed in the back, you can buy cheap alternatives for a dollar.
+
+Or a pound. Look, we all talk in dollars now, get used to it.
+
+==If something comes to mind, or someone tells you something important, YOU MUST WRITE IT DOWN in a trusted system==
+
+---
+
+## Active Externalism
+
+[](#active-externalism)
+
+> I'm not writing it down to remember later, I'm writing it down to remember NOW.
+
+notes:
+
+A lot of the memory techniques I'm going to talk about change your understanding of your mind from something that is exclusively inside your head, to something that can be augmented by paper, pencil, and digital methods
+
+==This theory is called Active Externalism.==
+
+---
+
+## 3\. Calendars
+
+[](#3-calendars)
+
+## are GREAT
+
+[](#are-great)
+
+notes:
+
+I think you have a google account in 2005, you and I are early adopters, which is always exciting if not relaxing.
+
+==Put EVENTS on your calendar.==
+
+Events are things you can miss if you forget them and sit at home all weekend watching South Park while all your friends have fun. Oh, that oddly-specific example hasn't happened to you yet? It will. Remember to use a calendar.
+
+==Events are not tasks that have a due date - those things should go in a task management system.==
+
+==If it can be done before the due date, it's a task, not an event.==
+
+---
+
+## 4\. Getting Things Done (GTD)
+
+[](#4-getting-things-done-gtd)
+
+notes:
+
+There are a lot of task management systems, even in your time. The one that fits the shape of our brain best is David Allen's GTD.
+
+GTD has tasks split into projects like many others, but the differentiating factor that makes it work for us is that tasks also have a Context tag, like 'laptop', 'home', 'work', or whatever you want.
+
+The reason this works for us is that when you are physically IN a certain context, you can filter out all the rubbish that by definition you CAN'T do at the moment.
+
+Task systems that don't do this filtering create more undue distractions.
+
+---
+
+## 5\. ==Carry earplugs==
+
+[](#5-carry-earplugs)
+
+notes:
+
+OK sorry you had to find out like this in front of 100,000 of our closest friends, but you, my dude, have autism.
+
+Right? Makes sense now I say it out loud doesn't it? It's no biggie, a lot of folks do.
+
+You know how you don't like pubs, clubs, stadia and other noisy places? Surprise! That's called sensory overload, and is an Autism symptom.
+
+wear earplugs to relieve this symptom.
+
+There's a lot of earplug options, from the classic foam cylinders to mouldable wax. I've heard that wax ear plugs can get stuck in there, so don't use those, I like the ones that look like rounded foam earbuds, very comfy.
+
+---
+
+## 6\. In the face of ambiguity,
+
+[](#6-in-the-face-of-ambiguity)
+
+## refuse the temptation
+
+[](#refuse-the-temptation)
+
+## to guess
+
+[](#to-guess)
+
+❯ python -c "import this" | grep ambiguity
+In the face of ambiguity, refuse the temptation to guess.
+
+notes:
+
+OK, so while we're talking about Autism, let's talk about all those misunderstandings that happen when you talk to people.
+
+Neurotypical people have a lot more bandwidth available in their communications than you or I do. They take into consideration body language, tone, vocal hesitations, and extrapolate enormous amounts of information when talking.
+
+AND THEY EXPECT YOU TO DO THE SAME.
+
+You're not going to do that, nor should you have to.
+
+==What you're going to do is, at the first hint of confusion or misunderstanding, say "I'm sorry, I don't understand" and let them try again.==
+
+If they continue to give you incomplete confusing information, you are going to say again, patiently, "I don't understand", don't worry they won't mind repeating themselves, they all love talking, it'll help them too, trust me.
+
+And if on the third utterance they still don't make sense, you say "I'm sorry, I don't think YOU understand". Because half the time they DON'T, and it's not your responsibility to teach them how to communicate.
+
+---
+
+!\[\[white-logo.png|400\]\] notes:
+
+==You need context in communication like you're talking to a deep space probe
+Ask for what you need, which is for context to be included in what people ask of you.==
+
+==All relevant information must be inside the message.==
+
+It's a long way back home.
+
+Let me take a break from my open letter for a moment.
+
+Friends, I hope to not only teach myself, I'm hoping to teach and help everyone.
+
+---
+
+!\[\[lt-shuttle-screenshot.png\]\]
+
+Watch on YouTube or at [LostTerminal.com](https://lostterminal.com/)
+
+notes: In addition to this no boilerplate video, I've put together 12 seasons so far of my scifi, hopepunk, mental health story podcast, Lost Terminal, and thousands of lovely people tune in each week.
+
+It's very reasonable for an AI to have difficulty understanding other people's emotions, or struggle with his own, and framing this as an AI challenge allows me to talk about autism in a safe environment. In later seasons, my research has allowed me to branch out into other mental health and LGBT issues too, all with the same AI lens.
+
+I'd love for you to watch or listen to the first season, I've linked it here, and at the end of the video, or in the description.
+
+back to the letter
+
+---
+
+## 7\. ==Use a Note-Taking System==
+
+[](#7-use-a-note-taking-system)
+
+notes:
+
+Tris, There are many note-taking systems available, even in 2005, and the one feature you should look for in any of them is the ability to link between pages. Yes, hyperlinks. This is the whole point of the web and is its killer feature.
+
+You can use a wiki for this, there are several available, but you can also use Markdown.
+
+---
+
+## 8\. Plain Text
+
+[](#8-plain-text)
+
+## lasts forever
+
+[](#lasts-forever)
+
+notes:
+
+If Your brain is going to be external to your head, it should be in plain text. Not a propitiatory database hidden inside some app waiting for the company to go out of business.
+
+As an example, my show Lost Terminal is set in the future some time after the environmental collapse, and in the story, the survivors STILL HAVE plain text digital records. You know what they don't have? iCloud.
+
+My brain is stored in plain text, marked up with Markdown, inside Obsidian.
+
+---
+
+!\[\[obsidian-hopepunk.png\]\]
+
+[obsidian.md](http://obsidian.md/) (not sponsored, other editors available)
+
+notes:
+
+Every wiki page I read, every blog, every article, if it could be relevant to my work, I copy and paste into my brain, for later linking and extraction.
+
+This is a simple screenshot of the wikipedia article on Hopepunk, the cosy, safe genre that Lost Terminal sits in.
+
+But through the plugin system, Obsidian, and therefore my brain, can be as complex as it needs to be.
+
+---
+
+!\[\[obsidian-lt-12.png\]\]
+
+notes:
+
+Here is the workspace I use for writing Lost Terminal. We've got widgets written in a few lines of javascript embedded on the page, and in the side panes.
+
+In the morning, I open this up, set a timer, and write my word count before opening my browser.
+
+==This is important, Past Tris.
+Don't. Open. Your. Browser.==
+
+---
+
+## 9\. Eat the frog
+
+[](#9-eat-the-frog)
+
+notes:
+
+Like a lot of other people discovered in 2020, you also have ADHD.
+
+What happened in 2020 to cause this? I'll just say that a LOT of people's work routines were disrupted and they were expected to be much more autonomous then before, exposing the underlying problem.
+
+Don't worry about it, you've got a while till it happens.
+
+So the frameworks that people realised they needed to be productive, you're going to build for yourself.
+
+==The first coping mechanism in this framework is eat the frog, which means to do the least pleasant or hardest task first.==
+
+Don't let it loom over you while you do other easy things on your task list like laundry or shopping.
+
+Do the hardest thing first.
+
+---
+
+## 10\. Build habits
+
+[](#10-build-habits)
+
+## Then chain them together
+
+[](#then-chain-them-together)
+
+> wake → water → yoga → write → shower
+
+notes:
+
+==There's a good but boring book called Triggers by Marshall Goldsmith, that I recommend you read, or ideally get someone to summarise it for you.==
+
+Pay attention to what is making you do thing, its trigger, like a location, a song, a person or a thought. Then build a feedback loop to improve and chain these triggers together.
+
+---
+
+## 1.017 \= 1.07
+
+[](#1017--107)
+
+#### but
+
+[](#but)
+
+## 1.01365 \= 37.78
+
+[](#101365--3778)
+
+notes:
+
+tiny daily change adds up cumulatively over time.
+
+You won't see it at first, but if you, for example, write 400 words every single day, in a year you'll have 4 whole seasons of a podcast, or many novels, or video scripts, or whatever it is you want to do.
+
+If you spend you time bouncing between 3 apps, you'll end the year with nothing.
+
+---
+
+## 11\. Public speaking is important
+
+[](#11-public-speaking-is-important)
+
+notes:
+
+I'm very good at public speaking NOW, so it all works out eventually, but that is because I PRACTISED a lot.
+
+Yes that thing mum and dad asked us to do for the piano and we never did.
+
+At university you are going to realise public speaking is going to be
+
+1. a problem and
+2. mandatory in the wider world.
+
+==Pay attention to people who seem like they know what they are talking about and figure out what makes them so good at explaining their thoughts.==Don't bother with persuasion or rhetoric, we're not here for that, we're here to talk to people clearly and precisely.
+
+==Study, imitate and practice.==
+
+---
+
+## 12.
+
+[](#12)
+
+## Imitate
+
+[](#imitate)
+
+## imitate
+
+[](#imitate-1)
+
+## imitate
+
+[](#imitate-2)
+
+notes:
+
+Pay attention to how people act, then do what they do.
+
+This works as well in a sprint planning meeting as it does on the dance floor.
+
+---
+
+## 13\. Negative emotions are not very useful
+
+[](#13-negative-emotions-are-not-very-useful)
+
+notes:
+
+I don't know why neurotypical people romanticise jealousy as protectiveness, anger as passion, greed as ambition, but you don't need to learn these emotions. And if you have learned them, you certainly don't need to practice them. In fact, do the opposite.==Save your energy by focusing on the positives==, there's a lot to be happy about in our life, we're extremely fortunate!
+
+HOWEVER negative emotions are not ENTIRELY un-useful!
+
+Remember that girl I mentioned earlier? You'll stay with her because you're minimising the negative emotions you're feeling. That's not good.
+
+You're not a robot, I know, but throuhg practice you can choose what to feel, and what to notice.==Notice the negatives, but feel the positives.==
+
+==You have to FOCUS.==
+
+---
+
+## 14.
+
+[](#14)
+
+## _F o c u s_
+
+[](#f-o-c-u-s)
+
+notes:
+
+there's dozens of new programming languages per year, just choose one and try it. There's lots of games to play, don't scroll your steam library, just choose one and play it. There's an infinite amount of news available to read, use rss feeds, and filters, not firehose scrolling and read important things deeply.
+
+---
+
+## ==15. Just do a bit==
+
+[](#15-just-do-a-bit)
+
+> ==You put one word after another until its done. It's that easy, and that hard.==
+
+==— Neil Gaiman==
+
+notes:
+
+The plural of word is sentence, the plural of sentence is paragraph and the plural of paragraph means you're done and can go back to playing video games.
+
+It's like a reverse Zenos's paradox, just put one word in front of the other and you'll get there.
+
+==I trick my brain into doing this with Timers.==
+
+---
+
+## 16\. Timers
+
+[](#16-timers)
+
+## are GREAT
+
+[](#are-great-1)
+
+notes:
+
+I run my life on timers, and you should too. I'm writing this with a timer running, in 14 minutes I'll have a break and a cup of tea.
+
+Then after that I'll do a bit more.
+
+---
+
+!\[\[napchart-pomodoro.png\]\]
+
+notes:
+
+There's a light system for organising your timers called the Pomodoro Technique
+
+The default recommendations are to set a timer for 20 minutes, work as fast as you can, then when the timer goes off, set another for 5 minutes and have a break.
+
+This ends up, tricking us into HOURS of high-quality, focussed work!
+
+Here's an example schedule, some work in the morning, a lot of work in the afternoon, and a bit before bed.
+
+I know you go to bed late, Past Tris, so I tweaked this just for you.
+
+Would you believe me that these days I get up early and love it? No, probably I wouldn't have believed me either.
+
+---
+
+## ==17. humanize organize mechanize==
+
+[](#17-humanize-organize-mechanize)
+
+==notes:
+This is how I build systems, both in my life and professionally.==
+
+**==Humanise==**
+==Do everything manually, on paper if needed, for many iterations.==
+
+**==Organise==**
+==Notice the patterns that are creeping into your methods.==
+
+**==Mechanise==**
+==Automate those patterns in a system, either by writing checklists, flowcharts or software.==
+
+---
+
+!\[\[27-coping-mechanisms 2023-06-07 15.21.56.excalidraw\]\]
+
+notes:
+
+Here's a trivial algorithm I set up for myself. I don't know why I need to drink so much water, but every body is different I suppose! In addition to waking up and drinking 500ml before breakfast, this little system works for me, at the first sign of a headache.
+
+---
+
+## 18.
+
+[](#18)
+
+## ==One thing at a time==
+
+[](#one-thing-at-a-time)
+
+## ==most important thing first==
+
+[](#most-important-thing-first)
+
+## ==Start now==
+
+[](#start-now)
+
+notes: Really that's what all my advice comes down to, past Tris. Choose what you want to do and do it.
+
+Keep at it champ, I'm proud of you, it all works out in the end!
+
+---
+
+!\[\[tri-hex-moon-white-transparent.png|300\]\]
+
+## Thank you
+
+[](#thank-you)
+
+notes:
+
+## OUTRO
+
+[](#outro)
+
+If you would like to support my channel, get early ad-free and tracking-free videos and vip discord access head to patreon.com/noboilerplate.
+
+If you're interested in transhumanism and hopepunk stories, please check out my sci-fi podcast, Lost Terminal.
+
+Or if urban fantasy is more your bag, do listen to a strange and beautiful podcast I produce called Modem Prometheus.
+
+Transcripts and compile-checked markdown sourcecode 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.
+
+ println!("That's all folks!");
+}
\ No newline at end of file
diff --git a/Omnivore/2024-03-25 - noboilerplate-scripts-35-adhd-a-left-handed-brain.md at main · 0atman-noboilerplate.md b/Omnivore/2024-03-25 - noboilerplate-scripts-35-adhd-a-left-handed-brain.md at main · 0atman-noboilerplate.md
new file mode 100644
index 0000000..08ec3bc
--- /dev/null
+++ b/Omnivore/2024-03-25 - noboilerplate-scripts-35-adhd-a-left-handed-brain.md at main · 0atman-noboilerplate.md
@@ -0,0 +1,832 @@
+---
+id: 7484046e-a123-4c02-a67a-1822184aed23
+title: |
+ noboilerplate/scripts/35-adhd-a-left-handed-brain.md at main · 0atman/noboilerplate
+status: ARCHIVED
+tags:
+ - read-later
+date_added: 2024-03-25 17:37:48
+url_omnivore: |
+ https://omnivore.app/me/noboilerplate-scripts-35-adhd-a-left-handed-brain-md-at-main-0-a-18e77555f9a
+url_original: |
+ https://github.com/0atman/noboilerplate/blob/main/scripts/35-adhd-a-left-handed-brain.md
+---
+
+# noboilerplate/scripts/35-adhd-a-left-handed-brain.md at main · 0atman/noboilerplate
+
+## Notes
+
+Another examples:
+
+- Hyperfixation and the struggle to let go of the thing I'm doing, even if it meant to have problems with other tasks/people
+- The procastination to start doing something
+- The craving for "multitasking", which is more searching for dopamine in distraction while working.
+- The meltdowns and struggles when I loose the structure in life: coronavirus lockdowns and the meldown in the institude, when I'm on vacations, now that I don' have a job
+- The search of dopamine on other places in class.
+- The hurry of doing stuff
+## Highlights
+
+* They're not intentionally disruptive in class, they're choosing dopamine-rewarding behaviours.
+* They're not greedy when eating, they're choosing dopamine-rewarding behaviours
+* They're not unable to listen to you when you talk to them, they're choosing dopamine-rewarding behaviours
+* They are not constantly distracted, they're constantly engaging in dopamine-rewarding behaviour, just as evolution has taught us all to do.
+
+[source](https://omnivore.app/me/noboilerplate-scripts-35-adhd-a-left-handed-brain-md-at-main-0-a-18e77555f9a#4d4650e0-de8d-4038-87de-030d07d5b550)
+
+---
+
+I no longer could get by on smarts, everyone's smart here
+
+[source](https://omnivore.app/me/noboilerplate-scripts-35-adhd-a-left-handed-brain-md-at-main-0-a-18e77555f9a#d5939abe-d36f-4fcd-b709-883d979d1237)
+
+---
+
+Web development might be the best job in the world, it certainly was the best job for me: It's naturally structured, with the work often agreed upon by the team, and divided up into byte-sized tasks. ^2f688b
+
+The prevailing organisation system, scrum, had clear goals and structure that really worked for me, at least at first, it was like solving a puzzle or playing a video game, but every day. ^b121ff
+
+[source](https://omnivore.app/me/noboilerplate-scripts-35-adhd-a-left-handed-brain-md-at-main-0-a-18e77555f9a#be183259-2e7d-4ff0-bba2-4ce1ef8e7b88)
+
+---
+
+If you, like many folks,
+
+* wake up to an alarm,
+* commute to your job for 8 or 9am,
+* do whatever work your boss tells you to do,
+* commute home and eat and then sleep,
+* only to do it all over again the next day.
+
+You might never notice you have ADHD.
+
+Symptoms like executive dysfunction and inattention might not affect you in the 9-to-5 grind. ^183e58
+
+[source](https://omnivore.app/me/noboilerplate-scripts-35-adhd-a-left-handed-brain-md-at-main-0-a-18e77555f9a#b594529e-a544-4475-8996-3880700e369a)
+
+---
+
+Right when I needed to be self-directed, to decide for myself what to spend each day doing.
+
+[source](https://omnivore.app/me/noboilerplate-scripts-35-adhd-a-left-handed-brain-md-at-main-0-a-18e77555f9a#e5c4e121-b329-4c65-9534-a3d98fa50305)
+
+---
+
+not whatever random thoughts popped into my mind
+
+[source](https://omnivore.app/me/noboilerplate-scripts-35-adhd-a-left-handed-brain-md-at-main-0-a-18e77555f9a#e4454351-e4ee-4e0b-89ba-3aca2f501018)
+
+---
+
+Though illegal drugs famously can boost dopamine, so can caffeine and chocolate.
+
+[source](https://omnivore.app/me/noboilerplate-scripts-35-adhd-a-left-handed-brain-md-at-main-0-a-18e77555f9a#670219c7-995d-4877-80f6-b6de27776e27)
+
+---
+
+## Original
+
+<style> :root {--r-code-font: "FiraCode Nerd Font";} .reveal .hljs {min-height: 50%;} </style>
+
+## ADHD: A Left-handed Brain
+
+[](#adhd-a-left-handed-brain)
+
+## (in A Right-handed World)
+
+[](#in-a-right-handed-world)
+
+---
+
+!\[\[logo-head-half-digital.png|300\]\]
+
+## In a Right-
+handed World
+
+[](#in-a-right-handed-world-1)
+
+notes:
+
+Hi friends my name is Tris and this is No Boilerplate, focusing on fast, technical videos.
+
+This video is about ADHD.
+
+Despite not being left-handed, I do have a great deal of empathy for our left-handed cousins because of my ADHD.
+
+A surprising number of left-handed people are ambidextrous, they are equally skilled with either hand.
+
+This makes a lot of sense, in our world there are many manual interfaces that are explicitly right-handed, from scissors, to mice, to industrial machines.
+
+Some tools, like scissors, you can get a left-handed version of, of course. You can fill your house with physical coping mechanisms that help you function. But when you walk out into the world, you will find that nearly everything isn't designed for you.
+
+It's not fair, but
+
+* if you are left-handed, you must learn to be ambidextrous.
+* And if you have ADHD, you must learn to cope in a neurotypical world.
+
+---
+
+!\[\[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 markdown document available freely on github under a public domain licence.
+
+---
+
+!\[\[tris-fake-wikipedia-contents.png|600\]\] (My very real Wikipedia page)
+
+notes:
+
+As I mentioned in my coping mechanisms video, I have ADHD.
+
+I was diagnosed in school in the early 90s, and have recently started taking medication after an adult diagnosis.
+
+---
+
+## I Am not a Doctor
+
+[](#i-am-not-a-doctor)
+
+### I'm Hoping that Hearing My Story Could Be Helpful for Folks
+
+[](#im-hoping-that-hearing-my-story-could-be-helpful-for-folks)
+
+notes:
+
+#todo
+
+* screenshot this slide My adhd has profoundly shaped my life as a child and through to adulthood.
+
+I made this video to tell you my story, but also to share everything that I've learned along the way.
+
+---
+
+!\[\[becca-champ-headshot.png|300\]\]
+
+[patreon.com/rebeccachampuk](https://www.patreon.com/rebeccachampuk/)
+
+notes:
+
+In addition to drawing upon my own experience of ADHD, I must thank my friend Rebecca Champ, who is currently researching better treatment of ADHD in adults as part of her PhD.
+
+This video has been much improved by her involvement, do check out her Patreon where she posts about ADHD and her cutting-edge research.
+
+Let's start with the big question:
+
+---
+
+## Why Does it Seem Like
+
+[](#why-does-it-seem-like)
+
+## Everyone Has ADHD
+
+[](#everyone-has-adhd)
+
+## These Days?
+
+[](#these-days)
+
+notes:
+
+Why Does it Seem Like Everyone Has ADHD These Days?
+
+I think it's partly just the slow march of medical and diagnostic progress:
+
+The same proportion of the population have ADHD who have always had ADHD, but because we're able to diagnose and treat it so much better than even a decade or two ago, people are more aware of it.
+
+---
+
+!\[\[left-handedness-graph.png\]\]
+
+notes:
+
+## Left Handed Analogy
+
+[](#left-handed-analogy)
+
+It feels to me similar to the suppression of left-handedness in many countries around the turn of the last century, where children were forced to write with their right hand, despite more than a tenth of them favouring the left.
+
+This sinister practice died out in the 50s and the graph has been flat ever since, likely showing the true proportion of actual lefties.
+
+It's important to note that the number of naturally left-handed people didn't actually increase, the number of people learning to be left dominant increased because _we stopped persecuting them_
+
+---
+
+#### The Number Hasn't Increased
+
+[](#the-number-hasnt-increased)
+
+## We just Stopped
+
+[](#we-just-stopped)
+
+## Persecuting Them
+
+[](#persecuting-them)
+
+(maybe this explains other trends...)
+
+[](https://camo.githubusercontent.com/a5559bf8874fbc651ac1cdc6b96301f3f5724f88860cd26f9cb9e91bfdd0598c/68747470733a2f2f7777772e7072696465666c6167732e6f72672f7374617469632f7365617263682f646174612f696d672f70726f67726573735f70726964655f666c61672e737667)
+
+notes:
+
+This attitude shift for both left-handedness and ADHD is huge. And perhaps you can think of a few others that fit this pattern too.
+
+Instead of "Here's Timmy, he's a troublemaker" it's "Here's Timmy, he has ADHD"
+
+One of those comments is judgemental, and one of them is constructive.
+
+---
+
+## My Experience
+
+[](#my-experience)
+
+## Childhood
+
+[](#childhood)
+
+notes:
+
+I am extremely lucky. You can kind of reverse-engineer that from the knowledge that I'm a YouTuber. A lot of things had to align for us to be talking today.
+
+As a child I had extremely severe ADHD, then called ADD, as well as Dyslexia, plus the wildcard of Autism. What a winning hand!
+
+But in addition to those three interesting cards that fate dealt me, I had an ace. Or, two, up my sleeve:
+
+---
+
+!\[\[superman-and-wonderwoman.png\]\]
+
+(artist's impression)
+
+notes:
+
+Both my parents, in addition to being wonderful supportive people, taught in primary school.
+
+This experience meant that when their first-born son wasn't making eye contact as early as he should, and seemed more disruptive and distracted among other children, they took FAST action.
+
+And it saved my life.
+
+---
+
+_"Tristram spends most of his time organising his desk and looking around at what other students are doing. This doesn't affect his work **because he doesn't do any**."_
+
+### — My Childhood Report
+
+[](#-my-childhood-report)
+
+notes:
+
+My parents got me to a childhood psychologist who observed me in class, noting hilariously, that (quote)
+
+After the diagnosis of ADHD, my parents lined up all the help I needed, fighting council budgets in our small rural school.
+
+I didn't learn foreign languages as a teenager, I left my friends in these subjects and took lessons in the special education department, and had a dedicated Ancillary teacher to keep me on task in every lesson.
+
+I needed all this guidance to help align my left-handed ADHD brain into the right-handed Neurotypical world that was not set up for people like me.
+
+What's astonishing is that despite attending a state school, this was all provided for me for free.
+
+When I ask my parents how they managed it, they say that they simply would not take no for an answer.
+
+How lucky am I?
+
+---
+
+## So What is ADHD?
+
+[](#so-what-is-adhd)
+
+notes:
+
+If you have a broken leg, there's a clear underlying condition that explains your symptoms. But with mental health, you can't always see the source of the problems.
+
+ADHD, like many mental health conditions, is a classification of groups of symptoms that respond to common treatment, rather than a fixed underlying cause.
+
+There are many hypothesised causes of ADHD, and the most dominant model is a Dopamine imbalance.
+
+---
+
+## Dopamine Imbalance
+
+[](#dopamine-imbalance)
+
+notes:
+
+Dopamine is my favourite brain chemical, and yours too. It is part of the reward system in the brain. Dopamine encourages us to do activities that the brain thinks are good for us.
+
+Our brains give us a huge dopamine hit in anticipation of positive primal activities: eating fatty foods, exercise, sex, entertainment, and so on.
+
+But it also rewards us with a smaller amount of dopamine for doing more cerebral activities:
+
+* Cleaning your house,
+* getting an early start on that paper that is due next month
+* daily practising art and music, or
+* raking up leaves in the yard
+
+In short, non-urgent tasks that you could just ignore. Until you can't.
+
+When we are children, our dopamine system, and understanding of the world, is not developed yet. Our parents and teachers have to persuade us into doing non-primal but important tasks.
+
+Because we are rewarded by our parents and teachers for doing a Good Job in these endeavours, our brain, and dopamine system, learns this, and we start to build autonomous positive habits for ourselves.
+
+But what if this system works in an atypical way?
+
+---
+
+## The ADHD Child
+
+[](#the-adhd-child)
+
+notes:
+
+Imagine a child, like a young Tris, who doesn't get enough dopamine from doing good tasks.
+
+Even before they can speak, they are learning through constant chemical feedback that when they eat a lot, they get loads of dopamine - they feel good. Same with running around and playing, loads of dopamine there. FANTASTIC!
+
+But sitting quietly because mummy told us to? No dopamine. No positive chemical re-enforcement.
+
+And this is a powerful teacher.
+
+We are slaves to our brain chemistry, Dopamine especially, and children especially.
+
+So by the time the ADHD child goes to school, there is a marked difference in behaviour, and they ALL might be because of an atypical dopamine system:
+
+* ==They're not intentionally disruptive in class, they're choosing dopamine-rewarding behaviours.==
+* ==They're not greedy when eating, they're choosing dopamine-rewarding behaviours==
+* ==They're not unable to listen to you when you talk to them, they're choosing dopamine-rewarding behaviours==
+* ==They are not constantly distracted, they're constantly engaging in dopamine-rewarding behaviour, just as evolution has taught us all to do.==
+
+The problem is: The system is not working in the same way as the other children.
+
+---
+
+## Graduation
+
+[](#graduation)
+
+notes:
+
+With all this support, both in-school and outside, by the time I was 16, I was awarded "Most Improved" in our graduation ceremony, an award I felt was somewhat of a back-handed complement! And two years later. I was off to University.
+
+How did I get to university? To paraphrase Dave Lister, from Red Dwarf:
+
+---
+
+!\[\[lister-milkshake.png|800\]\]
+
+— Dave Lister (AKA Lister of Smeg, Cloister the Stupid, Sebastian Doyle, Skipper, Cinzano Bianco, Spanners)
+
+notes:
+
+> The normal way you get into University. The same old, usual, normal, boring way you get in. I failed my exams and applied.
+
+But now I was on my own, no-one could tell me to pay attention in class, they couldn't even force me out of bed to go to class.
+
+And self-direction is a nightmare for someone with ADHD.
+
+---
+
+## University Experimentation
+
+[](#university-experimentation)
+
+notes:
+
+Starting university, in 2004, I had access to broadband internet for the first time - imagine that!
+
+This allowed me to easily research ways to organise myself, what I would later come to know as _coping mechanisms_.
+
+At this stage, I thought I was cured. I had that 'most improved' award, after all. I was making eye contact like a champ, and my university grades were good.
+
+However, I knew that I was only scraping by. I was legendarily forgetful, missing both social and school appointments regularly.
+
+I started researching as much as I could, reading early Lifehacker articles and blog posts. I started building more coping mechanisms.
+
+* I had built enough of them for school, but not university
+* ==I no longer could get by on smarts, everyone's smart here==
+* But with the ADHD diagnosis, I was able to use the university's systems set up for people like me to just about get by.
+* By the end of university, fresh coping mechanisms in hand, I once again thought I was cured, and I began my career as a web developer.
+
+---
+
+## Professional Life
+
+[](#professional-life)
+
+notes:
+
+==Web development might be the best job in the world, it certainly was the best job for me:
+It's naturally structured, with the work often agreed upon by the team, and divided up into byte-sized tasks.==
+
+==The prevailing organisation system, scrum, had clear goals and structure that really worked for me, at least at first, it was like solving a puzzle or playing a video game, but every day.==
+
+And they were paying me to do it!
+
+I became senior very quickly, then team lead and everything was looking up.
+
+However, what I was experiencing was masking, not pure victory as I thought. And it happens to millions of people:
+
+---
+
+## ADHD Doesn't Present Strongly in a Structured & Deadline-Filled Environment
+
+[](#adhd-doesnt-present-strongly-in-a-structured--deadline-filled-environment)
+
+notes:
+
+==If you, like many folks,==
+
+* ==wake up to an alarm,==
+* ==commute to your job for 8 or 9am,==
+* ==do whatever work your boss tells you to do,==
+* ==commute home and eat and then sleep,==
+* ==only to do it all over again the next day.==
+
+==You might never notice you have ADHD.==
+
+==Symptoms like executive dysfunction and inattention might not affect you in the 9-to-5 grind.==
+
+But guess what happened in 2020.
+
+---
+
+## THANKS CORONA
+
+[](#thanks-corona)
+
+## I Hate it
+
+[](#i-hate-it)
+
+notes:
+
+Suddenly, your boss begged you NOT to come into the office, working from home became mandatory. And even after the lockdowns lifted, we discovered that in many cases, we didn't need the offices at all.
+
+It suddenly seemed like insanity to go from your home, where you have an internet connection and a computer, to sit in a noisy office where you have an internet connection and a computer.
+
+The collective dillusion of the Victorian workhouse was shattered by the coronavirus lockdowns.
+
+The world experimented, just briefly, with pausing infinite growth and grind:
+
+* Smog lifted in Beijing and Delhi,
+* Venice's canals ran clear, and
+* Working from home became the new standard.
+
+But this new-found autonomy, freedom, and self-direction was like a tsunami tide, first withdrawing and exposing all the rocks that were so carefully covered, and then returning, crashing down with the realisation that millions of people can't work outside the old frameworks.
+
+---
+
+## Let the Past Die
+
+[](#let-the-past-die)
+
+## Kill it if You Have to
+
+[](#kill-it-if-you-have-to)
+
+notes:
+
+The solution isn't to pack the people back into the workhouse again. We're past that, for all the sabre-rattling of CEOs to get back to the office, that boat has sailed. The leases on the offices have been given up, and white-collar worker's eyes have opened to the fact that they were being tricked into giving away hours of their life commuting for literally no reason.
+
+And the free market, darling of the very CEOs who demand the return to work, has seized upon this efficiency, and will not let it go.
+
+---
+
+## 2020
+
+[](#2020)
+
+notes:
+
+In 2020 I survived the apocalypse, literally and figuratively, though many people did not. Both figuratively and literally.
+
+Wfh did not seem to affect my ADHD like it did for so many others. I think this was because I was already working in an asynchronous highly structured way, my structure came from systems (like JIRA and Trello and scrum), not the physical office, and so didn't affect me much.
+
+The change for me came 2 years later:
+
+---
+
+## Self-Employment
+
+[](#self-employment)
+
+### Or
+
+[](#or)
+
+## Rust Ruined Everything
+
+[](#rust-ruined-everything)
+
+#### (In The Nicest Way)
+
+[](#in-the-nicest-way)
+
+notes:
+
+* THIS is where it fell apart for me, when I went full-time on this channel.
+* I created my first rust video (link) to show to a few colleagues who couldn't make my in-person unhinged sermon about this incredible language I'd found.
+ * I uploaded, sent the link to them, and it got 10 views and I thought nothing of it.
+ * 2 weeks later, my email stopped loading one sleepy Sunday because I received so many comments overnight.
+ * The algorithm gods had chosen me, and I started writing more videos.
+* After a whirlwind 6 months, I went full time on this channel, supported by my generous patrons.
+* I can't thank you enough, by the way
+
+---
+
+!\[\[patreon.png|200\]\]
+
+notes:
+
+It's just me running this channel, and I'm so grateful to everyone for supporting me on this wild adventure.
+
+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, Personal organisation, creative production, Web tech, or anything that I talk about in my videos, do sign up and let's chat!
+
+Back to my story:
+
+---
+
+## Executive Dysfunction
+
+[](#executive-dysfunction)
+
+notes:
+
+* But again, my ADHD caught up with me.
+* ==Right when I needed to be self-directed, to decide for myself what to spend each day doing.==
+* I found that I had a problem, and I needed more help.
+
+---
+
+## So how Do We Fix This Dopamine Imbalance?
+
+[](#so-how-do-we-fix-this-dopamine-imbalance)
+
+notes:
+
+If the common cause of ADHD might be so simple, can we just take a dopamine supplement and solve this all?
+
+Surprisingly, for mental health, yes, that's almost exactly what you can do. The medicine is simple, with few side-effects, and if you live in a developed country, available for free, but you must be diagnosed by a specialist.
+
+---
+
+## Adult Diagnosis
+
+[](#adult-diagnosis)
+
+For my UK friends, I went with [ADHD-360.com](https://www.adhd-360.com/)
+
+(not sponsored, obviously)
+
+notes:
+
+By this time it was September 2023, there was almost nowhere you could get an ADHD diagnosis, and those that were still accepting patients had multi-year waiting lists.
+
+After exhaustive research, I found a provider that was still accepting patients. They did this with a clever little hack of being extremely expensive.
+
+After sleeping on it, I decided that I might be repaid many times for my investment, and took the plunge.
+
+The next week I was diagnosed and had medication.
+
+---
+
+## Medication
+
+[](#medication)
+
+notes:
+
+ADHD medication can work wonders if you are being affected by the same dopamine imbalance as affects me.
+
+* They START you on medication for ADHD before much else.
+* Which is weird because in other conditions medication is usually the last resort.
+ * You typically try therapy and CBT before antidepressants, for example.
+* But ADHD meds are GOOD.
+
+---
+
+## ADHD Meds
+
+[](#adhd-meds)
+
+## Are GOOD
+
+[](#are-good)
+
+notes:
+
+#todo
+
+* re-take and re-record this slide
+
+The path onto ADHD meds can run a lot smoother than when you first start taking other similarly wonderful, life-saving medicines. It is easier to find the right ADHD drug for you, there are fewer side effects, and you don't have to take them for long periods of time to let them build up slowly, unlike (say) antidepressants.
+
+As there is no pill for autism yet, ADHD is my first personal experience with daily medication.
+
+Some of my friends take antidepressants, and it sounds tough. Worth it, let me be clear, but tough at first, before they start working for you.
+
+This is nothing like my experience with ADHD meds.
+
+---
+
+## Properties of ADHD Stimulants
+
+[](#properties-of-adhd-stimulants)
+
+* No dependence/withdrawal
+* Lower the dose some days to suit you
+* Start and stop whenever suits you
+* Treatment holidays encouraged
+* Side effects are very slight
+
+notes:
+
+* There's no withdrawal symptoms apart from your ADHD symptoms returning
+* Some days you don't need a full dose. It is safe to dial your dose up and down, after initial titration (the week or two at the start where you and your doctor are figuring out the right dose for you).
+* Some days, perhaps lazy Saturdays, you can skip the meds altogether, and take a break to watch cartoons on the sofa all day.
+* Treatment holidays every year or so are encouraged because with the space the meds gave you, you might have built enough coping mechanisms to function well enough, like I did until this year. If so, you can stop taking them, or reduce their frequency.
+* Though your doctor will talk to you about your specific medication's side effects, for me, I only experienced two:
+ * Headache for the first few days,
+ * and euphoria.
+
+The headache was due to dehydration. I felt like in the first week as I was getting used to them, I needed to drink a little more than usual, perhaps a litre more per day. But after a few more weeks that settled down.
+
+The second side effect, euphoria, was very funny.
+
+---
+
+## ADHD Medication Made Me Feel Fantastic
+
+[](#adhd-medication-made-me-feel-fantastic)
+
+notes:
+
+I noticed I was feeling really positive, energized and happy, and I also noticed the word 'euphoria' in the side effects list for what I was taking.
+
+Though I knew that the medication was so low dose that this probably wasn't some chemical high, it did make me wonder!
+
+I mentioned it at my monthly catchup call with my specialist, as we made sure the medication and dose were working for me.
+
+He laughed and confirmed that I wasn't getting high, but nonetheless, it was a common side-effect of taking ADHD medicine.
+
+---
+
+## Imagine
+
+[](#imagine)
+
+## Being in Control of Your Life
+
+[](#being-in-control-of-your-life)
+
+notes:
+
+The happiness I was feeling was that I could finally focus!
+
+To retrain my behaviour from desperately seeking dopamine in distractions, to quietly working on what I want to do:
+
+* Long hours of script writing for these videos, or
+* Long hours of focussed music composition, or
+* Long hours of quality chats with friends, where I actually talk about what I intend to talk about, ==not whatever random thoughts popped into my mind==
+
+I wish this quiet focus for everyone with ADHD, but getting diagnosed is not just difficult because of the medical system overheads.
+
+A big problem is the stigma about seeing your doctor in the first place.
+
+---
+
+!\[\[south-park-drug-free-treatment.png\]\]
+
+'Drug-free ADD treatment' in S4E3 of _South Park_, 2000
+
+notes:
+
+Treatment of ADHD, or ADD as it was known when I was first diagnosed in the 90s, is plagued by stigma, still.
+
+When I was growing up, most media portrayed ADHD kids as loud troublemakers or inattentive slow-wits. The medicines are in the amphetamine family, a word that is more often associated with ravers, not doctors, despite it being an enormous category of common medicines that all do very different things in the brain.
+
+---
+
+## If Your Body Doesn't Make the Chemicals You Want
+
+[](#if-your-body-doesnt-make-the-chemicals-you-want)
+
+## Store Bought is Fine
+
+[](#store-bought-is-fine)
+
+notes:
+
+We now know better, and we have really excellent treatment options.
+
+My medication is one-a-day, slow-release, and with such a small dose that I barely notice a difference when I'm taking it. I have to look back on my day and think "yeah, that was a good day, I got a lot of stuff done!" before I notice.
+
+There are many medicine options to choose from if you don't like the first one you and your doctor try out.
+
+If it's half as affective with you as it has been for me, it'll still be incredible.
+
+---
+
+## Lessons Learned
+
+[](#lessons-learned)
+
+* This is all very new
+* Drugs are good
+* Deadlines are good
+* Checklists are good
+* Study your Triggers and Habits
+ * Then improve them
+* Routines are good
+* Breaks are important
+
+notes:
+
+ADHD is a modern diagnosis of a challenge that people have been dealing with as long as there have been people. The diagnosis has been available to Boys for the longest, but girls and women and adult men are now finally allowed to have ADHD, as a little treat.
+
+It was only in 1994 that the first conference to discuss gender differences in ADHD was held. And the Adult diagnosis was only agreed-upon and formalised in 2013.
+
+---
+
+## "Attention Deficit Hyperactivity Disorder"
+
+[](#attention-deficit-hyperactivity-disorder)
+
+notes:
+
+The name is still a problem, and names have power. "Attention Deficit Hyperactivity Disorder"
+
+It sounds very judgemental, doesn't it? As someone with Autism, I don't have a deficit of social skills, or whatever. The name is non-judgemental.
+
+Our understanding is still evolving, and even the dominant Dopamine model I described today is subject to criticism and new research.
+
+(check out Rebecca Champ's published work for details there)
+
+---
+
+## ADHD and Societal Problems
+
+[](#adhd-and-societal-problems)
+
+notes:
+
+It's possible we evolved these ADHD behaviours because of wider population benefits. It might have been bad for the individual, but in pre-historic times, perhaps good for the whole to have a mix of neurotypical and neurodivergent folks.
+
+We're past that now, we don't have to take one for the team any more!
+
+There is a troubling trend that ADHD behaviours are dramatically over-represented in prison populations. Perhaps spiralling dopamine-rewarding behaviours can get out of hand in some people, or, simply, that if you don't fit in to neurotypical society, you can fall out of it.
+
+==Though illegal drugs famously can boost dopamine, so can caffeine and chocolate.== You don't have to look very far for behaviours that increase dopamine that are not always good for you.
+
+When getting a diagnosis, even for the newly-recognised adult ADHD, pre-existing childhood symptoms are essential to find for the medical professional because otherwise it could represent a recent, new condition, and that could be an emergency.
+
+Don't let this historical requirement put you off. If you have ADHD today, you very likely had it as a child. Your doctor will help you.
+
+---
+
+!\[\[coping-video-thumb-build-habits.png\]\]
+
+_"[Hack Your Brain With Elaborate Coping Mechanisms](https://www.youtube.com/watch?v=XUZ9VATeF%5F4)"_
+
+notes:
+
+I couldn't fit all my advice in this script today: I talked about 18 of my elaborate coping mechanisms in a previous video, pinned here and linked in the description, do watch that for more detail on what I do to manage my life day-to-day.
+
+If some of what I've said has struck a chord in you, talk to your doctor.
+
+I was very fortunate to be able to pay for a quicker diagnosis than many of my friends.
+
+But even if I couldn't afford that, my advice to my past self would be the same as to anyone: The wait is worth it, start the ball rolling today.
+
+---
+
+!\[\[tri-hex-moon-white-transparent.png|300\]\]
+
+## Thank You
+
+[](#thank-you)
+
+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 sourcecode 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. \`\`
\ No newline at end of file
diff --git a/Omnivore/2024-03-26 - How Do Open Source Software Lifecycles Work-.md b/Omnivore/2024-03-26 - How Do Open Source Software Lifecycles Work-.md
new file mode 100644
index 0000000..03d8d73
--- /dev/null
+++ b/Omnivore/2024-03-26 - How Do Open Source Software Lifecycles Work-.md
@@ -0,0 +1,166 @@
+---
+id: 7ec51414-ec16-11ee-9d24-0f20db024fdd
+title: |
+ How Do Open Source Software Lifecycles Work?
+status: ARCHIVED
+tags:
+ - read-later
+ - RSS
+date_added: 2024-03-26 14:01:50
+url_omnivore: |
+ https://omnivore.app/me/how-do-open-source-software-lifecycles-work-18e7f16d0ba
+url_original: |
+ https://www.freecodecamp.org/news/understanding-open-source-software-lifecycles/
+---
+
+# How Do Open Source Software Lifecycles Work?
+
+## Highlights
+
+* There's the **alpha release** – an initial version of software that is typically not feature-complete and is not intended for use by the general public. It is used for testing and internal use only.
+* A **beta release** is a pre-release version of software that is feature-complete but may still have bugs or other issues. It is released to a limited audience for testing and feedback before the final release.
+* Next will be a **release candidate**, which is a version of software that is considered stable and ready for release, pending final testing and bug fixes.
+* And finally you'll produce a **general availability release** as the final version of software that's released to the general public.
+
+[source](https://omnivore.app/me/how-do-open-source-software-lifecycles-work-18e7f16d0ba#e773fb30-19c5-435e-b694-3dc361102961)
+
+---
+
+Major releases are typically used for significant changes or new features that are not backward compatible with previous versions. Major releases are usually announced to users and customers with a lot of fanfare, as they represent a significant milestone in the development of the software.
+
+Minor releases, on the other hand, are used for smaller changes or new features that are backward compatible with previous versions. Minor releases are typically released more frequently and are intended to provide users with incremental improvements to the software.
+
+[source](https://omnivore.app/me/how-do-open-source-software-lifecycles-work-18e7f16d0ba#a3fc7d71-2005-47d8-ae20-ad8ba83d0096)
+
+---
+
+Backward compatibility is the ability of a newer version of software or system to work with files, data, and other components created in an older version of that software or system. This means that users can upgrade to the newer version without losing access to their existing data or files.
+
+[source](https://omnivore.app/me/how-do-open-source-software-lifecycles-work-18e7f16d0ba#a2e6d179-5650-4258-aeca-c97135d5cbd1)
+
+---
+
+Feature freeze is a stage in the software development process where no new features are added to the product or project. It is typically implemented as a deadline by which all new features must be completed and approved before the release of the software product.
+
+[source](https://omnivore.app/me/how-do-open-source-software-lifecycles-work-18e7f16d0ba#8f0133c9-d2fd-4bd5-ad62-6e5bbb42fd39)
+
+---
+
+A roadmap is a high-level strategic document that outlines the goals, objectives, and timeline for a software product's development. It provides a visual representation of the product development plan, outlining key milestones and the expected timeline for completion.
+
+[source](https://omnivore.app/me/how-do-open-source-software-lifecycles-work-18e7f16d0ba#15a5ff9c-9ba1-423a-9ee3-a4e9359ee251)
+
+---
+
+A changelog is a document that lists the changes made to a software product over time, including bug fixes, new features, and other updates. Changelogs allow developers and other stakeholders to understand what's been updated and when.
+
+[source](https://omnivore.app/me/how-do-open-source-software-lifecycles-work-18e7f16d0ba#49c22f66-4cae-4b35-9830-8ca179e57c1c)
+
+---
+
+Long term support refers to a software version that is designated for longer-term support and maintenance, typically for a period of several years. During this time, the software vendor provides ongoing support, including bug fixes, security updates, and other maintenance activities.
+
+[source](https://omnivore.app/me/how-do-open-source-software-lifecycles-work-18e7f16d0ba#44327f2b-0570-483f-9aa4-d73ba0a88d18)
+
+---
+
+end-of-life refers to a point in time when a software version is no longer supported by the vendor. This means that the vendor will no longer provide
+
+[source](https://omnivore.app/me/how-do-open-source-software-lifecycles-work-18e7f16d0ba#88586f0a-919d-4ce9-b50a-dc2c4176950e)
+
+---
+
+## Original
+
+
+
+Software projects follow identifiable milestones as they move towards a successful completion. If you want to give your project the best chances of success, it's important to understand what those milestones mean and how they're defined.
+
+This article comes from my Complete LPI Open Source Essentials Exam Study Guide [Udemy course](https://www.udemy.com/course/complete-lpi-open-source-essentials-exam-study-guide/?referralCode=05B999CE18EF4D6E243C) and [book](https://www.amazon.com/dp/B0CK3Q8DCF). You can also [view the video version](https://youtu.be/eZ%5F4DLVxs7Q).
+
+## What are Software Releases?
+
+There are several types of software releases and some related versioning methods used to keep track of software changes and to communicate them to users. We'll start with releases.
+
+* ==There's the== **==alpha release==** ==– an initial version of software that is typically not feature-complete and is not intended for use by the general public. It is used for testing and internal use only.==
+* ==A== **==beta release==** ==is a pre-release version of software that is feature-complete but may still have bugs or other issues. It is released to a limited audience for testing and feedback before the final release.==
+* ==Next will be a== **==release candidate==**==, which is a version of software that is considered stable and ready for release, pending final testing and bug fixes.==
+* ==And finally you'll produce a== **==general availability release==** ==as the final version of software that's released to the general public.==
+
+## What is Software Versioning?
+
+Software versioning (sometimes known as semantic versioning) is the practice of assigning unique version numbers to different releases of software.
+
+Here's a useful example:
+
+```angelscript
+vmlinuz-5.19.0-40-generic
+```
+
+In some approaches, the first number in the version number ("5" in this case) is the major version. A major version change indicates significant changes or new features that are not backward compatible with previous versions.
+
+The second number ("19") is the minor version. A minor version change indicates new features or functionality that are backward compatible with previous versions.
+
+The third number in the version number ("0") is the patch version. A patch version change indicates bug fixes or minor changes that are backward compatible with previous versions.
+
+Why distinguish between major and minor releases? ==Major releases are typically used for significant changes or new features that are not backward compatible with previous versions. Major releases are usually announced to users and customers with a lot of fanfare, as they represent a significant milestone in the development of the software.==
+
+==Minor releases, on the other hand, are used for smaller changes or new features that are backward compatible with previous versions. Minor releases are typically released more frequently and are intended to provide users with incremental improvements to the software.==
+
+## What Does Backward Compatibility Mean?
+
+==Backward compatibility is the ability of a newer version of software or system to work with files, data, and other components created in an older version of that software or system. This means that users can upgrade to the newer version without losing access to their existing data or files.==
+
+For example, let's assume a user has created a document in an older version of a word processing program. If the newer version of the program is backward compatible, the user can open and edit the same document without any issues. This is because the newer version of the program is designed to read and interpret the file format used in the older version.
+
+However, if the newer version of the program is not backward compatible, the user may not be able to open or edit the file created in the older version without first converting or re-creating it in the newer version. This can be a significant inconvenience for users and can lead to compatibility issues and data loss.
+
+Here are some more quick – but important – definitions.
+
+## Feature Freeze
+
+==Feature freeze is a stage in the software development process where no new features are added to the product or project. It is typically implemented as a deadline by which all new features must be completed and approved before the release of the software product.==
+
+The primary goal of a feature freeze is to stabilize the software product in preparation for release. By setting a feature freeze deadline, developers can focus on completing and testing existing features rather than introducing new ones. This allows time for rigorous testing and bug fixing, improving the overall quality and reliability of the software product.
+
+## Roadmaps
+
+==A roadmap is a high-level strategic document that outlines the goals, objectives, and timeline for a software product's development. It provides a visual representation of the product development plan, outlining key milestones and the expected timeline for completion.==
+
+Roadmaps are useful for communicating the overall direction of a software product to stakeholders, including developers, product managers, investors, and customers.
+
+## Milestones
+
+Milestones are specific, measurable achievements that mark progress towards the completion of a software product. They're typically set at regular intervals throughout the development process and are used to track progress and ensure that the project stays on schedule.
+
+Examples of milestones might include the completion of a specific feature, the successful completion of a testing phase, or the release of a beta version of the software product.
+
+## Changelog
+
+==A changelog is a document that lists the changes made to a software product over time, including bug fixes, new features, and other updates. Changelogs allow developers and other stakeholders to understand what's been updated and when.==
+
+Changelogs are particularly useful for software products that are updated frequently or have a large number of contributors.
+
+## Long Term Support (LTS)
+
+==Long term support refers to a software version that is designated for longer-term support and maintenance, typically for a period of several years. During this time, the software vendor provides ongoing support, including bug fixes, security updates, and other maintenance activities.==
+
+LTS versions are often used in enterprise environments where stability and reliability are critical. In April of each even year, for example, Canonical will release an LTS version of Ubuntu. These versions are normally supported for four or five years.
+
+## End of Life (EOL)
+
+On the other hand, ==end-of-life refers to a point in time when a software version is no longer supported by the vendor. This means that the vendor will no longer provide== updates or fixes for the software, and any security vulnerabilities or bugs that are discovered will not be addressed. This can leave users with unsupported software that may be prone to security risks and other issues.
+
+When a software product reaches its end-of-life, it is typically retired, and users are encouraged to upgrade to a newer version or switch to a different product. The EOL process is often gradual, with the vendor providing advance notice and guidance to users to help them migrate to a new version or product.
+
+## Conclusion
+
+You've seen how it's important to understand the stages through which successful software projects will move. And this isn't just theoretical, because this knowledge gives you the tools to track your progress and quickly identify when things are going off rails.
+
+__This article comes from my [_Complete LPI Open Source Essentials Study Guide course](https://www.udemy.com/course/complete-lpi-open-source-essentials-exam-study-guide/?referralCode=05B999CE18EF4D6E243C)_. And there's much more technology goodness available at [bootstrap-it.com](https://bootstrap-it.com/)_
+
+---
+
+---
+
+ 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/)
\ No newline at end of file
diff --git a/Omnivore/2024-03-27 - The Complete Guide to Time Blocking.md b/Omnivore/2024-03-27 - The Complete Guide to Time Blocking.md
new file mode 100644
index 0000000..8843590
--- /dev/null
+++ b/Omnivore/2024-03-27 - The Complete Guide to Time Blocking.md
@@ -0,0 +1,307 @@
+---
+id: 04745848-2b0d-482d-802c-8872ac9043dd
+title: |
+ The Complete Guide to Time Blocking
+status: ARCHIVED
+tags:
+ - read-later
+date_added: 2024-03-27 20:34:53
+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
+
+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)
+
+---
+
+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)
+
+---
+
+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)
+
+---
+
+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)
+
+---
+
+time boxing asks you to limit how much time you'll dedicate to a specific task.
+
+> [!note]
+> Is _"I'm gonna finish this in X time"_, instead of _"I'm gonna work on this for X time"_
+
+[source](https://omnivore.app/me/https-todoist-com-productivity-methods-time-blocking-18bbc432143#e342c6ce-607b-4482-af54-4ffbf81ab7ab)
+
+---
+
+## Original
+
+* Why is time blocking so effective?
+* But will time blocking work with my job?
+* Some common time blocking missteps and how to avoid them
+* 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.
+
+We've made a companion [video for time blocking](https://youtu.be/FLxt4Sbpud4) because everyone learns differently and we know some of you prefer to watch instead of read. Check out that video below, or continue reading for a deeper dive.
+
+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.
+
+## 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.
+
+
+
+### 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.
\ No newline at end of file
diff --git a/Omnivore/2024-03-29 - Let's Save the (Git) Trees.md b/Omnivore/2024-03-29 - Let's Save the (Git) Trees.md
new file mode 100644
index 0000000..f98449b
--- /dev/null
+++ b/Omnivore/2024-03-29 - Let's Save the (Git) Trees.md
@@ -0,0 +1,91 @@
+---
+id: 228a5a0a-eded-11ee-9840-8b8ae5e4b6f0
+title: |
+ Let's Save the (Git) Trees
+status: ARCHIVED
+tags:
+ - read-later
+ - Newsletter
+date_added: 2024-03-29 13:55:23
+url_omnivore: |
+ https://omnivore.app/me/let-s-save-the-git-trees-18e8b23331a
+url_original: |
+ https://omnivore.app/no_url?q=b542dc42-874d-446c-84a7-6c02bf819f29
+---
+
+# Let's Save the (Git) Trees
+
+## Highlights
+
+We start using something called **interactive rebase** on our feature branches. It’s really just a way to clean up our commit history before we merge it into the main branch. This might change the history, but since it’s just on our own feature branches, it doesn’t mess up anything for everyone else.
+
+[source](https://omnivore.app/me/let-s-save-the-git-trees-18e8b23331a#0f14f09a-7965-46bd-bc32-d4eede7e821c)
+
+---
+
+Here’s a quick guide on how to do it:
+
+1. **Start on Your Feature Branch:**`git checkout -b my-feature`
+2. **Grab the Latest Main Branch Updates Without Switching:**`git fetch origin main:main` (using `main:main` is a trick to fetch remote main changes to the local copy without switching back and forth)
+3. **Interactive Rebase Time:**`git rebase main --interactive` \- This lets us pick and choose which commits to keep or squash, change the commits you want to `s` to make sure git squashes them into the parent commit, while keeping the changes.
+4. **Safely Update the Remote Branch:**`git push --force-with-lease` \- This flag makes sure we don’t accidentally overwrite anyone else’s work.
+5. **Prepare to Merge:**`git checkout main`
+6. **Merge Without Extra Commits:**`git merge --ff-only -` \- Keeps our history straight by avoiding merge commits.
+7. **Push it Up:**`git push` \- And we’re done!
+
+[source](https://omnivore.app/me/let-s-save-the-git-trees-18e8b23331a#abe6a553-9d96-4f41-aba2-73ad21e3e86a)
+
+---
+
+## Original
+
+Hi friends,
+
+You know how companies use merge commits when working on projects?
+
+Just go to one of your work projects and checkout the history of the main branch. It may look tidy (or not) but it’s bad for the environment (the real-world one 😉)
+
+
+
+Lots of merge commits
+
+While that’s pretty standard, it actually makes things messy.
+
+Every time we do this, it stops us from keeping our commit history nice and clean all the way through from development to production.
+
+Here’s why that’s a bit of a problem: if we’ve already **built and tested** a commit, **installing dependencies** in the process and **storing** all its details, there’s really no need to go through all that again.
+
+It’s like doing the same work twice, which wastes time and resources, which translate to environmental effects that compound and another financial waste if that’s not enough.
+
+Plus, a cleaner git history makes it easier for us to figure out issues. It helps us use tools like `git bisect` much more effectively to find bugs. But we’ll talk more about that another time.
+
+So, what’s the solution?
+
+==We start using something called== **==interactive rebase==** ==on our feature branches. It’s really just a way to clean up our commit history before we merge it into the main branch. This might change the history, but since it’s just on our own feature branches, it doesn’t mess up anything for everyone else.==
+
+
+
+Rebasing 3 commits into one with interactive rebase
+
+==Here’s a quick guide on how to do it:==
+
+1. **==Start on Your Feature Branch:==**`==git checkout -b== ==my====-feature==`
+2. **==Grab the Latest Main Branch Updates Without Switching:==**`==git== ==fetch== ==origin== ==main====:main==` ==(using== `==main:====main==` ==is a trick to fetch remote main changes to the local copy without switching back and forth)==
+3. **==Interactive Rebase Time:==**`==git rebase main== ==--interactive==` ==- This lets us pick and choose which commits to keep or squash, change the commits you want to== `==s==` ==to make sure git squashes them into the parent commit, while keeping the changes.==
+4. **==Safely Update the Remote Branch:==**`==git push --====force====-====with====-lease==` ==- This flag makes sure we don’t accidentally overwrite anyone else’s work.==
+5. **==Prepare to Merge:==**`==git checkout main==`
+6. **==Merge Without Extra Commits:==**`==git== ==merge== ==--ff-====only== ==-==` ==- Keeps our history straight by avoiding merge commits.==
+7. **==Push it Up:==**`==git== ==push==` ==- And we’re done!==
+
+By making this part of what we do every day, our git trees will stay clean and easy to work with.
+
+Hope you find this helpful! Always happy to hear your thoughts or answer any questions.
+
+Enjoy your weekend!
+
+_**Whenever you’re ready, here’s how I can help you**_
+
+* [Follow me on X / Twitter](https://click.convertkit-mail2.com/qduo9vo0l2f7h7pwe7eulhnpxowkk/wnh2hghw84rpw8h7/aHR0cHM6Ly90d2l0dGVyLmNvbS9kZXZvcHN0b29sYm94) for the occasional tips and tricks on better workflows
+* [Building a Second Brain with Neovim in Under 90 Minutes ](https://click.convertkit-mail2.com/qduo9vo0l2f7h7pwe7eulhnpxowkk/reh8hoh0n7qr0ka2/aHR0cHM6Ly9sZWFybi5vbWVyeHguY29tL2NvdXJzZXMvc2Vjb25kLWJyYWluLW5lb3ZpbQ==)My first course, discussing the basics of building a second brain using the PARA and CODE methods, combined with Obsidian and Neovim as an editor. Join 200+ enrolled students here
+
+[](https://click.convertkit-mail2.com/qduo9vo0l2f7h7pwe7eulhnpxowkk/08hwh9hdqxm5dvul/aHR0cHM6Ly9jb252ZXJ0a2l0LmNvbS9mZWF0dXJlcy9lbWFpbC1tYXJrZXRpbmc%5FdXRtX2NhbXBhaWduPXBvd2VyZWRieSZ1dG1fY29udGVudD1lbWFpbCZ1dG1fbWVkaXVtPXJlZmVycmFsJnV0bV9zb3VyY2U9ZHluYW1pYw==)
\ No newline at end of file
diff --git a/Omnivore/2024-04-18 - Unix sockets, the basics in Rust - Emmanuel Bosquet.md b/Omnivore/2024-04-18 - Unix sockets, the basics in Rust - Emmanuel Bosquet.md
new file mode 100644
index 0000000..3152340
--- /dev/null
+++ b/Omnivore/2024-04-18 - Unix sockets, the basics in Rust - Emmanuel Bosquet.md
@@ -0,0 +1,239 @@
+---
+id: 3f72e613-eb8e-446b-93b5-fdb275a781c0
+title: |
+ Unix sockets, the basics in Rust - Emmanuel Bosquet
+status: ARCHIVED
+tags:
+ - read-later
+date_added: 2024-04-18 20:15:21
+url_omnivore: |
+ https://omnivore.app/me/unix-sockets-the-basics-in-rust-emmanuel-bosquet-18ef3b52a37
+url_original: |
+ https://emmanuelbosquet.com/2022/whatsaunixsocket/
+---
+
+# Unix sockets, the basics in Rust - Emmanuel Bosquet
+
+## Notes
+
+This will be useful someday...
+when I want to try to build my own TCP server or something like that
+## Original
+
+## Contents
+
+* [What is a unix socket?](#what-is-a-unix-socket)
+* [Create a socket, server side](#create-a-socket-server-side)
+* [Waiting for connections, server side](#waiting-for-connections-server-side)
+* [Connecting to the socket, client side](#connecting-to-the-socket-client-side)
+* [Writing on the socket, client side](#writing-on-the-socket-client-side)
+* [Reading from the socket, server side](#reading-from-the-socket-server-side)
+ * [Launch the whole thing!](#launch-the-whole-thing)
+* [Respond to a message, server side](#respond-to-a-message-server-side)
+* [Listen to responses, client side](#listen-to-responses-client-side)
+ * [Launch the whole thing, again!](#launch-the-whole-thing-again)
+* [Browse the code](#browse-the-code)
+
+I found myself wondering about unix sockets while working on [Sōzu](https://github.com/sozu-proxy/sozu), a reverse proxy written in Rust. A bunch of Sōzu issues led me to[dig into Sōzu channels](https://github.com/Keksoj/stream%5Fstuff%5Fon%5Fa%5Fsozu%5Fchannel), which themselves make use of[Metal I/O ’s implementation of unix sockets](https://tokio-rs.github.io/mio/doc/mio/net/struct.UnixListener.html).
+
+Here are the questions, summed up:
+
+* what are unix sockets?
+* how can we create them in Rust?
+* how do we use them to stream data?
+
+So here we go.
+
+It is _not_ a web socket like `127.0.0.1:8080`.
+
+You may have heard that in unix,[everything is a file](https://www.youtube.com/watch?v=dDwXnB6XeiA). Unix sockets seem to be a good example of this principle. They are empty files of sorts, only there to be written to, and read from.
+
+Sockets are a core feature of unix. In fact, if you type
+
+```ebnf
+man unix
+
+```
+
+in your terminal, you should land on an ancient man page:
+
+| 1 2 3 4 5 | UNIX(7) Linux Programmer's Manual UNIX(7) NAME unix - sockets for local interprocess communication |
+| --------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
+
+that explains how sockets are declared in C in the kernel, how they are created with the `AF_UNIX` system call, and many more thing that go far beyond my limited understanding.
+
+Creating a socket is not as easy as creating just any file, using, say, `touch`. They are tools available in the command line, but most of the time, sockets are created and used by processes, not by users. Looking up how to create one will land you on a tutorial in C, or in python. So let’s see how to do it in Rust.
+
+The Rust standard library has a [std::os::unix module](https://doc.rust-lang.org/std/os/unix/index.html)to interact with unix processes, unix files, and so on. Within it, we want to look at the `net` module, named that way because unix sockets are used to do networking between processes.
+
+The `std::os::unix::net` module contains, among other things:
+
+* [UnixListener](https://doc.rust-lang.org/std/os/unix/net/struct.UnixListener.html)
+* [UnixStream](https://doc.rust-lang.org/std/os/unix/net/struct.UnixStream.html)
+
+Both those entities are unsafe wrappers of the `libc` library to perform the very same unix system calls you would write in C. They both wrap a unix file descriptor, but they are distinct in order to separate higher-level concerns.
+
+* `UnixListener` is used to create sockets, (`libc::bind()` and `libc::listen()`)
+* `UnixStream` is there to connect to a socket (`libc::connect()`), to read from it and write on it.
+
+Let’s use those.[Install Rust and Cargo](https://www.rust-lang.org/tools/install),[Learn the basics of Rust](https://doc.rust-lang.org/book/), and then do:
+
+```haxe
+cargo new unix_sockets
+
+```
+
+Add this to `Cargo.toml` (makes error propagation easier):
+
+| 1 2 | \# Cargo.toml anyhow \= "^1.0.42" |
+| --- | --------------------------------- |
+
+In the `src` directory, create a `bin` directory, in which you will create a `server.rs` file.
+
+| 1 2 3 4 5 6 7 8 9 10 11 12 13 | // src/bin/server.rs use std::os::unix::net::{UnixListener, UnixStream}; use anyhow::Context; fn main() -> anyhow::Result<()> { let socket\_path = "mysocket"; let unix\_listener = UnixListener::bind(socket\_path).context("Could not create the unix socket")?; Ok(()) } |
+| ------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+
+Then do
+
+```routeros
+cargo run --bin server
+
+```
+
+Which should run smoothly, and then do `ls -l` in your directory, you should have a line like this:
+
+```routeros
+srwxr-xr-x 1 emmanuel users 0 Jan 7 13:08 mysocket
+
+```
+
+The `s` stands for _socket_. Congratulations!
+
+Do one more `cargo run --bin server` and you have a neat, self-explanatory OS error:
+
+| 1 2 3 4 | Error: Could not create the unix socket Caused by: Address already in use (os error 98) |
+| ------- | ------------------------------------------------------------------------------------------- |
+
+I guess we’ll have to destroy it and recreate it each time.
+
+| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | // src/bin/server.rs use std::os::unix::net::{UnixListener, UnixStream}; use anyhow::Context; fn main() -> anyhow::Result<()> { let socket\_path = "mysocket"; // copy-paste this and don't think about it anymore // it will be hidden from there on if std::fs::metadata(socket\_path).is\_ok() { println!("A socket is already present. Deleting..."); std::fs::remove\_file(socket\_path).with\_context(\|| { format!("could not delete previous socket at {:?}", socket\_path) })?; } let unix\_listener = UnixListener::bind(socket\_path).context("Could not create the unix socket")?; Ok(()) } |
+| ---------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+
+The `UnixListener` struct has an `accept()` method that waits for other processes to connect to the socket. Once a connections comes, `accept()` returns a tuple containing a `UnixStream` and a `SocketAddr`.
+
+As mentioned above, `UnixStream` implements `Read` and `Write`. We will handle this stream to:
+
+* read what another process will send through the socket
+* write responses on the socket
+
+Add the loop and the `handle_stream` function to the server code:
+
+| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | // src/bin/server.rs use std::os::unix::net::{UnixListener, UnixStream}; fn main() -> anyhow::Result<()> { let socket\_path = "mysocket"; let unix\_listener = UnixListener::bind(socket\_path).context("Could not create the unix socket")?; // put the server logic in a loop to accept several connections loop { let (mut unix\_stream, socket\_address) = unix\_listener .accept() .context("Failed at accepting a connection on the unix listener")?; handle\_stream(unix\_stream)?; } Ok(()) } fn handle\_stream(mut stream: UnixStream) -> anyhow::Result<()> { // to be filled Ok(()) } |
+| ------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+
+Remove the existing socket and run the code:
+
+```routeros
+cargo run --bin server
+
+```
+
+it should hang. Perfect! The server is waiting for connections!
+
+The client process wants to connect to an existing socket, read and write from it.
+
+Next to `server.rs`, create the `client.rs` file. The client will merely consist of a `UnixStream`:
+
+| 1 2 3 4 5 6 7 8 9 10 11 12 | // src/bin/client.rs use std::os::unix::net::{UnixListener, UnixStream}; use anyhow::Context; fn main() -> anyhow::Result<()> { let socket\_path = "mysocket"; let mut unix\_stream = UnixStream::connect(socket\_path).context("Could not create stream")?; Ok(()) |
+| ---------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+
+We need to import the `Read` and `Write` traits.
+
+| 1 2 | // src/bin/client.rs use std::io::{Read, Write}; |
+| --- | ------------------------------------------------ |
+
+And now we can write onto the stream. Below the `unix_stream` declaration, add the write logic:
+
+| 1 2 3 | unix\_stream .write(b"Hello?") // we write bytes, &\[u8\] .context("Failed at writing onto the unix stream")?; |
+| ----- | ---------------------------------------------------------------------------------------------------------------------------- |
+
+Be sure to import `Read` and `Write` in `server.rs`:
+
+| 1 2 | // src/bin/server.rs use std::io::{Read, Write}; |
+| --- | ------------------------------------------------ |
+
+Now let’s fill the `handle_stream` function with ordinary read logic:
+
+| 1 2 3 4 5 6 7 8 9 10 | // src/bin/server.rs fn handle\_stream(mut unix\_stream: UnixStream) -> anyhow::Result<()> { let mut message = String::new(); unix\_stream .read\_to\_string(&mut message) .context("Failed at reading the unix stream")?; println!("{}", message); Ok(()) } |
+| ---------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+
+Make sure you have the server running in a terminal:
+
+```routeros
+cargo run --bin server
+
+```
+
+And in a separate terminal, run the client:
+
+```routeros
+cargo run --bin client
+
+```
+
+If all is well, the hello message should display on the server side.
+
+Let’s answer something every time the server receives anything.
+
+| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | // src/bin/server.rs fn handle\_stream(mut unix\_stream: UnixStream) -> anyhow::Result<()> { let mut message = String::new(); unix\_stream .read\_to\_string(&mut message) .context("Failed at reading the unix stream")?; println!("We received this message: {}\\nReplying...", message); unix\_stream .write(b"I hear you!") .context("Failed at writing onto the unix stream")?; Ok(()) } |
+| ------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+
+Introducing the same reading logic we used on the server **will not work**. Why? After writing on a stream, we need to shut down the writing, if we want to read from it.
+
+Let’s segregate the write and read logic into distinct functions. Oh, and we pass mutable references (`&mut`) of the unix stream to the function, because… Rust. Don’t worry about it.
+
+| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | // src/bin/client.rs use std::io::{Read, Write}; use std::os::unix::net::{UnixListener, UnixStream}; use anyhow::Context; fn main() -> anyhow::Result<()> { let socket\_path = "mysocket"; let mut unix\_stream = UnixStream::connect(socket\_path).context("Could not create stream")?; write\_request\_and\_shutdown(&mut unix\_stream)?; read\_from\_stream(&mut unix\_stream)?; Ok(()) } |
+| ---------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+
+The `shutdown()` method takes a `Shutdown` enum we would otherwise use on TCP streams. Write below the main function:
+
+| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 | fn write\_request\_and\_shutdown(unix\_stream: &mut UnixStream) -> anyhow::Result<()> { unix\_stream .write(b"Hello?") .context("Failed at writing onto the unix stream")?; println!("We sent a request"); println!("Shutting down writing on the stream, waiting for response..."); unix\_stream .shutdown(std::net::Shutdown::Write) .context("Could not shutdown writing on the stream")?; Ok(()) } |
+| ---------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+
+The stream is now clean to be read from.
+
+| 1 2 3 4 5 6 7 8 9 | fn read\_from\_stream(unix\_stream: &mut UnixStream) -> anyhow::Result<()> { let mut response = String::new(); unix\_stream .read\_to\_string(&mut response) .context("Failed at reading the unix stream")?; println!("We received this response: {}", response); Ok(()) } |
+| ----------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+
+Have the server running in a terminal:
+
+```routeros
+cargo run --bin server
+
+```
+
+And in a separate terminal, run the client:
+
+```routeros
+cargo run --bin client
+
+```
+
+If all is well,
+
+* the hello message should display on the server side
+* the “I hear you” response should display on the client side
+
+You can run the client as many times as you want, since the server runs in a loop.
+
+This tutorial comes with a [github repository](https://github.com/Keksoj/unix%5Fsockets%5Fbasics)that contains the above code.
+
+Feel free to write an issue for any comment, criticism, or complaint you may have. Fork and do pull requests as you please.
+
+This blog post is a sum-up of what I learned trying to understand unix sockets while working on Sōzu. A more elaborate version of the code is available[in this other repo](https://github.com/Keksoj/unix%5Fsocket%5Fbased%5Fserver%5Fclient), with additional features:
+
+* a `UnixListener`\-wrapping library with a glorious `SocketBuilder` helper (permissions! blocking/nonblocking!)
+* a `Message` module with serializable `Request` and `Response` structs. The Response has a status that is either `Ok`, `Error` or `Processing`
+* a client loop that continues reading the stream as long as responses come with a `Processing` status, to stops only at `Ok` or `Error`
+
+All this happened thanks to my employer, [Clever Cloud](https://clever-cloud.com/), who allows me to learn my job in the best possible conditions. Much gratitude.
\ No newline at end of file
diff --git a/Omnivore/2024-05-10 - Bullet Journal in 5 Minutes a Day (for busy people).md b/Omnivore/2024-05-10 - Bullet Journal in 5 Minutes a Day (for busy people).md
new file mode 100644
index 0000000..1fb49fb
--- /dev/null
+++ b/Omnivore/2024-05-10 - Bullet Journal in 5 Minutes a Day (for busy people).md
@@ -0,0 +1,50 @@
+---
+id: fafb2eae-5872-4b07-8e3e-a215337ff70f
+title: |
+ Bullet Journal in 5 Minutes a Day (for busy people)
+status: ARCHIVED
+tags:
+ - read-later
+date_added: 2024-05-10 23:57:58
+url_omnivore: |
+ https://omnivore.app/me/https-www-youtube-com-watch-v-t-op-4-hr-l-sc-4-18f65cce78b
+url_original: |
+ https://www.youtube.com/watch?v=T_Op4hrLSc4
+---
+
+# Bullet Journal in 5 Minutes a Day (for Busy people)
+
+## Notes
+
+KISS
+
+In the morning:
+
+- Write down what needs to be done in the day in a simple bullet list, ~5 actions
+- Check previous day log
+
+Daily logging:
+
+- When switching contexts, write down what you did and what are you gonna do next
+- When the action is completed, cross it off
+- Single sentences
+- Only write down what's noteworthy
+
+Types of bullets:
+
+- ` • `: actions
+- ` - `: Notes, ideas & thoughts
+- ` = `: Moods, mental & physical feelings
+- ` ˚ `: Events
+
+Reflection:
+
+- Update the bullets
+- Decided what to do with the uncompleted actions
+- Write down final thoughts
+
+## Original
+
+[Bullet Journal in 5 Minutes a Day (for busy people)](https://www.youtube.com/watch?v=T%5FOp4hrLSc4)
+
+By [Bullet Journal](https://www.youtube.com/@bulletjournal)
diff --git a/Omnivore/2024-05-13 - Simbología de diagrama de flujo - Lucidchart.md b/Omnivore/2024-05-13 - Simbología de diagrama de flujo - Lucidchart.md
new file mode 100644
index 0000000..d9ba2d0
--- /dev/null
+++ b/Omnivore/2024-05-13 - Simbología de diagrama de flujo - Lucidchart.md
@@ -0,0 +1,40 @@
+---
+id: e121c5da-aeed-412d-9d37-97c6fb5009a1
+title: |
+ Simbología de diagrama de flujo | Lucidchart
+status: ARCHIVED
+tags:
+ - read-later
+date_added: 2024-05-13 09:28:34
+url_omnivore: |
+ https://omnivore.app/me/simbologia-de-diagrama-de-flujo-lucidchart-18f72240313
+url_original: |
+ https://www.lucidchart.com/pages/es/simbolos-comunes-de-los-diagramas-de-flujo
+---
+
+# Simbología de diagrama de flujo | Lucidchart
+
+## Notes
+
+keep
+## Original
+
+Muchos de estos símbolos de diagramas de flujo adicionales se utilizan para trazar un diagrama de flujo de proceso de negocios para aplicaciones, flujo de usuarios, procesamiento de datos, etc.
+
+| Símbolo de diagrama de flujo | Nombre | Descripción |
+| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+|  | Símbolo de base de datos | Representa los datos alojados en un servicio de almacenamiento que probablemente permitirá buscar y filtrar por usuarios. |
+|  | Símbolo de cinta de papel | Símbolo obsoleto rara vez empleado en las prácticas o los flujos de proceso modernos. No obstante, se podría usar este símbolo cuando se trazan procesos o métodos de ingreso en computadoras y máquinas CNC mucho más antiguas. |
+|  | Símbolo de suma o unión | Suma las entradas de varias rutas que convergen. |
+|  | Símbolo de proceso predefinido | Indica un proceso u operación complicado que es bien conocido o definido en otro lado. |
+|  | Símbolo de almacenamiento interno | Empleada comúnmente para trazar los diseños de software, esta figura indica los datos almacenados en la memoria interna. |
+|  | Símbolo de entrada manual | Representa la entrada manual de datos en un campo o paso del proceso, por lo general a través del teclado o de un dispositivo. Por ejemplo, en el proceso de inicio de sesión cuando se le pide al usuario que ingrese los datos manualmente. |
+|  | Símbolo de operación manual | Indica un paso que se debe realizar de forma manual, no automáticamente. |
+|  | Símbolo de fusión | Combina múltiples caminos en uno solo. |
+|  | Símbolo de documentos múltiples | Representa documentos o informes múltiples. |
+|  | Símbolo de preparación | Diferencia entre los pasos que preparan para el trabajo y los pasos que realmente hacen el trabajo. Ayuda a introducir la configuración en otro paso dentro del mismo proceso. |
+|  | Símbolo de datos almacenados | Esta figura, también conocida como símbolo de "almacenamiento de datos", representa dónde se almacenan los datos en un proceso. |
+|  | Símbolo de retraso | Representa un segmento de retraso en un proceso. Puede ser útil para indicar la duración exacta del retraso dentro de la figura. |
+|  | Símbolo "or" | Tal como se describe, esta figura indica que el flujo del proceso de negocio continúa en dos o más caminos. |
+|  | Símbolo de pantalla | Esta figura es útil para indicar dónde se mostrará la información dentro de un flujo de proceso. |
+|  | Símbolo de disco rígido | Indica dónde están almacenados los datos dentro del disco rígido, también conocido como almacenamiento de acceso directo. |
\ No newline at end of file
diff --git a/Omnivore/2024-05-13 - ¿Qué es un diagrama de flujo- - Lucidchart.md b/Omnivore/2024-05-13 - ¿Qué es un diagrama de flujo- - Lucidchart.md
new file mode 100644
index 0000000..b11f965
--- /dev/null
+++ b/Omnivore/2024-05-13 - ¿Qué es un diagrama de flujo- - Lucidchart.md
@@ -0,0 +1,267 @@
+---
+id: 52e165c4-8ef3-4036-a5ea-6d8cebd148a4
+title: |
+ ¿Qué es un diagrama de flujo? | Lucidchart
+status: ARCHIVED
+tags:
+ - read-later
+date_added: 2024-05-13 09:27:16
+url_omnivore: |
+ https://omnivore.app/me/que-es-un-diagrama-de-flujo-lucidchart-18f7222d3b7
+url_original: |
+ https://www.lucidchart.com/pages/es/que-es-un-diagrama-de-flujo
+---
+
+# ¿Qué es un diagrama de flujo? | Lucidchart
+
+## Highlights
+
+Un diagrama de flujo es un diagrama que describe un proceso, sistema o algoritmo informático.
+
+[source](https://omnivore.app/me/que-es-un-diagrama-de-flujo-lucidchart-18f7222d3b7#811b888b-84ca-4575-87b9-7b329885bdb4)
+
+---
+
+Puedes usar un diagrama de flujo para explicar detalladamente la lógica detrás de un programa antes de empezar a codificar el proceso automatizado.
+
+[source](https://omnivore.app/me/que-es-un-diagrama-de-flujo-lucidchart-18f7222d3b7#a732a8de-c335-4f4b-b107-e0804c35d826)
+
+---
+
+## Cómo planificar y dibujar un diagrama de flujo básico
+
+1. #### Define tu propósito y alcance.
+. ¿Qué deseas lograr? ¿Estás considerando las cosas correctas con un punto inicial y final apropiados para alcanzar ese propósito? Realiza una investigación lo suficientemente detallada, pero lo suficientemente simple a la hora de crear tus diagramas para comunicarte con tu audiencia.
+2. #### Identifica las tareas en orden cronológico.
+Esto puede involucrar las conversaciones con los participantes, la observación de un proceso o la revisión de cualquier documentación existente. Puedes escribir los pasos en forma de notas o comenzar con un diagrama en versión borrador.
+3. #### Organízalos por tipo y figura correspondiente,
+como procesos, decisiones, datos, entradas o salidas.
+4. #### Crea tu diagrama,
+ ya sea dibujándolo a mano o usando un programa como Lucidchart.
+5. #### Confirma tu diagrama de flujo,
+ verificando todos los pasos con las personas que participan en el proceso. Observa el proceso para asegurarte de no dejar de lado nada que sea importante para tu propósito.
+
+[source](https://omnivore.app/me/que-es-un-diagrama-de-flujo-lucidchart-18f7222d3b7#10b651cf-aaa2-46dc-9261-12b625bfd701)
+
+---
+
+## Original
+
+[](https://www.lucidchart.com/pages/es)
+
+
+
+## ¿Cuáles son tus necesidades de creación de diagramas de flujo?
+
+[No tengo experiencia en diagramas de flujo y quiero aprender más.](#discoveryTop)
+
+---
+
+## Índice
+
+* [Más recomendaciones para los diagramas de flujo](#section%5F0)
+* [¿Qué es un diagrama de flujo?](#section%5F1)
+* [Historia](#section%5F2)
+* [Símbolos de diagramas de flujo](#section%5F3)
+* [Diagramas de flujo para algoritmos/programación informática ](#section%5F4)
+* [Cómo se usan los diagramas de flujo en muchos otros campos](#section%5F5)
+* [Tipos de diagramas de flujo](#section%5F6)
+* [Cómo planificar y dibujar un diagrama de flujo básico ](#section%5F7)
+
+Esta guía completa brinda todo lo que debes saber sobre los diagramas de flujo, incluidas definiciones, historia, casos de uso, símbolos, recomendaciones y más.
+
+10 minutos de lectura
+
+¿Deseas crear un diagrama de flujo por tu cuenta? Prueba Lucidchart. Es rápido, sencillo y totalmente gratis.
+
+## Más recomendaciones para los diagramas de flujo
+
+* Ten a tu audiencia en mente y orienta los detalles de tu diagrama hacia ella. La comunicación clara es un objetivo fundamental en los diagramas de flujo.
+* Si el proceso que estás representando involucra distintos equipos o departamentos, considera usar un diagrama de carriles para definir claramente las responsabilidades y transferencias.
+* Usa conectores dentro o fuera de la página para "editar" tu diagrama y lograr que fluya de forma lógica. Esto te puede permitir separar el diagrama en distintas páginas y que continúe siendo fluido.
+
+==Un diagrama de flujo es un diagrama que describe un proceso, sistema o algoritmo informático.== Se usan ampliamente en numerosos campos para documentar, estudiar, planificar, mejorar y comunicar procesos que suelen ser complejos en diagramas claros y fáciles de comprender. Los diagramas de flujo emplean rectángulos, óvalos, diamantes y otras numerosas figuras para definir el tipo de paso, junto con flechas conectoras que establecen el flujo y la secuencia. Pueden variar desde diagramas simples y dibujados a mano hasta diagramas exhaustivos creados por computadora que describen múltiples pasos y rutas. Si tomamos en cuenta todas las diversas figuras de los diagramas de flujo, son uno de los diagramas más comunes del mundo, usados por personas con y sin conocimiento técnico en una variedad de campos. Los diagramas de flujo a veces se denominan con nombres más especializados, como "diagrama de flujo de procesos", "mapa de procesos", "diagrama de flujo funcional", "mapa de procesos de negocios", "notación y modelado de procesos de negocio (BPMN)" o "diagrama de flujo de procesos (PFD)". Están relacionados con otros diagramas populares, como los diagramas de [flujo de datos](https://www.lucidchart.com/pages/es/diagrama-de-flujo-de-datos) (DFD) y los diagramas de actividad de lenguaje unificado de modelado (UML).
+
+
+
+
+
+## Historia
+
+El uso de los diagramas de flujo para documentar procesos de negocios se inició entre las décadas de 1920 y 1930\. En 1921, los ingenieros industriales Frank y Lillian Gilbreth presentaron el "diagrama de flujo de procesos" en la Sociedad Americana de Ingenieros Mecánicos (ASME – American Society of Mechanical Engineers). A principios de la década de 1930, el ingeniero industrial Allan H. Morgensen empleó las herramientas de Gilbreth para presentar conferencias sobre cómo aumentar la eficiencia en el trabajo a personas de negocios en su empresa. En la década de 1940, dos estudiantes de Morgensen, Art Spinanger y Ben S. Graham, difundieron los métodos más ampliamente. Spinanger introdujo los métodos de simplificación del trabajo en Procter & Gamble. Graham, director de Standard Register Industrial, adaptó los diagramas de flujo de procesos al procesamiento de información. En 1947, ASME adoptó un sistema de símbolos para los diagramas de flujo de procesos derivado del trabajo original de Gilbreth.
+
+Además, a fines de la década de 1940, Herman Goldstine y John Van Neumann usaron diagramas de flujo para desarrollar programas informáticos. Pronto la creación de diagramas se volvió cada vez más popular para los programas informáticos y algoritmos de todo tipo. Los diagramas de flujo se continúan usando para la programación hoy en día. Sin embargo, el pseudocódigo, una combinación de palabras y lenguaje de codificación pensado para lectura humana, a menudo se usa para representar niveles más específicos de detalle y para tener una versión más cercana al producto final.
+
+En Japón, Kaoru Ishikawa (1915-1989), una personalidad clave en las iniciativas de calidad en manufactura, afirmó que los diagramas de flujo eran una de las herramientas fundamentales en el área de control de calidad, junto a otras complementarias, como el histograma, la ficha de control y el diagrama de causa-efecto, también llamado Diagrama de Ishikawa.
+
+## Símbolos de diagramas de flujo
+
+¿Deseas crear un diagrama de flujo por tu cuenta? Prueba Lucidchart. Es rápido, sencillo y totalmente gratis.
+
+[Genera un diagrama de flujo](https://lucid.app/es/pricing/lucidchart?anonId=0.e632479b18f721b8479&sessionDate=2024-05-13T13%3A19%3A17.116Z&sessionId=0.48b7148618f721b847c)
+
+## Diagramas de flujo para algoritmos/programación informática
+
+Como una representación visual del flujo de datos, los diagramas de flujo son útiles para escribir un programa o algoritmo y explicárselo a otros o colaborar con otros en el mismo. ==Puedes usar un diagrama de flujo para explicar detalladamente la lógica detrás de un programa antes de empezar a codificar el proceso automatizado.== Puede ayudar a organizar una perspectiva general y ofrecer una guía cuando llega el momento de codificar. Más específicamente, los diagramas de flujo pueden:
+
+* Demostrar cómo el código está organizado.
+* Visualizar la ejecución de un código dentro de un programa.
+* Mostrar la estructura de un sitio web o aplicación.
+* Comprender cómo los usuarios navegan por un sitio web o programa.
+
+A menudo, los programadores pueden escribir un pseudocódigo, una combinación de lenguaje natural y lenguaje informático que puede ser leído por personas. Esto puede permitir más detalle que el diagrama de flujo y servir como reemplazo del diagrama de flujo o como el próximo paso del código mismo.
+
+Los diagramas relacionados que se emplean en el software informático incluyen:
+
+* Lenguaje unificado de modelado (UML): este es el lenguaje de propósito general usado en la ingeniería de software para el modelado.
+* Diagramas Nassi-Shneiderman (NSD): usados para la programación informática estructurada. Llevan el nombre de sus creadores: Isaac Nassi y Ben Shneiderman, quienes los desarrollaron en 1972 en la Universidad Estatal de Nueva York en Stony Brook. También se denominan "estructogramas".
+* Diagramas DRAKON: DRAKON es un lenguaje de programación visual de algoritmos empleado para crear diagramas de flujo.
+
+
+
+## Cómo se usan los diagramas de flujo en muchos otros campos
+
+Más allá de la programación informática, los diagramas de flujo pueden tener muchos usos en diversos campos.
+
+#### En cualquier campo pueden:
+
+* Documentar y analizar un proceso.
+* Estandarizar un proceso para obtener eficiencia y calidad.
+* Comunicar un proceso para capacitar a otros sectores de la organización o lograr el entendimiento de su parte.
+* Identificar cuellos de botellas, redundancias y pasos innecesarios en un proceso y mejorarlo.
+
+#### Educación:
+
+* Planificar los requisitos académicos y las tareas del curso.
+* Crear una presentación oral o un plan de clase.
+* Organizar un proyecto grupal o individual.
+* Mostrar un proceso civil o legal, como el registro de votantes.
+* Planificar y estructurar la escritura creativa, como poesía o poesía lírica.
+* Demostrar el desarrollo de un personaje en la literatura y el cine.
+* Representar el flujo de algoritmos o acertijos lógicos.
+* Comprender un proceso científico, como el ciclo de Krebs.
+* Dibujar un proceso anatómico, como la digestión.
+* Trazar síntomas y tratamientos para enfermedades o trastornos.
+* Comunicar hipótesis y teorías, como la pirámide de Maslow o jerarquía de las necesidades humanas.
+
+#### Ventas y marketing:
+
+* Trazar el flujo de una encuesta.
+* Dibujar un proceso de ventas.
+* Planificar estrategias de investigación.
+* Mostrar flujos de registro.
+* Difundir políticas de comunicación, como un plan de R.R. P.P. de emergencia.
+
+
+
+#### Negocios:
+
+* Comprender procesos de pedidos y compras.
+* Representar la rutina diaria o las tareas de un empleado.
+* Comprender las rutas que toman los usuarios en un sitio web o en una tienda.
+* Desarrollar un plan de negocio o un plan de desarrollo de un producto.
+* Documentar un proceso en preparación para una auditoría, incluido el cumplimiento normativo, por ejemplo, en virtud de la Ley Sarbanes-Oxley.
+* Documentar un proceso en preparación para una venta o consolidación.
+
+
+
+#### Manufactura:
+
+* Indicar la composición química o física de un producto.
+* Ilustrar el proceso de manufactura de principio a fin.
+* Descubrir y resolver ineficiencias en un proceso de manufactura o adquisición.
+
+#### Ingeniería:
+
+* Representar flujos de proceso o de sistema.
+* Diseñar y actualizar procesos químicos y de planta.
+* Evaluar el ciclo de vida de una estructura.
+* Diagramar un flujo de ingeniería inversa.
+* Demostrar la fase de prototipo y diseño de una estructura o producto nuevos.
+
+## Tipos de diagramas de flujo
+
+Distintos autores describen numerosos tipos de diagramas de flujo en diferentes términos. Estas personas incluyen a expertos publicados, como Alan B. Sterneckert, Andrew Veronis, Marilyn Bohl y Mark A. Fryman.
+
+Sterneckert, en su libro escrito en 2003 _Critical Incident Management_, mencionó cuatro tipos de diagramas de flujo populares, enmarcados en el concepto de controles de flujos en vez del flujo en sí mismo:
+
+* #### Diagramas de flujo de documentos:
+Estos "tienen el propósito de mostrar los controles existentes en el flujo de documentos a través de los componentes de un sistema. (...) El diagrama se lee de izquierda a derecha y detalla el flujo de documentos a través de numerosas unidades de negocio".
+* #### Diagramas de flujo de datos:
+Estos indican "los controles que rigen los flujos de datos en un sistema. (...) Los diagramas de flujo de datos se usan principalmente para mostrar los canales donde se transmiten los datos a través del sistema en lugar de cómo se controla el flujo".
+* #### Diagramas de flujo de sistemas:
+ Estos "indican el flujo de datos que pasa hacia los componentes principales de un sistema, o a través de ellos, tales como entrada de datos, programas, medios de almacenamiento, procesadores y redes de comunicación".
+* #### Diagramas de flujo de programas:
+ Estos muestran "los controles ubicados internamente en un programa dentro de un sistema".
+
+Veronis , en su libro escrito en 1978, _Microprocessors: Design and Applications_, describió tres tipos de diagramas de flujo en función del alcance y nivel de detalle:
+
+* #### Diagrama de flujo de sistema:
+identifica los dispositivos que se emplearán.
+* #### Diagrama de flujo general:
+ vista general.
+* #### Diagrama de flujo detallado:
+ más detalles.
+
+Bohl, en su libro escrito en 1978 llamado A Guide for Programmers, enumera solo dos:
+
+* #### Diagrama de flujo de sistemas.
+* #### Diagrama de flujo de programas.
+
+But Fryman, en su libro escrito en 2001 titulado _Quality and Process Improvement_, distinguió los tipos de muchas maneras, más desde una perspectiva orientada a los negocios que a la informática:
+
+* #### Diagrama de flujo de decisiones.
+* #### Diagrama de flujo lógico.
+* #### Diagrama de flujo de sistemas.
+* #### Diagrama de flujo de productos.
+* #### Diagrama de flujo de procesos.
+
+Otros tipos de diagramas de flujo definidos por otros incluyen:
+
+* #### Diagrama de carriles, también conocido como "diagrama de flujo de carriles":
+ detalla los roles de cada participante en procesos que se realizan entre equipos.
+* #### Diagrama de flujo de trabajo:
+documenta flujos de trabajo, a menudo involucra tareas, documentos e información en las oficinas.
+* #### Diagrama de cadena de procesos impulsada por eventos (EPC):
+documenta o planifica un proceso de negocio.
+* #### Diagrama de flujo de lenguaje de descripción y especificación (SDL):
+ realiza un lluvia de ideas sobre los algoritmos informáticos mediante tres componentes básicos: proceso, bloqueo y definición de sistema.
+
+
+
+Estos diagramas relacionados también se piensan, a veces, como tipos de diagramas de flujo:
+
+* #### Diagrama de flujo de datos (DFD):
+traza el flujo de información de cualquier sistema o proceso.
+* #### Diagrama de flujo de procesos (PFD), también conocido como "gráfico de flujo de procesos":
+ilustra las relaciones entre los principales componentes de una planta industrial.
+* #### Modelo y notación de procesos de negocio (BPMN 2.0):
+modela los pasos de un proceso de negocio planificado.
+
+## ==Cómo planificar y dibujar un diagrama de flujo básico==
+
+1. #### ==Define tu propósito y alcance.==
+==. ¿Qué deseas lograr? ¿Estás considerando las cosas correctas con un punto inicial y final apropiados para alcanzar ese propósito? Realiza una investigación lo suficientemente detallada, pero lo suficientemente simple a la hora de crear tus diagramas para comunicarte con tu audiencia.==
+2. #### ==Identifica las tareas en orden cronológico.==
+==Esto puede involucrar las conversaciones con los participantes, la observación de un proceso o la revisión de cualquier documentación existente. Puedes escribir los pasos en forma de notas o comenzar con un diagrama en versión borrador.==
+3. #### ==Organízalos por tipo y figura correspondiente,==
+==como procesos, decisiones, datos, entradas o salidas.==
+4. #### ==Crea tu diagrama,==
+ ==ya sea dibujándolo a mano o usando un programa como Lucidchart.==
+5. #### ==Confirma tu diagrama de flujo,==
+ ==verificando todos los pasos con las personas que participan en el proceso. Observa el proceso para asegurarte de no dejar de lado nada que sea importante para tu propósito.==
+
+---
+
+## Recursos útiles
+
+* [Plantilla de diagrama de flujo para Word](https://www.lucidchart.com/pages/es/plantilla-de-diagrama-de-flujo-para-word)
+* [Cómo hacer un diagrama de flujo en Excel](https://www.lucidchart.com/pages/es/como-hacer-un-diagrama-de-flujo-en-excel)
+* [Simbología de diagrama de flujo](https://www.lucidchart.com/pages/es/simbolos-comunes-de-los-diagramas-de-flujo)
+* [Cómo hacer un diagrama de flujo](https://www.lucidchart.com/pages/es/como-hacer-un-diagrama-de-flujo)
+* [Cómo crear un diagrama de flujo en PowerPoint](https://www.lucidchart.com/pages/es/hacer-un-diagrama-de-flujo-en-powerpoint)
+* [Cómo crear un diagrama de flujo en Word](https://www.lucidchart.com/pages/es/como-hacer-un-diagrama-de-flujo-en-word)
+
+Crear diagramas de flujo en Lucidchart es fácil e intuitivo. Simplemente debes arrastrar las figuras en el lienzo y dibujar las líneas que las conectan. Si no sabes bien por dónde empezar, echa un vistazo a nuestro tutorial sobre recomendaciones acerca de [cómo dibujar un diagrama de flujo](https://www.lucidchart.com/pages/es/como-hacer-un-diagrama-de-flujo).
+
+¿Deseas crear un diagrama de flujo por tu cuenta? Prueba Lucidchart. Es rápido, sencillo y totalmente gratis.
\ No newline at end of file
diff --git a/Omnivore/2024-06-24 - Maintaining Balance for Open Source Maintainers - Open Source Guides.md b/Omnivore/2024-06-24 - Maintaining Balance for Open Source Maintainers - Open Source Guides.md
new file mode 100644
index 0000000..e1ffe85
--- /dev/null
+++ b/Omnivore/2024-06-24 - Maintaining Balance for Open Source Maintainers - Open Source Guides.md
@@ -0,0 +1,124 @@
+---
+id: 796f6a6c-b7d5-4139-9601-460023ba0db6
+title: |
+ Maintaining Balance for Open Source Maintainers | Open Source Guides
+status: ARCHIVED
+tags:
+ - read-later
+date_added: 2024-06-24 09:59:10
+url_omnivore: |
+ https://omnivore.app/me/maintaining-balance-for-open-source-maintainers-open-source-guid-1904a8b1fc4
+url_original: |
+ https://opensource.guide/maintaining-balance-for-open-source-maintainers/
+---
+
+# Maintaining Balance for Open Source Maintainers | Open Source Guides
+
+## Highlights
+
+* **Lack of positive feedback:** Users are far more likely to reach out when they have a complaint. If everything works great, they tend to stay silent. It can be discouraging to see a growing list of issues without the positive feedback showing how your contributions are making a difference.
+* **Not saying ‘no’:** It can be easy to take on more responsibilities than you should on an open source project. Whether it’s from users, contributors, or other maintainers – we can’t always live up to their expectations.
+* **Working alone:** Being a maintainer can be incredibly lonely. Even if you work with a group of maintainers, the past few years have been difficult for convening distributed teams in-person.
+* **Not enough time or resources:** This is especially true for volunteer maintainers who have to sacrifice their free time to work on a project.
+* **Conflicting demands:** Open source is full of groups with different motivations, which can be difficult to navigate. If you’re paid to do open source, your employer’s interests can sometimes be at odds with the community.
+
+[source](https://omnivore.app/me/maintaining-balance-for-open-source-maintainers-open-source-guid-1904a8b1fc4#dae1e4e1-4910-4dc6-ab2f-a6e0f407d489)
+
+---
+
+* **Lean on the community:** Delegation and finding contributors can alleviate the workload. Having multiple points of contact for a project can help you take a break without worrying. Connect with other maintainers and the wider community–in groups like the [Maintainer Community](http://maintainers.github.com/). This can be a great resource for peer support and learning.
+You can also look for ways to engage with the user community, so you can regularly hear feedback and understand the impact of your open source work.
+* **Explore funding:** Whether you’re looking for some pizza money, or trying to go full time open source, there are many resources to help! As a first step, consider turning on [GitHub Sponsors](https://github.com/sponsors) to allow others to sponsor your open source work. If you’re thinking about making the jump to full-time, apply for the next round of [GitHub Accelerator](http://accelerator.github.com/).
+
+[source](https://omnivore.app/me/maintaining-balance-for-open-source-maintainers-open-source-guid-1904a8b1fc4#e30a0308-0d0f-4aea-a66a-a8087992fc2b)
+
+---
+
+* **Use tools:** Explore tools like [GitHub Copilot](https://github.com/features/copilot/) and [GitHub Actions](https://github.com/features/actions) to automate mundane tasks and free up your time for more meaningful contributions.
+* **Rest and recharge:** Make time for your hobbies and interests outside of open source. Take weekends off to unwind and rejuvenate–and set your [GitHub status](https://docs.github.com/account-and-profile/setting-up-and-managing-your-github-profile/customizing-your-profile/personalizing-your-profile#setting-a-status) to reflect your availability! A good night’s sleep can make a big difference in your ability to sustain your efforts long-term.
+If you find certain aspects of your project particularly enjoyable, try to structure your work so you can experience it throughout your day.
+* **Set boundaries:** You can’t say yes to every request. This can be as simple as saying, “I can’t get to that right now and I do not have plans to in the future,” or listing out what you’re interested in doing and not doing in the README. For instance, you could say: “I only merge PRs which have clearly listed reasons why they were made,” or, “I only review issues on alternate Thursdays from 6 -7 pm.”This sets expectations for others, and gives you something to point to at other times to help de-escalate demands from contributors or users on your time.
+
+[source](https://omnivore.app/me/maintaining-balance-for-open-source-maintainers-open-source-guid-1904a8b1fc4#9288f579-7a9f-4135-8933-86266d8baa39)
+
+---
+
+## Original
+
+Tips for self-care and avoiding burnout as a maintainer.
+
+
+
+As an open source project grows in popularity, it becomes important to set clear boundaries to help you maintain balance to stay refreshed and productive for the long run.
+
+To gain insights into the experiences of maintainers and their strategies for finding balance, we ran a workshop with 40 members of the [Maintainer Community](http://maintainers.github.com/), allowing us to learn from their firsthand experiences with burnout in open source and the practices that have helped them maintain balance in their work. This is where the concept of personal ecology comes into play.
+
+So, what is personal ecology? As [described by the Rockwood Leadership Institute](https://rockwoodleadership.org/nonprofit-four-day-workweek-can-take-care-still-change-world/#:~:text=personal%20ecology%3A%20maintaining%20balance%2C%20pacing%20and%20efficiency%20to%20sustain%20your%20energy%20over%20a%20lifetime%20of%20activism), it involves “**maintaining balance, pacing, and efficiency to sustain our energy over a lifetime**.” This framed our conversations, helping maintainers recognize their actions and contributions as parts of a larger ecosystem that evolves over time. Burnout, a syndrome resulting from chronic workplace stress as [defined by the WHO](https://icd.who.int/browse11/l-m/en#/http://id.who.int/icd/entity/129180281), is not uncommon among maintainers. This often leads to a loss of motivation, an inability to focus, and a lack of empathy for the contributors and community you work with.
+
+By embracing the concept of personal ecology, maintainers can proactively avoid burnout, prioritize self-care, and uphold a sense of balance to do their best work.
+
+## [](#tips-for-self-care-and-avoiding-burnout-as-a-maintainer)Tips for Self-Care and Avoiding Burnout as a Maintainer:
+
+### [](#identify-your-motivations-for-working-in-open-source)Identify your motivations for working in open source
+
+Take time to reflect on what parts of open source maintenance energizes you. Understanding your motivations can help you prioritize the work in a way that keeps you engaged and ready for new challenges. Whether it’s the positive feedback from users, the joy of collaborating and socializing with the community, or the satisfaction of diving into the code, recognizing your motivations can help guide your focus.
+
+### [](#reflect-on-what-causes-you-to-get-out-of-balance-and-stressed-out)Reflect on what causes you to get out of balance and stressed out
+
+It’s important to understand what causes us to get burned out. Here are a few common themes we saw among open source maintainers:
+
+* **==Lack of positive feedback:==** ==Users are far more likely to reach out when they have a complaint. If everything works great, they tend to stay silent. It can be discouraging to see a growing list of issues without the positive feedback showing how your contributions are making a difference.==
+* **==Not saying ‘no’:==** ==It can be easy to take on more responsibilities than you should on an open source project. Whether it’s from users, contributors, or other maintainers – we can’t always live up to their expectations.==
+* **==Working alone:==** ==Being a maintainer can be incredibly lonely. Even if you work with a group of maintainers, the past few years have been difficult for convening distributed teams in-person.==
+* **==Not enough time or resources:==** ==This is especially true for volunteer maintainers who have to sacrifice their free time to work on a project.==
+* **==Conflicting demands:==** ==Open source is full of groups with different motivations, which can be difficult to navigate. If you’re paid to do open source, your employer’s interests can sometimes be at odds with the community.==
+
+### [](#watch-out-for-signs-of-burnout)Watch out for signs of burnout
+
+Can you keep up your pace for 10 weeks? 10 months? 10 years?
+
+There are tools like the [Burnout Checklist](https://governingopen.com/resources/signs-of-burnout-checklist.html) from [@shaunagm](https://github.com/shaunagm) that can help you reflect on your current pace and see if there are any adjustments you can make. Some maintainers also use wearable technology to track metrics like sleep quality and heart rate variability (both linked to stress).
+
+### [](#what-would-you-need-to-continue-sustaining-yourself-and-your-community)What would you need to continue sustaining yourself and your community?
+
+This will look different for each maintainer, and will change depending on your phase of life and other external factors. But here are a few themes we heard:
+
+* **Lean on the community:** Delegation and finding contributors can alleviate the workload. Having multiple points of contact for a project can help you take a break without worrying. Connect with other maintainers and the wider community–in groups like the [Maintainer Community](http://maintainers.github.com/). This can be a great resource for peer support and learning.
+You can also look for ways to engage with the user community, so you can regularly hear feedback and understand the impact of your open source work.
+* **Explore funding:** Whether you’re looking for some pizza money, or trying to go full time open source, there are many resources to help! As a first step, consider turning on [GitHub Sponsors](https://github.com/sponsors) to allow others to sponsor your open source work. If you’re thinking about making the jump to full-time, apply for the next round of [GitHub Accelerator](http://accelerator.github.com/).
+* **Use tools:** Explore tools like [GitHub Copilot](https://github.com/features/copilot/) and [GitHub Actions](https://github.com/features/actions) to automate mundane tasks and free up your time for more meaningful contributions.
+* **Rest and recharge:** Make time for your hobbies and interests outside of open source. Take weekends off to unwind and rejuvenate–and set your [GitHub status](https://docs.github.com/account-and-profile/setting-up-and-managing-your-github-profile/customizing-your-profile/personalizing-your-profile#setting-a-status) to reflect your availability! A good night’s sleep can make a big difference in your ability to sustain your efforts long-term.
+If you find certain aspects of your project particularly enjoyable, try to structure your work so you can experience it throughout your day.
+* **Set boundaries:** You can’t say yes to every request. This can be as simple as saying, “I can’t get to that right now and I do not have plans to in the future,” or listing out what you’re interested in doing and not doing in the README. For instance, you could say: “I only merge PRs which have clearly listed reasons why they were made,” or, “I only review issues on alternate Thursdays from 6 -7 pm.”This sets expectations for others, and gives you something to point to at other times to help de-escalate demands from contributors or users on your time.
+
+Learn to be firm in shutting down toxic behavior and negative interactions. It’s okay to not give energy to things you don’t care about.
+
+Remember, personal ecology is an ongoing practice that will evolve as you progress in your open source journey. By prioritizing self-care and maintaining a sense of balance, you can contribute to the open source community effectively and sustainably, ensuring both your well-being and the success of your projects for the long run.
+
+## [](#additional-resources)Additional Resources
+
+* [Maintainer Community](http://maintainers.github.com/)
+* [The social contract of open source](https://snarky.ca/the-social-contract-of-open-source/), Brett Cannon
+* [Uncurled](https://daniel.haxx.se/uncurled/), Daniel Stenberg
+* [How to deal with toxic people](https://www.youtube.com/watch?v=7lIpP3GEyXs), Gina Häußge
+* [SustainOSS](https://sustainoss.org/)
+* [Rockwood Art of Leadership](https://rockwoodleadership.org/art-of-leadership/)
+* [Saying No](https://docs.google.com/document/d/1esQQBJXQi1x%5F-1AcRVPiCRAEQYO4Qlvali0ylCvKa%5Fs/edit?pli=1#:~:text=Saying%20No%20%7C%20Mike%20McQuaid), Mike McQuaid
+* [Governing Open](https://docs.google.com/document/d/1esQQBJXQi1x%5F-1AcRVPiCRAEQYO4Qlvali0ylCvKa%5Fs/edit?pli=1#:~:text=a%20mixed%20list.-,Governance%20of%20Open%20Source%20Software,-governingopen.com)
+* Workshop agenda was remixed from [Mozilla’s Movement Building from Home](https://docs.google.com/document/d/1esQQBJXQi1x%5F-1AcRVPiCRAEQYO4Qlvali0ylCvKa%5Fs/edit?pli=1#:~:text=a%20mixed%20list.-,It%E2%80%99s%20a%20wrap%3A%20Movement%2DBuilding%20from%20Home,-foundation.mozilla.org) series
+
+## [](#contributors)Contributors
+
+Many thanks to all the maintainers who shared their experiences and tips with us for this guide!
+
+This guide was written by [@abbycabs](https://github.com/abbycabs) with contributions from:
+
+[@agnostic-apollo](https://github.com/agnostic-apollo) [@AndreaGriffiths11](https://github.com/AndreaGriffiths11) [@antfu](https://github.com/antfu) [@anthonyronda](https://github.com/anthonyronda) [@CBID2](https://github.com/CBID2) [@Cli4d](https://github.com/Cli4d) [@confused-Techie](https://github.com/confused-Techie) [@danielroe](https://github.com/danielroe) [@Dexters-Hub](https://github.com/Dexters-Hub) [@eddiejaoude](https://github.com/eddiejaoude) [@Eugeny](https://github.com/Eugeny) [@ferki](https://github.com/ferki) [@gabek](https://github.com/gabek) [@geromegrignon](https://github.com/geromegrignon) [@hynek](https://github.com/hynek) [@IvanSanchez](https://github.com/IvanSanchez) [@karasowles](https://github.com/karasowles) [@KoolTheba](https://github.com/KoolTheba) [@leereilly](https://github.com/leereilly) [@ljharb](https://github.com/ljharb) [@nightlark](https://github.com/nightlark) [@plarson3427](https://github.com/plarson3427) [@Pradumnasaraf](https://github.com/Pradumnasaraf) [@RichardLitt](https://github.com/RichardLitt) [@rrousselGit](https://github.com/rrousselGit) [@sansyrox](https://github.com/sansyrox) [@schlessera](https://github.com/schlessera) [@shyim](https://github.com/shyim) [@smashah](https://github.com/smashah) [@ssalbdivad](https://github.com/ssalbdivad) [@The-Compiler](https://github.com/The-Compiler) [@thehale](https://github.com/thehale) [@thisisnic](https://github.com/thisisnic) [@tudoramariei](https://github.com/tudoramariei) [@UlisesGascon](https://github.com/UlisesGascon) [@waldyrious](https://github.com/waldyrious) \+ many others!
+
+
+
+### Contribute
+
+Want to make a suggestion? This content is open source. Help us improve it.
+
+[ Contribute](https://github.com/github/opensource.guide/blob/main/%5Farticles/maintaining-balance-for-open-source-maintainers.md)
\ No newline at end of file
diff --git a/Readwise/11 Life-Changing Journaling Tips for Beginners.md b/Readwise/11 Life-Changing Journaling Tips for Beginners.md
new file mode 100644
index 0000000..d1e263b
--- /dev/null
+++ b/Readwise/11 Life-Changing Journaling Tips for Beginners.md
@@ -0,0 +1,41 @@
+# 11 Life-Changing Journaling Tips for Beginners
+
+
+
+## Metadata
+- Author: [[Jennifer]]
+- Full Title: 11 Life-Changing Journaling Tips for Beginners
+- Category: #articles
+- URL: https://www.simplyfiercely.com/journaling-tips/
+- Archive: https://web-archive.alecodes.page/bookmarks?bf=1&search=&title=11%20Life-Changing%20Journaling%20Tips%20for%20Beginners
+> [!tldr]
+> Journaling is a powerful tool for self-discovery and personal growth. To help beginners get started, the author shares 11 tips, like using prompts and writing honestly. The key is to enjoy the process and make journaling a regular habit.
+
+## Highlights
+1. Keep a list of go-to prompts ... They can be very helpful if you’re just starting because they give you a place to begin.
+
+write as though you’re talking to someone else.
+You can write to:
+• Your future self
+• Your younger self
+• To someone who is no longer with us
+• To someone who has hurt your feelings
+• To someone you admire
+• To someone who needs your help [View Highlight](https://read.readwise.io/read/01j862h864h4mhyv3vqy6xvve3))
+
+If you’re working from a list of journaling prompts, using a guided journal, or experimenting with a new journaling method, and something doesn’t feel right for you—then it’s OK to stop. [View Highlight](https://read.readwise.io/read/01j862kcsaxk8909cdb69f3dpe))
+
+Remember that the point of a prompt is to get your thoughts flowing freely, not necessarily to answer or address that specific question or statement. [View Highlight](https://read.readwise.io/read/01j862kvny6qx7bt3eykq0z8zm))
+
+But here’s the thing: too much inspiration can often lead to paralysis. [View Highlight](https://read.readwise.io/read/01j862ppxd79psqff22tjz21z1))
+
+cover the first page with a big scribble! A friend of mine recommends doing this as a way to break the ice [View Highlight](https://read.readwise.io/read/01j862r1djv5s1px2z8f233efa))
+
+Freewriting is a form of journaling where you write everything down without stopping, editing or even correcting grammar until your mind feels empty. [View Highlight](https://read.readwise.io/read/01j862t96pgsrqk03vdvpcj643))
+
+Keep this in mind at the start of your journey as you may feel pressure to journal the “right way”. When it comes to journaling, there is no right way. It’s your space to explore how you see fit. Don’t overthink it—just keep writing! [View Highlight](https://read.readwise.io/read/01j862vd6rrf591ccavj9s1f5b))
+
+To get the full benefits of journaling, you have to be honest. Open up and be vulnerable—it’s one of the few genuinely private spaces you have (unless you choose to share your journal with someone). The more honest you are, the closer you’ll get to your truth. [View Highlight](https://read.readwise.io/read/01j862vy4n84vzqznh9t62t0qx))
+
+Whenever you have a thought or feel strong emotions, write them down. [View Highlight](https://read.readwise.io/read/01j862ww1v0j1ebb9rfkd1ww7e))
+
diff --git a/Readwise/5 Design System Examples.md b/Readwise/5 Design System Examples.md
new file mode 100644
index 0000000..309eec4
--- /dev/null
+++ b/Readwise/5 Design System Examples.md
@@ -0,0 +1,8 @@
+---
+
+New highlights added at 2024-09-15 3:42 PM
+People are highly visual but can get overwhelmed by too many graphics. Liferay takes a direct approach to educating users by using images only when it matters, such as in screenshots of actual elements. By limiting the unnecessary items in your design system documentation, you can ensure the important things get communicated. [View Highlight](https://read.readwise.io/read/01j7tw12yxcgpsp883nsvscf1t))
+
+IBM shows that if you want to ensure that everyone can use your product, you need to start that process with your design system.
+And when you do, don’t just state your intent. Educate your team on the accessibility challenges different people face and teach them proven best practices that can make a noticeable difference for millions of people worldwide. [View Highlight](https://read.readwise.io/read/01j7twa6wgtnehe050h7br44r7))
+
diff --git a/Readwise/6 Morning Journal Prompts That Will Transform Your Day.md b/Readwise/6 Morning Journal Prompts That Will Transform Your Day.md
new file mode 100644
index 0000000..1b81291
--- /dev/null
+++ b/Readwise/6 Morning Journal Prompts That Will Transform Your Day.md
@@ -0,0 +1,69 @@
+# 6 Morning Journal Prompts That Will Transform Your Day
+
+
+
+## Metadata
+- Author: [[Jennifer]]
+- Full Title: 6 Morning Journal Prompts That Will Transform Your Day
+- Category: #articles
+- Document Tags: [[journaling]] [[notetaking]]
+- URL: https://www.simplyfiercely.com/morning-journal-prompts/
+- Archive: https://web-archive.alecodes.page/bookmarks?bf=1&search=&title=6%20Morning%20Journal%20Prompts%20That%20Will%20Transform%20Your%20Day
+> [!tldr]
+> Morning journaling can help you start your day with clarity and purpose by processing your thoughts and emotions. Using specific prompts can guide your reflections and help you feel more focused and less overwhelmed. Establishing a morning journaling routine can make your mornings more enjoyable and productive.
+
+## Highlights
+1. How do I want to feel when I go to bed tonight?
+**Use when: You feel stuck, unsure, or even a bit lost.** [View Highlight](https://read.readwise.io/read/01j8588c42w7v68v76cjzak02x)) [[journaling/prompt]]
+
+To do this, start by imagining that you’re in bed at the end of the day and you’re about to close your eyes. Take a deep breath and then exhale. How do you want to feel at that moment? [View Highlight](https://read.readwise.io/read/01j858a7fzcsje3ptx8evpnh7g))
+
+instead of saying *happy,* you could write down that you want to feel *accomplished* or *connected*. [View Highlight](https://read.readwise.io/read/01j858ajbqht1382hc75spg314))
+
+take things a step further by brainstorming simple actions that will support you. [View Highlight](https://read.readwise.io/read/01j858b7frqbr2kpzck52rsvdr))
+
+2. What season of life am I in?
+**Use when: You’re feeling overwhelmed by your to-do list.** [View Highlight](https://read.readwise.io/read/01j858cvvbjkzh75jvzbet09xa))
+
+think about your own life and ask yourself, “What season am I in?”
+• Are you in a season of caring for others?
+• A season of resting while you heal from physical or emotional trauma?
+• A season of growth in your career or professional life? [View Highlight](https://read.readwise.io/read/01j858g53d4y95edq9ca2265kx))
+
+Living a balanced life means knowing when to drop some things and when to pick up others *depending on what season you’re in right now*. It gives you permission to focus on what you need most and clarity to choose a few [things to let go of](https://www.simplyfiercely.com/things-to-let-go-of/) (for a while, at least). [View Highlight](https://read.readwise.io/read/01j858j3yzdcjpmrd72zrssfrj))
+
+Acknowledging life’s seasonality and where you are in that rhythm can, with practice, release you from the guilt that comes with wanting to do it all. [View Highlight](https://read.readwise.io/read/01j858kpwq5d6xnb80721zj64z))
+
+**Journaling Tip:** When working through this journal prompt, ask yourself if you need rest, if you need to work, if you need to spend time with family or friends, or if you need to be alone right now. [View Highlight](https://read.readwise.io/read/01j858m1vvj4nfkwn9g433he6d))
+
+3. Today I am excited to…
+**Use when: You need a pick-me-up.** [View Highlight](https://read.readwise.io/read/01j858mgv14bedfggjwgza7exg)) [[journaling/prompt]]
+
+you’re generally feeling a little low [View Highlight](https://read.readwise.io/read/01j858sve44psj3r6zvyahhekb))
+
+We are hard-wired to focus more on the negative things in life than the positive things. So how can we overcome this?
+By putting extra attention on the positive in the morning and throughout the day as well. [View Highlight](https://read.readwise.io/read/01j858thnp6y7cam9rbg2098zf))
+
+**Journaling Tip:** If you’re struggling to feel excited, try getting your senses involved. Imagine a warm cup of coffee pressed between your palms, the sound of the birds on your way to work, the sun shining on your skin—and see if it doesn’t change the way you feel. [View Highlight](https://read.readwise.io/read/01j858s0zxdjg1jfa6yhqf5j4c))
+
+4. Today I get to…
+**Use when: You’re feeling burdened or resentful.** [View Highlight](https://read.readwise.io/read/01j858y4e0kv537bhhck4vs0em)) [[journaling/prompt]]
+
+think about things that you have to do today … and see if you can reframe your thoughts about the situation. [View Highlight](https://read.readwise.io/read/01j8591gse70tyvt73pah1aaw1))
+
+**Journaling Tip:** Don’t forget to acknowledge if you are currently living out a past goal or dream! [View Highlight](https://read.readwise.io/read/01j8594bw1hq0kssgpszr0wqxq))
+
+5. I am challenged by…
+**Use when: You’re struggling.** [View Highlight](https://read.readwise.io/read/01j85c3n5raa1jpnkww72tg06n)) [[journaling/prompt]]
+
+By making your challenges the focus of your morning journal prompt, you’re ‘eating the frog’ but in a more mindful way. When you write about what challenges you, it is helpful to explore why and how you will overcome the challenge—but you should also write out what it will mean to you or your life. [View Highlight](https://read.readwise.io/read/01j85c8z3kjz86gjm4t6sybshm))
+
+If those words don’t ring true to your situation, you may need to re-evaluate whether the challenge fits with your values and goals. [View Highlight](https://read.readwise.io/read/01j85cngfe6j4f1bp4cy1q88nh))
+
+6. Write it all out
+**Use When: You don’t know what to do next.** [View Highlight](https://read.readwise.io/read/01j85dnb9vnavm92sfq8cvjfds)) [[journaling/prompt]]
+
+The idea behind free-writing is just as it sounds—you simply write out all of your thoughts without editing until there is nothing left. [View Highlight](https://read.readwise.io/read/01j85dpk39fpze0r24wkwas9kt))
+
+I find that it’s powerful because it allows your brain to unload without expectations. It’s a bit like ranting to a friend after a long day—sometimes you just need to get things off your chest, and then you can move on. [View Highlight](https://read.readwise.io/read/01j85dqa7hcqt5k4h4pc161dwc))
+
diff --git a/Readwise/7 Intentional Questions To Ask Yourself Every Day.md b/Readwise/7 Intentional Questions To Ask Yourself Every Day.md
new file mode 100644
index 0000000..f41ea96
--- /dev/null
+++ b/Readwise/7 Intentional Questions To Ask Yourself Every Day.md
@@ -0,0 +1,54 @@
+# 7 Intentional Questions To Ask Yourself Every Day
+
+
+
+## Metadata
+- Author: [[Jennifer]]
+- Full Title: 7 Intentional Questions To Ask Yourself Every Day
+- Category: #articles
+- Document Tags: [[journaling]]
+- URL: https://www.simplyfiercely.com/7-questions-to-inspire-intentional-living/
+- Archive: https://web-archive.alecodes.page/bookmarks?bf=1&search=&title=7%20Intentional%20Questions%20To%20Ask%20Yourself%20Every%20Day
+> [!tldr]
+> Regular self-reflection is essential for living a meaningful and purposeful life. Asking yourself seven intentional questions each day can help clarify your priorities and decisions. By taking time to reflect, you can ensure your actions align with what truly matters to you.
+
+## Highlights
+I thought I was too busy for something as trivial as “self-reflection” but now I know it’s one of the most valuable things I can do with my time, and for you as well. [View Highlight](https://read.readwise.io/read/01j85trb36ydy64sbw670rqy75))
+
+1. Why am I doing this?
+This is a deceptively simple yet very powerful question to ask yourself. I think too often we assume we know why we do what we do, but when we carve out time to sit and reflect, the truth can surprise us. [View Highlight](https://read.readwise.io/read/01j85ttaxs6xp6dyt426kv53re)) [[journaling/prompt]]
+
+It might save you ten minutes on a Monday morning, or ten years spent chasing a goal you don’t even really want. [View Highlight](https://read.readwise.io/read/01j85txf1x20mpd5dtfsex667w))
+
+2. Who am I doing this for? [View Highlight](https://read.readwise.io/read/01j85x45h66bevcpas8kb7jn36)) [[journaling/prompt]]
+
+This is a good question to ask yourself regularly when you feel your priorities are out of alignment. It can help shine a light on where you need stronger [personal boundaries](https://www.simplyfiercely.com/personal-boundaries/). [View Highlight](https://read.readwise.io/read/01j85x6nevt1a156g7tvrkar7w))
+
+But I should also point out that self-reflection isn’t about judging yourself or others. Instead, it’s about honesty; knowing why you do what you do and who you do things for, so you can [make intentional decisions about how to invest your time, money and energy](https://www.simplyfiercely.com/intentional-time-money-energy/). [View Highlight](https://read.readwise.io/read/01j85x70r7rxh41qz1tcm196qs))
+
+3. Is there a simpler way? [View Highlight](https://read.readwise.io/read/01j85xafyt9wnwf26pf711mjd2)) [[journaling/prompt]]
+
+Taking just five minutes to ask the question and look for a simpler way has saved me countless hours throughout my life. (And I’ll also admit that sometimes it happens in reverse —I’d spend hours doing something and then realise I made it harder than need be!) [View Highlight](https://read.readwise.io/read/01j85xe88z59xav5x5n16yee9k))
+
+4. How does this add value to my life? [View Highlight](https://read.readwise.io/read/01j85xqetvfmrkt17gwaxx8ssh)) [[journaling/prompt]]
+
+We trade away our precious lives in little moments ... we often spend our *lives* on things that give us little value in return.
+
+if you can’t quickly explain in very specific terms how something is adding value to your life, then odds are it isn’t. [View Highlight](https://read.readwise.io/read/01j85xtzjn34ra2xt29zyevsw4))
+
+5. What am I giving up? [View Highlight](https://read.readwise.io/read/01j85y3wdwgy2mbpkh1pygyevt)) [[journaling/prompt]]
+
+you put a name to the tradeoffs associated with any decision [View Highlight](https://read.readwise.io/read/01j85y5pfvpjm9mzm49bgc4kya))
+
+Whenever you decide to do or buy something, make sure you think about what you’re giving up to make it happen. [View Highlight](https://read.readwise.io/read/01j85y6bt9wgrec4r2520b5ja7))
+
+6. How does this make me feel? [View Highlight](https://read.readwise.io/read/01j85y8kck7ckzazkgdaphdfjm)) [[journaling/prompt]]
+
+If you’re doing something that makes you feel sad, anxious, or angry it’s important to understand why. Are you doing something that goes against your core values? Or do you need more rest and support? [View Highlight](https://read.readwise.io/read/01j85ya9vvam560p585n9eyhn6))
+
+Or when you feel more positive emotions—why? What can you learn from your feelings and how can you apply what you learn in your everyday life? How can you be intentional about creating the life you want? [View Highlight](https://read.readwise.io/read/01j85yak4qe3qzhdqnnp65nr74))
+
+7. Am I being honest with myself? [View Highlight](https://read.readwise.io/read/01j85yapckfm2deazf2qfdadx8)) [[journaling/prompt]]
+
+Finally, it’s important to check that you’re being honest with yourself, because if you’re not, none of your other answers really matter. [View Highlight](https://read.readwise.io/read/01j85ye7w6zca1hjwcaqxmp2zt))
+
diff --git a/Readwise/7 Mindful Journaling Prompts to Calm an Anxious Mind.md b/Readwise/7 Mindful Journaling Prompts to Calm an Anxious Mind.md
new file mode 100644
index 0000000..466a4b4
--- /dev/null
+++ b/Readwise/7 Mindful Journaling Prompts to Calm an Anxious Mind.md
@@ -0,0 +1,78 @@
+# 7 Mindful Journaling Prompts to Calm an Anxious Mind
+
+
+
+## Metadata
+- Author: [[Jennifer Burger]]
+- Full Title: 7 Mindful Journaling Prompts to Calm an Anxious Mind
+- Category: #articles
+- URL: https://www.simplyfiercely.com/mindful-journal-prompts/
+- Archive: https://web-archive.alecodes.page/bookmarks?bf=1&search=&title=7%20Mindful%20Journaling%20Prompts%20to%20Calm%20an%20Anxious%20Mind
+> [!tldr]
+> Journaling can help calm an anxious mind by bringing awareness to the present and allowing you to explore your feelings without judgment. Mindful journaling prompts provide a structured way to reflect on your thoughts and fears, making it easier to cope with anxiety. Whether you're new to journaling or have experience, these prompts can help you find peace and clarity in stressful times.
+
+## Highlights
+mindful journaling is intended to bring more of your awareness to the present moment. Simply put, it’s the act of conscious writing. It can be particularly helpful for anyone that struggles with meditation because you go to the extra step of taking the thoughts from your mind and making them tangible by writing them down. [View Highlight](https://read.readwise.io/read/01j83kfe31tcya0gkqbfcfw71c))
+
+Mindful journaling can help to ease anxiety by allowing you to uncover the root cause of your stress. After all, one of the [benefits of journaling](https://www.simplyfiercely.com/benefits-of-journaling/) is that it’s a reflective process. It helps you organise your thoughts, and because they’re written down, you have the chance to reflect on them too. [View Highlight](https://read.readwise.io/read/01j83kjtp3t9x64bmgtwkter90))
+
+In the words of Eckhart Tolle, “As soon as you honour the present moment, all unhappiness and struggle dissolve, and life begins to flow with joy and ease.” [View Highlight](https://read.readwise.io/read/01j83m70htvhxtfjfvhb68qsvx))
+
+If you’re new to journaling, you might be hit with ‘writer’s block’. Remember, any new behaviour or practice can take getting used to. [View Highlight](https://read.readwise.io/read/01j83m8kymfctpxjqyw29vq3wh))
+
+[Be intentional](https://www.simplyfiercely.com/be-intentional/) about creating time to write your feelings out. Turn it into a ritual by making yourself a warm drink, lighting a candle, or choosing a nice spot to write in. This might help you create a [daily routine](https://www.simplyfiercely.com/daily-routines/) in the future. [View Highlight](https://read.readwise.io/read/01j83m93tv468vmfpmrafmfg5j))
+
+Prompt: What Am I Feeling Right Now?
+**Use when: You feel like you need to empty a racing brain.** [View Highlight](https://read.readwise.io/read/01j83ncpgpa765e7ma2yk8264x)) [[journaling/prompt]]
+
+Once you start writing, don’t stop until you feel there is nothing else to write. This means you should write *everything* down, even if you begin to veer away from the prompt. Don’t pay any mind to spelling mistakes, your handwriting and don’t edit what ends up on the page. Just write it all out. [View Highlight](https://read.readwise.io/read/01j83nhv221bsrfd0r2fyv08vj))
+
+Prompt: What Am I Afraid Of?
+**Use when: You are overcome with worry.** [View Highlight](https://read.readwise.io/read/01j83njt22m4rmjdrv55g4c356)) [[journaling/prompt]]
+
+To journal through your fears, start by writing them out one at a time. Ask yourself what are the worse case scenarios, how they might affect you, and what you would do. Ask yourself how likely it is to happen, why you think it might happen, whether its occurrence would be positive or negative and why. [View Highlight](https://read.readwise.io/read/01j83qra9bkp4fzk2vrzhm0erf))
+
+The anticipation of something is usually much worse than when it actually occurs. This is because before something happens, we can’t do anything about it. By journaling through our fears, we’re doing something proactive and preemptive, which can help us work through our fears rather than letting them fester. [View Highlight](https://read.readwise.io/read/01j83sq982ymg9stz6mxbf4776))
+
+Prompt: Write A Letter That You’ll Never Send
+**Use when: The thought of someone is making you anxious.** [View Highlight](https://read.readwise.io/read/01j83sqq9zcr1aahr612jqkh2x)) [[journaling/prompt]]
+
+Address the letter to the person you need or want to talk to and say everything you want to say. This prompt will help you organise your thoughts and feelings about this person. You can also be as honest as you need because you’re never going to send the letter. [View Highlight](https://read.readwise.io/read/01j83sspweq1e87w1cgb2r1dzd))
+
+If you enjoy letter writing, you could also try a love letter. Write to your younger self (*or your future self!*) and practice being your own best friend. After all, self-love and compassion are also powerful tools for combating chronic anxiety. [View Highlight](https://read.readwise.io/read/01j83stt71p8h0kjdmf24mhpat)) [[journaling/prompt]]
+
+Prompt: Where Am I Right Now?
+**Use when: You need to feel grounded.** [View Highlight](https://read.readwise.io/read/01j83svpn19zb9t7k0rch206pr)) [[journaling/prompt]]
+
+The 5-4-3-2-1 coping technique for anxiety attacks is all about bringing your attention back to the now. ... In your journal, write the following:
+• Five things that you see
+• Four things that you can touch
+• Three things that you can hear
+• Two things that you can smell
+• One thing that you can taste
+
+Prompt: Why Do I Feel Unwell?
+**Use when: You’re feeling agitated, stressed or anxious for no apparent reason.** [View Highlight](https://read.readwise.io/read/01j83syhvp6jy0mvk0q32qhx8a)) [[journaling/prompt]]
+
+When I’m [so overwhelmed that I can’t think](https://www.simplyfiercely.com/overwhelmed-by-life/) about how to care for myself, I turn to my journal. I start with the line *‘I feel unwell because…’* and let my thoughts flow. Answering this question leads me to discover what I need (whether it be rest, connection, or creative expression). By delving into why I feel unwell, I learn what I can do about it, which improves how I care for myself. [View Highlight](https://read.readwise.io/read/01j83t1ryr94dwp6syd3c051ga))
+
+Prompt: How Can This Moment Inform My Future
+**Use when: You feel like you’ve made a mistake.** [View Highlight](https://read.readwise.io/read/01j83t2c2z79vpc1r0kfpmxz6k)) [[journaling/prompt]]
+
+Taking time to acknowledge our mistakes, understand why they occurred, and think about how we can make better choices in the future is healthy. [View Highlight](https://read.readwise.io/read/01j83t889905a6az7md4d70z3x))
+
+Mistakes are inevitable and mindfully working through them helps us accept them as part of life and let go of perfectionism. [View Highlight](https://read.readwise.io/read/01j83t97qhrr5fxj9nttkbke0n))
+
+Prompt: I Am Lucky To…
+**Use when: You are feeling negative.** [View Highlight](https://read.readwise.io/read/01j83t9evy5zxg8m3qf6r5gkw1)) [[journaling/prompt]]
+
+Gratitude is one of the healthiest emotions to sit with. It has the power to shift your mindset from scarcity to abundance, which can be helpful when you’re feeling stressed or just plain having a bad day. [View Highlight](https://read.readwise.io/read/01j83xxb6jwrvvdrg4a7wmvb5n))
+
+try reflecting on:
+• a favourite memory
+• your own strengths
+• song lyrics or a list of favourite songs
+• your greatest lessons
+• your biggest supporter
+• how you overcame a negative experience in the past [View Highlight](https://read.readwise.io/read/01j83xvwfvcc5tjc4an2a92671))
+
diff --git a/Readwise/APCA in a Nutshell.md b/Readwise/APCA in a Nutshell.md
new file mode 100644
index 0000000..1c288f3
--- /dev/null
+++ b/Readwise/APCA in a Nutshell.md
@@ -0,0 +1,25 @@
+# APCA in a Nutshell
+
+
+
+## Metadata
+- Author: [[APCA]]
+- Full Title: APCA in a Nutshell
+- Category: #articles
+- Document Tags: [[design]]
+- URL: https://git.apcacontrast.com/documentation/APCA_in_a_Nutshell#use-case--size-ranges
+- Archive: https://web-archive.alecodes.page/bookmarks?bf=1&search=&title=APCA%20in%20a%20Nutshell
+> [!tldr]
+> The Accessible Perceptual Contrast Algorithm (APCA) is a new method for measuring color contrast and improving readability on screens. It provides a more accurate way to assess contrast than the existing WCAG guidelines, focusing on user needs and different text sizes. APCA includes various levels of contrast to help designers create more accessible content, especially for body text and large elements.
+
+## Highlights
+Use-Case & Size Ranges
+These general levels are appropriate for use by themselves, without the need to reference a lookup table. APCA reports contrast as an Lc value (lightness contrast) from **Lc 0** to **Lc 105+**. For accessibility, consider Lc 15 the point of invisibility for many users, and Lc 90 as preferred for body text.
+• **Lc 90** • Preferred level for fluent text and columns of body text with a font no smaller than 18px/weight 300 or 14px/weight 400 (normal), or non-body text with a font no smaller than 12px/400. Also a recommended minimum for extremely thin fonts with a minimum of 24px at weight 200. Lc 90 is a *suggested maximum* for **very large and bold fonts** (greater than 36px bold), and large areas of color. Small fonts do not have a maximum.
+• **Lc 75** • The *minimum* level for columns of body text with a font no smaller than 24px/300 weight, 18px/400, 16px/500 and 14px/700. This level may be used with non-body text with a font no smaller than 15px/400. Also, Lc 75 should be considered a minimum for larger for any larger text where readability is important.
+• **Lc 60** • The *minimum* level recommended for content text that is not body, column, or block text. In other words, text you want people to read. The minimums: no smaller than 48px/200, 36px/300, 24px normal weight (400), 21px/500, 18px/600, 16px/700 (bold). These values based on the reference font Helvetica. To use these sizes as body text, add Lc 15.
+• **Lc 45** • The *minimum* for larger, heavier text (36px normal weight or 24px bold) such as headlines, and large text that should be fluently readable but is not body text. This is also the minimum for pictograms with fine details, or smaller outline icons.
+• **Lc 30** • The *absolute minimum* for any text not listed above, including text considered as “spot readable”. This includes placeholder text and disabled element text, and some non-content like a copyright bug. This is also the minimum for large/solid semantic & understandable non-text elements such as “mostly solid” icons or pictograms. Generally no less than 5.5px solid in its smallest dimension.
+• **Lc 15** • The *absolute minimum* for any non-semantic non-text that needs to be *discernible*, and is no less than 5px (solid) in its smallest dimension. This may include dividers, and in *some* cases large buttons or thick focus-visible outlines, but does *not* include fine details which have a higher minimum. **Designers should treat anything below this level as invisible**, as it will not be visible for many users. This minimum level should be avoided for any items important to the use, understanding, or interaction of the site.
+These define the basic minimum levels, what you might think of as AA in the old WCAG 2. For the equivelent to AAA, simply increase the contrast values by Lc 15. [View Highlight](https://read.readwise.io/read/01j80shgn3ccehc3qxw0at9gsz))
+
diff --git a/Readwise/Code-Splitting for Libraries—bundling for NPM With Rollup 1.0.md b/Readwise/Code-Splitting for Libraries—bundling for NPM With Rollup 1.0.md
new file mode 100644
index 0000000..16bd9b4
--- /dev/null
+++ b/Readwise/Code-Splitting for Libraries—bundling for NPM With Rollup 1.0.md
@@ -0,0 +1,37 @@
+# Code-Splitting for Libraries—bundling for NPM With Rollup 1.0
+
+
+
+## Metadata
+- Author: [[Lukas Taegert]]
+- Full Title: Code-Splitting for Libraries—bundling for NPM With Rollup 1.0
+- Category: #articles
+- Document Tags: [[dev]] [[dev/javascript]]
+- URL: https://levelup.gitconnected.com/code-splitting-for-libraries-bundling-for-npm-with-rollup-1-0-2522c7437697
+- Archive: https://web-archive.alecodes.page/bookmarks?bf=1&search=&title=Code-Splitting%20for%20Libraries%E2%80%94bundling%20for%20NPM%20With%20Rollup%201.0
+> [!tldr]
+> Rollup 1.0 introduces code-splitting as a key feature for bundling JavaScript libraries. The article explains how to create an efficient library called "fancy-case" that allows users to import specific utility functions while offering multiple formats for different environments. It highlights the benefits of using ES modules and provides guidance on configuring Rollup for optimal performance.
+
+## Highlights
+CommonJS module for Node
+This is probably the most important target. This allows Node users and legacy bundlers to import your library as a [CommonJS module](http://wiki.commonjs.org/wiki/Modules/1.1.1) via [View Highlight](https://read.readwise.io/read/01j864mhazhr25k1zh6ngzn2x8))
+
+Single bundle to be used in a script tag
+The “traditional way” of distributing JavaScript may still be interesting for small, hand-crafted sites with minimal setup. The bundle creates a global variable via which its exports can be accessed. [View Highlight](https://read.readwise.io/read/01j864mcsdtwp63pehyqf3cex6))
+
+AMD module to be used with an AMD loader
+There are still quite a few [AMD/RequireJS](https://requirejs.org/) based projects out there. We can distribute a file that can itself be used as a dependency of an AMD module. [View Highlight](https://read.readwise.io/read/01j864mvbta1gpk2n5rptm0m5z))
+
+ES module for modern bundlers
+[ECMAScript modules](http://exploringjs.com/es6/ch_modules.html) are now the official, standardized JavaScript module format. [View Highlight](https://read.readwise.io/read/01j864n23372ch1nkz5xrxwqp2))
+
+Direct imports for CJS or ESM consumers
+An emerging new pattern especially for libraries with many independent utility functions is to allow users to import independent parts of the library from separate files. Node users could write
+const upper = require(**'fancy-case/cjs/upper'**);
+console.log(upper('some Text'));
+while ESM consumers could write
+import upper from **'fancy-case/esm/upper'**;
+console.log(upper('some Text')); [View Highlight](https://read.readwise.io/read/01j864p33y06v43pdzwxrgksxg))
+
+Rollup supports a special output format called a [“Universal Module Definition”](https://github.com/umdjs/umd), which simultaneously supports the CJS, script tag, and ESM use cases. To create it, add a new file called `rollup.config.js` to the root of your project [View Highlight](https://read.readwise.io/read/01j864rhxg10v4kb7fnf2a869x))
+
diff --git a/Readwise/Dependency Injection, the Best Pattern.md b/Readwise/Dependency Injection, the Best Pattern.md
new file mode 100644
index 0000000..a9e41e7
--- /dev/null
+++ b/Readwise/Dependency Injection, the Best Pattern.md
@@ -0,0 +1,22 @@
+# Dependency Injection, the Best Pattern
+
+
+
+## Metadata
+- Author: [[CodeAesthetic]]
+- Full Title: Dependency Injection, the Best Pattern
+- Category: #articles
+- URL: https://www.youtube.com/watch?v=J1f5b4vcxCQ
+- Archive: https://web-archive.alecodes.page/bookmarks?bf=1&search=&title=Dependency%20Injection%2C%20the%20Best%20Pattern
+> [!tldr]
+> The text explains how to use dependency injection to build an attachment service that uploads files. By creating an interface for storage and injecting it into the request handler, the code becomes simpler and less error-prone. This approach also allows for easy testing with mock implementations.
+
+## Highlights
+have a piece of code which uses another piece of code, and instead of using that code directly, it's passed in instead. [View Highlight](https://read.readwise.io/read/01j8b4fbn7xc4day63pshpds1t))
+
+Injection basically just lets us pick and choose from our compatible puzzle pieces and then slot them in when we need them. [View Highlight](https://read.readwise.io/read/01j8b51ysp8pj6g1sk4cc94qzp))
+
+We can use injection to inject fake or mock implementations instead, which basically means we can slice and dice up our architecture to isolate sections of code during testing. [View Highlight](https://read.readwise.io/read/01j8b54d9xcz7p57m37apc92xm))
+
+A natural side effect of having nice code is that it's easy to test without needing to hack around the code structure. If you find yourself asking, how can I test a private method? Or I need to set some internal variable in order to test. That's a signal that you maybe need to pull some stuff out, that you need to isolate some part of it by separating it and injecting it instead. [View Highlight](https://read.readwise.io/read/01j8b57129cky28vhfsq2fd38y))
+
diff --git a/Readwise/How the Index Card Method Improves Your Knowledge Gathering.md b/Readwise/How the Index Card Method Improves Your Knowledge Gathering.md
new file mode 100644
index 0000000..3647918
--- /dev/null
+++ b/Readwise/How the Index Card Method Improves Your Knowledge Gathering.md
@@ -0,0 +1,28 @@
+# How the Index Card Method Improves Your Knowledge Gathering
+
+
+
+## Metadata
+- Author: [[THINKERS Notebook]]
+- Full Title: How the Index Card Method Improves Your Knowledge Gathering
+- Category: #articles
+- Document Tags: [[notetaking]] [[productivity]]
+- URL: https://thinkersnotebook.com/blogs/news/how-the-index-card-method-improves-your-knowledge-gathering
+- Archive: https://web-archive.alecodes.page/bookmarks?bf=1&search=&title=How%20the%20Index%20Card%20Method%20Improves%20Your%20Knowledge%20Gathering
+> [!tldr]
+> The index card method is a simple and effective way to organize and connect information for writing, research, and projects. It allows you to summarize ideas on cards, linking them to main themes for easy reference. You can even adapt this method to digital formats for better organization and searchability.
+
+## Highlights
+The key components of an effective index card method are:
+• The information on the card is summarized or simplified.
+• Each card is linked back to a main thread or theme of information via a number, a tag, or a title (or a mix of all three). [View Highlight](https://read.readwise.io/read/01j80drzv3a1w0wppg4syztwc3))
+
+There are other ways you can use this method in a notebook, to help order and structure your projects and ideas:
+• Organize your thoughts and findings around a particular topic you’re researching.
+• Scope your long-form article, thesis or book, summarizing each section or chapter.
+• Store important research data for key business metrics.
+• Create reference cards for your business presentation.
+• Track specific habits and goals for a week or month.
+• Keep note of specific birthdays and recurring events by month.
+• The key to using an index card method effectively lies in how you connect the separate ideas and information that you’re listing. [View Highlight](https://read.readwise.io/read/01j80e0c34a7kbvxsy3cbbkf25))
+
diff --git a/Readwise/How to Organize a Notebook for Work.md b/Readwise/How to Organize a Notebook for Work.md
new file mode 100644
index 0000000..a29e74e
--- /dev/null
+++ b/Readwise/How to Organize a Notebook for Work.md
@@ -0,0 +1,54 @@
+# How to Organize a Notebook for Work
+
+
+
+## Metadata
+- Author: [[Elizabeth Harrin]]
+- Full Title: How to Organize a Notebook for Work
+- Category: #articles
+- Document Tags: [[notetaking]] [[productivity]]
+- URL: https://rebelsguidetopm.com/how-to-organize-a-notebook-for-work/
+- Archive: https://web-archive.alecodes.page/bookmarks?bf=1&search=&title=How%20to%20Organize%20a%20Notebook%20for%20Work
+> [!tldr]
+> This text provides tips on organizing a notebook for work, emphasizing the importance of personalizing the system to suit individual needs. It suggests practical strategies like cutting corners to locate pages easily and using sections to categorize notes effectively. The author shares insights on maximizing a notebook's potential as a productivity tool within a larger task management system.
+
+## Highlights
+2. Put the To Do list at the back [View Highlight](https://read.readwise.io/read/01j80bnsjvv4jdnga09mjrajqx))
+
+3. Put important information on the inside front cover ... • Cost codes, timesheet codes or project codes
+• Important telephone numbers
+• Instructions on how to change your voicemail (can you tell that’s a real example from inside my book?!)
+
+You’ll get through a lot of work notebooks in time, so put the start date on the front cover or one of the first inside pages so you know what time period this book covers. [View Highlight](https://read.readwise.io/read/01j80bpqqt6fhjntgx30tkvnmn))
+
+5. Organize the inside ... I don’t use page numbers in my books because they are free-flow for my notes and tend to be a chronological representation of what I was working on at the time. ... • Leave a page at the front for the table of contents or keep a page at the back for the index
+• Add page numbers to each page
+• Mark where things are in the notebook as you go.
+
+I don’t section my work because as a project manager, I find much of my work overlaps. [View Highlight](https://read.readwise.io/read/01j80bs5d5q3vp2ccdpq97j1fp))
+
+If you don’t want to number and structure, an alternative option is to have a different notebook for each project or to use sections. [View Highlight](https://read.readwise.io/read/01j80bsg6hnpaqwjvyjnszmsxy))
+
+6. Use sections ... • Weekly goals and objectives (or monthly/annual goals)
+• Trackers for habits e.g. drinking water, gratitude
+• Lists e.g. team birthdays. ... Use sticky notes or sticky tabs to section off the book and make it easier to find the right page when you need it.
+
+in circles to help them stand out in the notes:
+A: Action – for specific tasks to be done
+D: Decision – normally to be transferred to a decision log or confirmed on email so no one can forget that we made it.
+R: Risk – to be transferred to the project risk log and something done about it.
+I: Issue – to be transferred to the issue log and flagged with whomever is going to be able to do something about it.
+Star – something important. Normally something that has to be done today. [View Highlight](https://read.readwise.io/read/01j80am80gt459xt3n5hkv1mr5))
+
+I make time to rewrite the important lists in my book (the actions) on a regular basis. It isn’t strictly necessary, but it helps me clear my mind and focus on what is still to do. [View Highlight](https://read.readwise.io/read/01j80aq18td7pq8hk3ty7fh0pg))
+
+However you use your notebook, I would recommend allocating some time on a regular basis to go through it and tidy it up. Mark tasks as complete, transfer notes to other tools, re-write lists. Just refresh yourself on what is in there and check it is still working for you. [View Highlight](https://read.readwise.io/read/01j80ar15h0jat05dtvevj5362))
+
+Your notebook should be part of a whole productivity and task management system. It should fit alongside your online tools. [View Highlight](https://read.readwise.io/read/01j80ayzgm5px6mvxbvbnpxr8m))
+
+Your system should work in the round. No one in your team should be waiting to be told what to do because you wrote it down in the wrong place. [View Highlight](https://read.readwise.io/read/01j80b1xq3h5rpdrrwmnbvkgqg))
+
+Notebook organization should be simple. If you create a system that is too difficult to stick to, then you won’t stick to it. [View Highlight](https://read.readwise.io/read/01j80b2b9t15za4kfvtmv0ytpr))
+
+Remember, the way you organize your work notebook can evolve over time. Switch up how you use your notebook as your needs change. [View Highlight](https://read.readwise.io/read/01j80bbpykp4yqskxt4g5m1aaz))
+
diff --git a/Readwise/How to Rebuild Your Routines When Everything Changes Rewind.md b/Readwise/How to Rebuild Your Routines When Everything Changes Rewind.md
new file mode 100644
index 0000000..af2dd89
--- /dev/null
+++ b/Readwise/How to Rebuild Your Routines When Everything Changes Rewind.md
@@ -0,0 +1,39 @@
+# How to Rebuild Your Routines When Everything Changes | Rewind
+
+
+
+## Metadata
+- Author: [[How to ADHD]]
+- Full Title: How to Rebuild Your Routines When Everything Changes | Rewind
+- Category: #articles
+- URL: https://youtube.com/watch?v=-c1HY-vrmIQ&si=7ximCdZha4zJg-LR
+- Archive: https://web-archive.alecodes.page/bookmarks?bf=1&search=&title=How%20to%20Rebuild%20Your%20Routines%20When%20Everything%20Changes%20%7C%20Rewind
+> [!tldr]
+> The video discusses how to rebuild routines after significant changes, especially for those with ADHD. It offers eight practical tips, such as keeping what works, allowing time for transitions, and managing stress. The key message is to be patient with yourself and acknowledge your achievements while adjusting to new routines.
+
+## Highlights
+keep what you know works it can be tempting to start with a blank slate but the less you change the quicker you'll adjust to those changes so anything you liked from your old
+routine that would still work with the new one consider keeping [View Highlight](https://read.readwise.io/read/01j8b6stmxqkv0rx1yq54y0fpb))
+
+design the rest with you in mind hang on current you not future you [View Highlight](https://read.readwise.io/read/01j8b6x2we07a50fpdy60tx1xf))
+
+give yourself plenty of white space in your schedule remember transitions will probably take longer at first because you're not used to your new routines [View Highlight](https://read.readwise.io/read/01j8b6z2dx0wnx94kde9a96xre))
+
+can speed up the process of setting those new routines and reduce the transition time between them by mentally walking through your new routines a few times before you need to start using them [View Highlight](https://read.readwise.io/read/01j8b71t112qtedbcbxbyfd2q8))
+
+write the new routines down ... put it in your schedule create a habit tracker sticker chart use an app
+
+there's a surprising amount that will suddenly not be automatic when you go through Big Life Changes again speaking from experience once you're used to your routines your brain will usually remind you what's next until then you'll probably need some help so you need to
+have a way of keeping yourself on track [View Highlight](https://read.readwise.io/read/01j8b776eyyvx1aq905tatr726))
+
+if at all humanly possible wait until you're used to your new routine before adding in stuff that you've never done before [View Highlight](https://read.readwise.io/read/01j8b7be7rkvdf5z68nva3fkx5))
+
+manage your stress levels change even good change is stressful expect small unexpected changes to affect you more than usual right now because they're not
+really small changes they're Peaks on a mountain of giant changes [View Highlight](https://read.readwise.io/read/01j8b7efp3k1eb92dakzhy2m6z))
+
+acknowledge your achievements it can be really easy when you're adjusting to a new routine to only see the stuff you didn't get to check out all the stuff you did even little things like getting to work on time that you might otherwise take for granted are a huge
+Victory when you did it with a new routine [View Highlight](https://read.readwise.io/read/01j8b7jk8wq2xtpscy1fdbhesg))
+
+tweak as necessary if anyone gets all of their routines right on their first try I'm going to very annoyed impressed but
+annoyed it's totally normal for it to take some trial and error to figure out what works for you so expect that things will go wrong and you will need to make adjustments doesn't mean you're doing something wrong it's part of the process [View Highlight](https://read.readwise.io/read/01j8b7ntbt4jbsb7ma3axe4z3b))
+
diff --git a/Readwise/How to Start Journaling.md b/Readwise/How to Start Journaling.md
new file mode 100644
index 0000000..f42f3cf
--- /dev/null
+++ b/Readwise/How to Start Journaling.md
@@ -0,0 +1,30 @@
+# How to Start Journaling
+
+
+
+## Metadata
+- Author: [[Jennifer]]
+- Full Title: How to Start Journaling
+- Category: #articles
+- URL: https://www.simplyfiercely.com/start-journaling/
+- Archive: https://web-archive.alecodes.page/bookmarks?bf=1&search=&title=How%20to%20Start%20Journaling
+> [!tldr]
+> Journaling is a powerful habit that promotes self-awareness and helps you make intentional choices in life. To start, just relax and begin writing about your thoughts and feelings, using prompts if needed. Sticking with journaling daily can lead to greater clarity and personal growth.
+
+## Highlights
+Journaling helps combat this short-sightedness by encouraging us to step back and consider the big picture. [View Highlight](https://read.readwise.io/read/01j83ye06dw8vkysgntnavndb8))
+
+First and foremost, relax and let go of any ideas about doing it the “right” way— because when it comes to journaling, there’s no such thing! Your journal is a personal space for you to use however you see fit. [View Highlight](https://read.readwise.io/read/01j83yn2d1qgem2pycxrsth3gj))
+
+After that, the best way to start journaling is to just begin. [View Highlight](https://read.readwise.io/read/01j83yp4c2axwtzy3k87e98ajt))
+
+If you don’t know what to write about, a great place to begin is by **[asking questions](https://www.simplyfiercely.com/7-questions-to-inspire-intentional-living/).** My favourites include:
+• *How do you feel right now?*
+• *Why do you feel that way?*
+• *How do you want to feel?*
+• *What can you do to feel that way?* [View Highlight](https://read.readwise.io/read/01j83yqf5g8j5h964d735bfexe)) [[journaling/prompt]]
+
+If you don’t feel comfortable writing long, in-depth entries in your journal then find something that works for you. Again, there are no right or wrong ways to journal as long as you’re exploring your thoughts and feelings. [View Highlight](https://read.readwise.io/read/01j84amwhygt3bsycq85eptcs4))
+
+**Make journaling a special ritual.** Try and do it at the same time every day and treat it as a special event, not a chore! Light a candle, make a hot drink, burn incense—whatever makes the experience special for you. [View Highlight](https://read.readwise.io/read/01j84anevvcn0ydv0287v7yjff))
+
diff --git a/Readwise/How to Think in Writing.md b/Readwise/How to Think in Writing.md
new file mode 100644
index 0000000..2b66728
--- /dev/null
+++ b/Readwise/How to Think in Writing.md
@@ -0,0 +1,52 @@
+# How to Think in Writing
+
+
+
+## Metadata
+- Author: [[Henrik Karlsson]]
+- Full Title: How to Think in Writing
+- Category: #articles
+- Document Tags: [[star]]
+- URL: https://substack.com/home/post/p-143987982
+- Archive: https://web-archive.alecodes.page/bookmarks?bf=1&search=&title=How%20to%20Think%20in%20Writing
+
+> [!note]
+> Este articulo habla sobre cómo utilizar la escritura como un medio para realizar un análisis crítico de nuestros propios pensamientos e ideas y obtener su completo potencial.
+> ---
+> Utiliza un metodo kinda like Phoenix Wright cross examination:
+> - hacer nuestros pensamientos solidos y especificos al escribirlos
+> - Decantarlos hasta poder obtener una conclusión, una conjetura o una hipótesis
+> - Desafiar esta conclusion intentando probarla verdadera o falsa, buscando sus fallas y grietas. Con _"pressionar"_ (follow up questions)
+> - Esto nos proveerá más información, más pensamientos y más ideas que pueden re-definir nuestra conclusión
+> [!tldr]
+> Writing helps refine thinking by making ideas more precise and complete. Without writing, one may not fully form or realize the limitations of their ideas. By unfolding and probing claims through writing, one can discover flaws, refine understanding, and reach deeper insights.
+
+## Highlights
+Ideas can feel complete. It's only when you try to put them into words that you discover they're not. So if you never subject your ideas to that test, you'll not only never have fully formed ideas, but also never realize it. [View Highlight](https://read.readwise.io/read/01j8b867hqxmxzdkn3q3pjqbm4))
+
+Good thinking is about pushing past your current understanding and reaching the thought behind the thought. [View Highlight](https://read.readwise.io/read/01j8b8cww40tqsnbaw3k42mgvn))
+
+When I write, I get to observe the transition from this fluid mode of thinking to the rigid. As I type, I’m often in a fluid mode—writing at the speed of thought. I feel confident about what I’m saying. But as soon as I stop, the thoughts solidify, rigid on the page, and, as I read what I’ve written, I see cracks spreading through my ideas. What seemed right in my head fell to pieces on the page. [View Highlight](https://read.readwise.io/read/01j8b8ezy6ywq99f4dkz8r3ymd))
+
+a conjecture,” a qualified guess based on limited information. A hypothesis. [View Highlight](https://read.readwise.io/read/01j8b8hry74ry71zk4ffareecj))
+
+Forcing the diffuse ideas and impressions in your head into a definite statement is an art form. You have to grab hold of what is floating and make it rigid and sharp. It can feel almost embarrassing–revealing your ignorance with as much vulnerability as possible. [View Highlight](https://read.readwise.io/read/01j8b8ksn5s7t4bn3wwefxeqwr))
+
+By unfolding I mean “interrogating the conclusion to come up with an explanation of why it *could* be true.” What premises and reasoning chains leads to this conclusion? The explanation isn’t meant to prove that your conclusion was right. It is just a way of unpacking it. [View Highlight](https://read.readwise.io/read/01j8b8nc9p2ywzsmztc4d6zjyk))
+
+Since the goal is to find flaws in our guesses (so that we can change our minds, refine our mental models and our language, and be more right) unfolding a claim through an explanation is progress. Even if the explanation is wrong. [View Highlight](https://read.readwise.io/read/01j8b8q53msmbr9kbr9dzhew55))
+
+Once I unfold my understanding in writing, I often see holes right away. I start correcting myself and discarding ideas already while typing. I cut ideas that are obviously flawed. I rewrite what feels ambiguous to make it sharper–more precise, concrete, unhedged, and true to my understanding. [View Highlight](https://read.readwise.io/read/01j8b8v6s8028792yvcwgy19n0))
+
+I tend to go through my list of premises and assumptions and ask follow-up questions to myself, to further unfold my conclusion. [View Highlight](https://read.readwise.io/read/01j8b8y1z5wbjfjkjpjcwkwj4b))
+
+Now that I have spelled out my position and fixed the obvious flaws, I start probing myself more seriously to see if I can get the argument to break down. [View Highlight](https://read.readwise.io/read/01j8b9fcg5r389f7pzvsfad82m))
+
+If one of the premises I have unfolded is a factual claim, I’ll spend a few minutes skimming research in the area to see how well my position holds up. [View Highlight](https://read.readwise.io/read/01j8b9g5d16dwc6dqe3b6x7hag))
+
+But often the type of problem I like to think about is too personal and messy and qualitative to be resolved cleanly through a statistically significant study. What I do in these situations instead is to consider *counterexamples*. ... I like to visualize concrete situations when I make an argument ... When I have a concrete situation in mind, I can ask myself, “What is a situation where the opposite happened? Why was that?” I can list the characteristics of the situation that inform my conclusion and then systematically look for cases that have other characteristics.
+
+Counterexamples are useful in two ways. Either you find a counterexample that a) proves one of the premises wrong but b) does not change your mind about the conclusion. Lakatos calls this a local (and non-global) counterexample. This means there is something wrong with your unfolding. ... Local counterexamples help you improve your explanation and get a better understanding.
+
+Other times, the counterexample you find undermines the whole idea—a *global counterexample*. You unfold your conclusion and discover that one of the premises does not hold up, and there is no way to patch it. The fracture spreads right up to the conclusion. Now—this is what we have been longing for—there is a big hole of confusion where before there was a mental model. It is time to replace it with something more subtle and deep that incorporates the critique. [View Highlight](https://read.readwise.io/read/01j8b9vyrraya2jxw8ygqhb7nz))
+
diff --git a/Readwise/Journaling for Personal Development Stress Management.md b/Readwise/Journaling for Personal Development Stress Management.md
new file mode 100644
index 0000000..4238a8e
--- /dev/null
+++ b/Readwise/Journaling for Personal Development Stress Management.md
@@ -0,0 +1,69 @@
+# Journaling for Personal Development: Stress Management
+
+
+
+## Metadata
+- Author: [[Barbara H. Pugh]]
+- Full Title: Journaling for Personal Development: Stress Management
+- Category: #articles
+- Document Tags: [[notetaking]]
+- URL: https://priscillapalmer.com/journaling/
+- Archive: https://web-archive.alecodes.page/bookmarks?bf=1&search=&title=Journaling%20for%20Personal%20Development%3A%20Stress%20Management
+> [!tldr]
+> Journaling is a helpful tool for managing stress and promoting personal growth by allowing individuals to reflect on their thoughts and emotions. It can lead to increased self-awareness, emotional release, and clarity about stressors. By regularly writing in a journal, people can develop strategies to cope with challenges and improve their overall well-being.
+
+## Highlights
+Research suggests that engaging in regular journaling can have numerous benefits when it comes to stress reduction and personal development. Firstly, by writing down one’s thoughts and feelings related to stressful events or situations, individuals are able to gain clarity and perspective on their internal state. This process enables them to identify patterns or triggers that contribute to their stress levels, thereby empowering them with the knowledge needed to make positive changes in their lives. Additionally, journaling provides a safe outlet for expressing emotions that may be difficult to articulate verbally. Through this cathartic release of pent-up feelings, individuals can experience relief from emotional distress while gaining a sense of emotional release and catharsis. [View Highlight](https://read.readwise.io/read/01j82r0yf8r0wfj54mg92wx0rv))
+
+Moreover, journaling can also serve as a means of problem-solving and decision-making. When faced with stressors or challenges, writing about them allows individuals to explore different perspectives and potential solutions. This process of self-reflection and brainstorming can lead to increased insight and clarity, helping individuals develop effective strategies for managing their stressors. [View Highlight](https://read.readwise.io/read/01j82r1qjbd8pykyn658ae279f))
+
+Furthermore, the act of journaling itself can be a calming and grounding practice. Taking the time to sit down, focus on one’s thoughts, and put them into words can create a sense of mindfulness and present-moment awareness. This mindfulness aspect of journaling has been shown to promote relaxation, reduce anxiety levels, and improve overall mental well-being. [View Highlight](https://read.readwise.io/read/01j82r23yyw2bs77zw57sdm8mk))
+
+There are no strict rules for journaling; Sarah can write freely without worrying about grammar or structure – the goal is simply to allow her thoughts and emotions to flow onto the pages. [View Highlight](https://read.readwise.io/read/01j82r51a1ef5bnr6mhk69e8q6))
+
+Here are some key benefits of journaling for stress reduction:
+• **Emotional release:** Writing down our thoughts and feelings allows us to acknowledge and process them more effectively. It provides a safe space to express raw emotions without judgment or consequences.
+• **Perspective gain:** Through journaling, we gain perspective on our problems and challenges. This shift in viewpoint enables us to approach difficulties with greater clarity and objectivity.
+• **Problem-solving:** Journaling facilitates problem-solving by allowing us to explore different solutions and evaluate their pros and cons. It helps break down complex issues into manageable parts.
+• **Gratitude cultivation:** Writing about the things we are grateful for fosters positivity and shifts our focus away from stressors. This practice encourages mindfulness and promotes a sense of contentment. [View Highlight](https://read.readwise.io/read/01j82rdzjqkbhtddtevdwsb6ct))
+
+Set aside dedicated time: Find a quiet space where you can focus solely on your writing without distractions. Allocating even just 10-15 minutes each day can make a significant difference in managing stress. [View Highlight](https://read.readwise.io/read/01j83g3ykzypexdx6yg264s24a))
+
+Choose a format that suits you: Whether it’s pen and paper or digital platforms, select a medium that feels comfortable for you. Experiment with different styles such as free-writing or structured prompts until you find what resonates best. [View Highlight](https://read.readwise.io/read/01j83g47r6y96fpxd11gq003hg))
+
+Be non-judgmental: Remember that your journal is a safe space for self-expression; there are no right or wrong answers. Allow yourself to freely explore your thoughts and feelings without censoring or criticizing them. [View Highlight](https://read.readwise.io/read/01j83g4f15c6h136m28f6ccymb))
+
+Incorporate gratitude practices: Cultivating gratitude has been shown to reduce stress levels significantly. Consider including a regular gratitude reflection in your journal entries by listing things you’re grateful for each day. [View Highlight](https://read.readwise.io/read/01j83g4t6htbb3g9av0q4czz0x))
+
+Emotional release: The act of putting pen to paper allows individuals to express suppressed emotions effectively, leading to emotional catharsis. [View Highlight](https://read.readwise.io/read/01j83g8at9az6qxc9mbvvkrzma))
+
+Stress reduction: Journaling offers an outlet for processing stressful experiences and reducing psychological distress. [View Highlight](https://read.readwise.io/read/01j83g8qgcdemre6wj8jz8hp27))
+
+Problem-solving: By writing down challenges and brainstorming potential solutions, individuals can develop a clearer perspective on problems they face. [View Highlight](https://read.readwise.io/read/01j83g94f5gj99fz91kke20f1x))
+
+Self-discovery: Regular journaling promotes self-awareness and facilitates personal growth by uncovering deeper layers of oneself. [View Highlight](https://read.readwise.io/read/01j83g98fa6s5kwmepwea2jh0x))
+
+Reflect on Daily Experiences: Allocate dedicated time each day to record significant events or encounters that affected your mood positively or negatively. [View Highlight](https://read.readwise.io/read/01j83gcn96tpdded0ydrqb6052))
+
+Identify Emotional Responses: Pay attention to how you feel throughout the day by checking in with yourself regularly. Describe these emotions accurately using specific terms such as frustration, excitement, sadness, or contentment. [View Highlight](https://read.readwise.io/read/01j83gcy7trhxp8ccs2kecxz2s))
+
+Explore Underlying Causes: Dig deeper into your reactions by questioning why certain situations evoke particular emotional responses within you. [View Highlight](https://read.readwise.io/read/01j83gdgv4dd5z122knj7yyb8v))
+
+Monitor Physical Sensations: Observe any physical sensations associated with different emotions—such as increased heart rate during moments of anger or tension—to develop an awareness of your body’s response. [View Highlight](https://read.readwise.io/read/01j83ge9xk9phtja3tpg8mcw1c))
+
+**Identify coping mechanisms**: Reflect on past entries where you successfully managed stressful situations. Note down those techniques and activities that helped alleviate your stress levels. [View Highlight](https://read.readwise.io/read/01j83ghndtsnn7x0d678pgmtbz))
+
+**Set realistic goals**: Break down larger tasks into smaller, achievable goals. This will provide a sense of progress and accomplishment while reducing overwhelm. [View Highlight](https://read.readwise.io/read/01j83ghwt10bc8h4d5wmteebb2))
+
+**Practice self-care**: Prioritize activities that promote relaxation and well-being, such as exercise, meditation, or spending time in nature. [View Highlight](https://read.readwise.io/read/01j83gj5e39ctg3sj16zs2wpyw))
+
+**Seek support**: Reach out to trusted friends or family members who can offer guidance and encouragement during challenging times. [View Highlight](https://read.readwise.io/read/01j83gj9v2zbm0ggre2zrgk54a))
+
+Enhanced self-reflection: Practicing mindfulness allows individuals like Sarah to observe their thoughts and emotions without judgment, fostering greater understanding of their inner experiences. [View Highlight](https://read.readwise.io/read/01j83gmxxazma1tt6rb144p8xs))
+
+Improved emotional regulation: By cultivating awareness of their emotions through mindful journaling, individuals can develop strategies for managing challenging feelings effectively. [View Highlight](https://read.readwise.io/read/01j83gneyj2gmpr6zp51vybmjp))
+
+Increased clarity and perspective: Engaging in mindful reflection while journaling enables individuals to gain fresh insights and new perspectives on stressful situations. [View Highlight](https://read.readwise.io/read/01j83gnhg39rqb94yept0sk884))
+
+Strengthened resilience: Regularly practicing mindfulness in conjunction with journaling equips individuals with tools to navigate adversity more skillfully. [View Highlight](https://read.readwise.io/read/01j83gp7c9ekx44ypp3sgrc4hz))
+
diff --git a/Readwise/NeurodiversityWhitePaperFINAL.md b/Readwise/NeurodiversityWhitePaperFINAL.md
new file mode 100644
index 0000000..0d5ef84
--- /dev/null
+++ b/Readwise/NeurodiversityWhitePaperFINAL.md
@@ -0,0 +1,43 @@
+# NeurodiversityWhitePaperFINAL
+
+
+
+## Metadata
+- Author: [[cdsreg.com]]
+- Full Title: NeurodiversityWhitePaperFINAL
+- Category: #articles
+- Document Tags: [[design]] [[dev/accesibility]]
+- URL: https://www.cdsreg.com/assets/NeurodiversityWhitePaperFINAL.pdf
+- Archive: https://web-archive.alecodes.page/bookmarks?bf=1&search=&title=NeurodiversityWhitePaperFINAL
+
+## Highlights
+A structured and predictable layout helps all attendees find what they need. Keep headings, colors, and spacing consistent throughout your event web page and forms to create a familiar visual pattern for neurodiverse users. [View Highlight](https://read.readwise.io/read/01j80z4vtd50rd6mx389xj245v))
+
+Choose legible fonts and appropriate font sizes to enhance readability. [View Highlight](https://read.readwise.io/read/01j80z5jjrtnjhrzz45151hedj))
+
+neurodiverse audiences have a preference toward muted, pastel hues and neutral tones. Consider using a matte black background with two or three pastel hues to depict data, or a neutral tan, gray, or white background to prevent colors from overwhelming the reader. [View Highlight](https://read.readwise.io/read/01j80zay83cd3zs5mr5cv8f5bj))
+
+r [View Highlight](https://read.readwise.io/read/01j80zbt6qxbf3qnkdw3z8qee1))
+
+Simplify your event web page and forms by reducing unnecessary animations and busy backgrounds. A clean design minimizes sensory overload, allowing neurodiverse users to focus on essential content. [View Highlight](https://read.readwise.io/read/01j80zeq2075rv1rej44a7k0mk))
+
+o [View Highlight](https://read.readwise.io/read/01j80zezsd7tf9tmtrw0nbqgp3))
+
+Use clear headings, subheadings, and visual cues to establish a hierarchy of information. Neurodiverse users benefit from a structured content layout that helps them quickly grasp the importance and organization of information. [View Highlight](https://read.readwise.io/read/01j80zgp155t1g2japh3sm2jm3))
+
+Craft straightforward language and concise sentences to facilitate comprehension. Clear content helps neurodiverse individuals process information more easily and reduces the risk of misinterpretation. [View Highlight](https://read.readwise.io/read/01j80zhpdq1k0knybfacq7d8xz))
+
+Include descriptive image alternative text (also known as alt text or alt tags) for images and diagrams. This ensures that neurodiverse attendees who rely on screen readers or have difficulty interpreting visuals can access and understand the content. [View Highlight](https://read.readwise.io/read/01j80zn0r0zsw75xejf3gpam0t))
+
+Incorporate sufficient spacing between elements and paragraphs. White space enhances content digestion, prevents crowding, and enables neurodiverse users to focus on individual pieces of information. [View Highlight](https://read.readwise.io/read/01j80znjnftwn94d83yj7ejzkk))
+
+Provide the ability to adjust font sizes, color themes, and reading modes. Customizable options empower neurodiverse attendees to tailor the online experience to their preferences, enhancing their engagement. [View Highlight](https://read.readwise.io/read/01j80zq3newv6vp3g8qbhf9bda))
+
+Offer a straightforward navigation menu with clear labels. Neurodiverse individuals may rely on structured browsing paths such as breadcrumb navigation, and intuitive navigation ensures everyone can easily find and explore relevant content. [View Highlight](https://read.readwise.io/read/01j80zr6nsdb9nwndf5ydhqsmv))
+
+Incorporate text-to-speech features to accommodate auditory learners and those with reading challenges. Enabling this functionality allows neurodiverse users to absorb content through their preferred sensory channel. [View Highlight](https://read.readwise.io/read/01j80zscatb4sypv22d48c09y3))
+
+When using videos or audio, provide transcripts and captions. This supports attendees who may struggle with auditory or visual processing, ensuring they can access and comprehend information effectively. [View Highlight](https://read.readwise.io/read/01j80zszx3pkx6xhb3xrz1v49m))
+
+Ensure forms follow a logical flow and offer clear instructions, and that there are visual cues like highlighted inputs to help readers know where they are in the form. A step-by-step approach minimizes confusion and frustration for neurodiverse users during data input. [View Highlight](https://read.readwise.io/read/01j80ztdpbr8m2kbjc7pyss1ac))
+
diff --git a/Readwise/The Composition Over Inheritance Principle¶.md b/Readwise/The Composition Over Inheritance Principle¶.md
new file mode 100644
index 0000000..c1dc31f
--- /dev/null
+++ b/Readwise/The Composition Over Inheritance Principle¶.md
@@ -0,0 +1,32 @@
+# The Composition Over Inheritance Principle¶
+
+
+
+## Metadata
+- Author: [[python-patterns.guide]]
+- Full Title: The Composition Over Inheritance Principle¶
+- Category: #articles
+- URL: https://python-patterns.guide/gang-of-four/composition-over-inheritance/
+- Archive: https://web-archive.alecodes.page/bookmarks?bf=1&search=&title=The%20Composition%20Over%20Inheritance%20Principle%C2%B6
+> [!tldr]
+> The Composition Over Inheritance principle emphasizes that using composition (combining classes) is often more effective than inheritance (subclassing) for managing complexity in code. By employing design patterns like Adapter, Bridge, and Decorator, developers can create flexible logging systems that separate filtering from logging behavior. This approach allows for easier maintenance and the ability to mix and match different filters and handlers at runtime without creating a large number of subclasses.
+
+## Highlights
+Favor object composition over class inheritance. [View Highlight](https://read.readwise.io/read/01j8bahv00beg9tchtr4b8hkem))
+
+A crucial weakness of inheritance as a design strategy is that a class often needs to be specialized along several different design axes at once, leading to what the Gang of Four call “a proliferation of classes” in their Bridge chapter and “an explosion of subclasses to support every combination” in their Decorator chapter. [View Highlight](https://read.readwise.io/read/01j8bakccctxe895jka6vmvdyw))
+
+The total number of classes will increase geometrically if *m* and *n* both continue to grow. This is the “proliferation of classes” and “explosion of subclasses” that the Gang of Four want to avoid. [View Highlight](https://read.readwise.io/read/01j8baqph5c3v99rgn0p32tj70))
+
+The solution is to recognize that a class responsible for both filtering messages and logging messages is too complicated. In modern Object Oriented practice, it would be accused of violating the “Single Responsibility Principle.” [View Highlight](https://read.readwise.io/read/01j8bar8r89tdkkqwg09cy61bk))
+
+One solution is the Adapter Pattern: to decide that the original logger class doesn’t need to be improved, because any mechanism for outputting messages can be wrapped up to look like the file object that the logger is expecting. [View Highlight](https://read.readwise.io/read/01j8bat4m4e3sttcc3x9x8nbtw))
+
+Python encourages duck typing [View Highlight](https://read.readwise.io/read/01j8bav8whbf9z87ssg40m23kz))
+> [!note]
+> Duck typing: A programming concept primarily associated with the Python language, duck typing emphasizes an object's behavior (methods and properties) over its explicit type. The term is derived from the saying, "If it looks like a duck and quacks like a duck, it must be a duck," indicating that the suitability of an object is determined by the presence of certain methods and attributes rather than its inheritance or class. This approach allows for greater flexibility and adaptability in coding, as it encourages developers to focus on what an object can do rather than what it is, facilitating the creation of lightweight adapters and promoting code reuse.
+
+And so the subclass explosion is avoided! Logger objects and adapter objects can be freely mixed and matched at runtime without the need to create any further classes: [View Highlight](https://read.readwise.io/read/01j8baynydfgxctvwbdw0rca62))
+
+The Bridge Pattern splits a class’s behavior between an outer “abstraction” object that the caller sees and an “implementation” object that’s wrapped inside. We can apply the Bridge Pattern to our logging example if we make the (perhaps slightly arbitrary) decision that filtering belongs out in the “abstraction” class while output belongs in the “implementation” class. [View Highlight](https://read.readwise.io/read/01j8bb0dxxf1dewfg0jyv6w8tn))
+
diff --git a/Readwise/The Easy Intro to the APCA Contrast Method.md b/Readwise/The Easy Intro to the APCA Contrast Method.md
new file mode 100644
index 0000000..6136760
--- /dev/null
+++ b/Readwise/The Easy Intro to the APCA Contrast Method.md
@@ -0,0 +1,56 @@
+# The Easy Intro to the APCA Contrast Method
+
+
+
+## Metadata
+- Author: [[APCA]]
+- Full Title: The Easy Intro to the APCA Contrast Method
+- Category: #articles
+- Document Tags: [[design]] [[dev]]
+- URL: https://git.apcacontrast.com/documentation/APCAeasyIntro.html
+- Archive: https://web-archive.alecodes.page/bookmarks?bf=1&search=&title=The%20Easy%20Intro%20to%20the%20APCA%20Contrast%20Method
+> [!tldr]
+> The APCA Contrast Method is a new way to measure readability contrast, improving upon outdated WCAG 2.x guidelines. It focuses on lightness contrast, ensuring consistent visual perception across various colors and contexts. This method helps designers create more accessible web content, especially for users with different visual impairments.
+
+## Highlights
+**Visual Acuity (VA)**. VA refers to the ability to focus the eyes on a small item, to a sharp clear image. An acuity impairment limits how small an item we can focus on. An eye doctor can prescribe glasses or contacts, or perform surgery, to improve acuity. One way we can help accommodate acuity problems is to make things bigger. [View Highlight](https://read.readwise.io/read/01j80q19atq7kcj9e3xhjv3m6j))
+
+**Contrast Sensitivity (CS)**. CS is our ability to detect edges, lines, & letters against a background. CS is separate from acuity, and we can have good acuity with poor contrast sensitivity. We can improve our contrast perception by increasing the light on the subject. On a computer screen, we can increase the difference between a darker and a lighter color. [View Highlight](https://read.readwise.io/read/01j80q35df9x2a0t34ts8r7vyj))
+
+**Color Vision Deficiency (CVD)**. CVD is a reduced ability to distinguish different hues of color. (Sometimes called “colorblind”). Those with CVD have as good or better vision and contrast sensitivity, as standard vision. Thus, CVD does not impact readability per se. But CVD affects visual tasks such as reading a map or charts (dataviz), due to the need to discriminate colors (hue). [View Highlight](https://read.readwise.io/read/01j80q4ftg8t1nw6etbpna3xhf))
+
+contrast between two colors is sensitive to context. This means the other items around it affects how you see it. The “spatial characteristics” of line thickness or text weight & size, govern our contrast sensitivity. [View Highlight](https://read.readwise.io/read/01j80q6p2903s73a752yvtaj83))
+
+For readability, we need ample lightness-contrast, disregarding color as in hue. Color contrast, meaning hue/saturation, does not play a major role in readability. But ample lightness/darkness contrast enables fluent readability at best speed and comprehension. This is especially true for small body text, such as in columns or blocks. [View Highlight](https://read.readwise.io/read/01j80q83bh27pagnrreeqfeze8))
+
+• **The contrast sensitivity threshold** **(CS)** is the point of “just noticeable differences” (JND). That is, the point between visible and invisible.
+• Fluent readability refers to critical contrast. This is the smallest amount needed for best reading speed and comprehension. Peer-reviewed science tells us¹ contrast should be at least ten times the JND. The preferred contrast reserve is twenty times threshold for best fluent reading.
+• Spot readability means readable without significant effort. Spot reading is the lowest readable level, where the contrast needs to be three times the JND. This low level is useful for disabled controls, copyright bugs, and other non-content. [View Highlight](https://read.readwise.io/read/01j80qcm3haxxzbq87k5070v11))
+
+T [View Highlight](https://read.readwise.io/read/01j80qg1xsekbn8qen3c2b12ew))
+
+he following chart demonstrates the spatial nature of human contrast sensitivity. The text samples connect the abstract science of the CS curve to practical reality.
+ [View Highlight](https://read.readwise.io/read/01j80qftmhwxycjeeb699tq6cr))
+
+Lightness contrast (Lc) [View Highlight](https://read.readwise.io/read/01j80qn4r2akhdg9bqz128fehm))
+
+APCA generates a lightness contrast value for a minimum font weight, size, and color pair. This value is uniform to lightness/darkness perception. Regardless of how light or dark the two colors are, a given contrast value is visually consistent. Thus, ***Lc 60*** represents the same perceived contrast, for the range of available colors. [View Highlight](https://read.readwise.io/read/01j80qmyq1185m5xfy298yj5vt))
+
+The APCA Readability Criteria has a basic set of levels, related to use cases. For instance, ***Lc 90*** is preferred and ***Lc 75*** is the minimum for body text. This makes it easy to use APCA, very much like WCAG guideline 1.4.3 for ease of use. [View Highlight](https://read.readwise.io/read/01j80qqdpsrb9rk2ejpzwkfy49))
+
+The values below based on the reference font Helvetica or Arial.
+• **Lc 90** - Preferred level for fluent text and columns of body text with a font no smaller than 14px/weight 400 (normal).
+• **Lc 75** - The minimum level for columns of body text with a font no smaller than 18px/400. Consider Lc 75 as a minimum for text where readability is important.
+• **Lc 60** - The minimum level recommended for content text that is not body, column, or block text. In other words, text you want people to read. The minimums: 24px normal weight (400) or 16px/700 (bold).
+• **Lc 45** - The minimum for larger, heavier text (36px normal weight or 24px bold) such as headlines. This is also the minimum for pictograms with fine details.
+• **Lc 30** - The absolute minimum for any text not listed above. This includes placeholder text and disabled element text. This is also the minimum for large/solid semantic & understandable non-text elements.
+• **Lc 15** - The absolute minimum for any non-text that needs to be discernible and differentiable, and is no less than 5px in its smallest dimension. This may include disabled large buttons. Designers should treat anything below this level as invisible. Less than Lc15 will not be visible for many users. Avoid less than Lc30 for anything important for the use, understanding, or interaction of the site. [View Highlight](https://read.readwise.io/read/01j80qwns8z71advxzqxtd91x8))
+
+The demonstrator tool provides real-time updates of minimum font size & weight vs ***Lc*** lightness-contrast. [**apcacontrast.com**](https://apcacontrast.com/) The tool has several ways to enter a color. Click on the color patches to bring up a color-picker, enter a hex value or an RGB value, or use the sliders. The text color supports alpha. A negative ***Lc*** value, such as ***Lc -60*** means the text is lighter than the background. A positive value ***Lc 60*** means the text is darker than the background (light mode). [View Highlight](https://read.readwise.io/read/01j80r1cmq4sx7cfxpy38ntfek))
+
+• **Spatial or spatially:** relating to size, weight, or thickness.
+• **Hue:** the uniqueness of a given color vs other colors, i.e. blue vs red.
+• **Chroma/saturation:** the intensity or purity of a color vs no color.
+• **Luminance:** a physical measure of light, disregarding hue.
+• **Lightness:** the human perception of a given luminance. Also darkness and brightness. [View Highlight](https://read.readwise.io/read/01j80r1p31g0yk305pv0zjq7zz))
+
+
+```
+
+Here is an example that shows an image of two (2) dogs:
+
+
+
+Image of two dogs
+
+And here's an example of an image that illustrates the use of alt text:
+
+
+
+Image of dog with alt text displayed
+
+==You should also describe your icon buttons.==
+
+Icons can be easily understood most of the time. It's widely recognized that an x symbol, like this ❌, typically closes a window, a check mark ✅ signifies completion, a forward arrow ▶ signifies send (or play), and a plus sign ➕ represents addition.
+
+But this is clear only for individuals with visual capabilities. For people who aren't able to see the buttons, you'll need to provide a description so they know what that button does.
+
+Let's take a look at this HTML and CSS code that shows how to make buttons access:
+
+Document
+
+Here's the result of the code implemented above:
+
+
+
+### Is it Operable?
+
+Users should be able to navigate and interact with the interface quickly. Consider the following factors:
+
+==First, make sure you use clear and consistent headings.==
+
+This is what clear and consistent headings look like:
+
+## I am a Title
+
+## I am a Subtitle
+
+### This is heading 3
+
+#### This is Heading 4
+
+##### This is Heading 5
+
+###### This is heading 6
+
+As you can see, these headings go from largest to smallest in order. We have an H1 heading first, followed by H2, H3, and so on.
+
+Here are some headings that don't follow the proper hierarchy:
+
+###### This is heading 6
+
+##### This is Heading 5
+
+#### This is Heading 4
+
+### This is heading 3
+
+## I am a Subtitle
+
+## I am a Title
+
+In this example, the headings go in reverse order, starting from H6 and moving up through H5, H4, and so on.
+
+Just remember to use proper heading hierarchy – don't use an H2 and then jump straight to H4 for a subheading, for example, as this is visually jarring and doesn't convey the proper importance or hierarchy of the text.
+
+Here's why heading hierarchy is important:
+
+* A clear heading hierarchy helps readers easily navigate and understand the content of a document.
+* Heading hierarchy is crucial for accessibility, as it helps screen readers and assistive technologies interpret the structure of the content. This is important for individuals with visual impairments who rely on such tools to access information.
+* A well-organized heading hierarchy implement a logical flow of information, ensuring that topics are presented in a coherent order.
+
+Also, refrain from using elements that might trigger physical discomfort, like bright flashing lights.
+
+==And make sure you think about== ==[keyboard accessibility](https://www.freecodecamp.org/news/designing-keyboard-accessibility-for-complex-react-experiences/)== ==so users can navigate and communicate using the keyboard, and not exclusively using a mouse.==
+
+### Is it Understandable?
+
+Content and functionality should be presented clearly and understandably. Consider the following factors:
+
+* ==Organize content using headings, subheadings, and bullet points to enhance readability.==
+* Provide instructions and error messages that are easy to understand.
+* Use simple and concise language, avoid complex terms.
+
+### Is it Robust?
+
+Websites should be built using robust and widely supported technologies to enable compatibility across devices and assistive technologies.
+
+You'll want to maximize compatibility with current and future user agents, including assistive technologies.
+
+Here are some of the ways you can maximize compatibility with current and future agents, including assistive tools:
+
+* ==Use== ==[HTML5 semantic elements](https://www.freecodecamp.org/news/semantic-html-alternatives-to-using-divs/)== ==like== `==<====header====>==`==,== `==<====nav====>==`==,== `==<====main====>==`==, and== `==<====footer====>==` ==to enhance the document's structure.==
+* ==Ensure that your== ==[JavaScript code is efficient](https://www.freecodecamp.org/news/javascript-performance-async-defer/)== ==and doesn't block the rendering process.==
+* ==Utilize== ==[browser developer tools](https://www.freecodecamp.org/news/learn-how-to-use-the-chrome-devtools-to-troubleshoot-websites/)== ==and online testing services to identify and fix compatibility issues.==
+* ==Conduct== ==[usability testing](https://www.freecodecamp.org/news/10-best-ux-testing-software-tools/)== ==with a diverse group of users, including those who rely on assistive technologies, to gather feedback and make improvements.==
+* ==Optimize your website for fast loading times and low data usage using techniques like== ==[caching](https://www.freecodecamp.org/news/a-detailed-guide-to-pre-caching/)== ==and== ==[tools like CDNs](https://www.freecodecamp.org/news/cdns-speed-up-performance-by-reducing-latency/)== ==to reduce latency. This benefits both accessibility and user experience.==
+* ==Document your code and accessibility features for future maintainers.==
+* ==Test== ==[website compatibility across various browsers](https://www.freecodecamp.org/news/cross-browser-compatibility-testing-best-practices-for-web-developers/)====. Testing website compatibility involves ensuring that your website functions correctly and looks good on a variety of devices, browsers, and assistive technologies.==
+
+Here are the steps you can follow to test website compatibility effectively:
+
+1. **Device Testing**: Test your website on various devices, such as desktop computers, laptops, tablets, and smartphones. This includes both iOS and Android devices.
+2. **Browser Testing**: Check your website's performance and appearance on multiple browsers, including but not limited to Google Chrome, Mozilla Firefox, Apple Safari, and Microsoft Edge.
+3. **User Testing**: Conduct usability testing with real users. Ask them to use your website on different devices and browsers and collect feedback on compatibility issues.
+4. **Performance Testing**: Assess website loading times, and optimize for speed using tools like Google PageSpeed Insights, GTmetrix, or Lighthouse. Check for compatibility with slow internet connections.
+
+## Conclusion
+
+Understanding web accessibility can enhance the user experience by creating a smooth and seamless interaction with websites and web applications.
+
+Implementing these tips can improve the overall user-friendliness and navigability of your app. It'll help create a more enjoyable experience for all users, and will also allow people with disabilities to perceive, understand, navigate, and interact with your sites effectively.
+
+---
+
+---
+
+ 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/)
\ No newline at end of file
diff --git a/Omnivore/2023-11-04 - Git Merge vs Rebase vs Squash ¿Qué estrategia debemos elegir-.md b/Omnivore/2023-11-04 - Git Merge vs Rebase vs Squash ¿Qué estrategia debemos elegir-.md
new file mode 100644
index 0000000..d8de707
--- /dev/null
+++ b/Omnivore/2023-11-04 - Git Merge vs Rebase vs Squash ¿Qué estrategia debemos elegir-.md
@@ -0,0 +1,27 @@
+---
+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
+- 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)
\ No newline at end of file
diff --git a/Omnivore/2023-11-06 - How to Write Components that Work in Any Framework.md b/Omnivore/2023-11-06 - How to Write Components that Work in Any Framework.md
new file mode 100644
index 0000000..628e953
--- /dev/null
+++ b/Omnivore/2023-11-06 - How to Write Components that Work in Any Framework.md
@@ -0,0 +1,402 @@
+---
+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
+
+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)
+
+---
+
+### 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)
+
+---
+
+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)
+
+---
+
+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
+
+
+
+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
+
+Here’s how you’d use the progress element in your project:
+
+```xml
+
+
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+