
Having recently delved into the world of Economics, a subject previously
unexplored in my academic journey as a Computer Science major, I find myself
reflecting on the valuable lessons learned - particularly in the realm of
decision-making, and the profound impact of one economic concept that stands
out – the Sunk Cost Fallacy.

In the grand scheme of life, decisions are omnipresent, and their consequences
shape our journey. Whether it's choosing a career path, investing time in a
project, or even deciding what to have for dinner, our choices carry
significance. Understanding the Sunk Cost Fallacy has opened my eyes to a
subtle yet powerful cognitive bias that often influences our decision-making
process.

The Sunk Cost Fallacy revolves around the idea that we tend to cling onto
investments, be it time, money, or effort, merely because we've already
invested in them. This fallacy clouds our judgment and makes us reluctant to
let go, even when the rational choice might be to cut our losses and move on.

> Recognizing when to abandon a failing project is a skill that transcends
> disciplines.

The application of the Sunk Cost Fallacy in the broader context of life is
profound. From relationships to career choices, we often find ourselves
entangled in situations where we're hesitant to let go due to what we've
already invested. Understanding that past investments should not dictate future
decisions is a liberating revelation.

One key takeaway from the Sunk Cost Fallacy is the importance of being
forward-thinking. Instead of dwelling on what we've already invested, it's
better to focus on the potential gains and losses moving forward. This shift in
perspective empowers us to make decisions based on the current situation rather
than being tethered to past investments.

Another crucial aspect is detachment. Learning to detach emotionally
from our investments allows for more rational decision-making. This detachment
doesn't imply apathy but rather a strategic approach to evaluating choices
without being clouded by emotional attachment to past efforts.

In a world that constantly demands adaptation and resilience, embracing the
wisdom embedded in the Sunk Cost Fallacy can be a game-changer. It encourages
us to be pragmatic, to reassess our decisions without the burden of past
investments, and to navigate life's myriad choices with a clear and discerning
mind.

In exploring the intersection of technology and economics, a profound
appreciation has emerged for concepts like the Sunk Cost Fallacy. Beyond the
intricacies of code and economic theories, what surfaces is a deeper
understanding of human behavior and decision-making. This knowledge, far from
confined to any specific discipline, holds universal relevance. It becomes a
guiding light through the complexities of life's choices, urging us to navigate
with clarity. Embracing the lessons of the Sunk Cost Fallacy allows us to
journey through life's intricacies with a discerning mind, unburdened by the
weight of past investments, and empowered to make choices that align with our
present and future aspirations.


Navigating Life's Choices


Useful Unix and (Git) commands. Updated often.

- Git reset one file to head

```bash
git checkout HEAD -- my-file.txt
```

- Append to file with echo

```bash
echo "old_files/" >> .gitignore
```

- Checking differences after copying

```bash
diff -rq --no-dereference /path/to/old/drive/ /path/to/new/drive/
```

- Delete All Node Modules in a big folder with multiple sub dirs and node modules

```bash
find . -type d -name node_modules -prune
find . -type d -name node_modules -prune -exec rm -rf {} \;
```

- Summary of new/missing files, and which files differ:

```bash
diff -arq folder1 folder2 --exclude=node_modules
```

- Ignore node_modules folder everywhere

```bash
echo "node_modules/" >> .gitignore && git rm -r --cached node_modules ; git status
```

- Recursively find and delete files with "text" in their names:

```bash
find -type f -name '*text*' -delete
```


Useful Unix Commands


The command line interface, with its powerful shell environments like Bash and
Zsh, allows you to interact with your computer using text-based commands. On
opening up your terminal, you’ll see a prompt where you can start typing
commands. Assuming your default shell is either Bash or Zsh, this tutorial
should work just fine.

> This guide is not intended to be an exhaustive resource on
> shell configuration or advanced command usage. Instead, we will focus on
> laying a basic foundation that will enable you to navigate the command line
> and get started.

### What is Bash?

Bash, short for "**B**ourne **A**gain **SH**ell," is a popular command-line
shell and scripting language used in Unix-based systems like Linux and macOS. It
provides a text-based interface for interacting with the operating system and
executing various commands.

### What is Zsh?

Zsh, short for "Z Shell," is another powerful command-line shell available as an
alternative to Bash. It offers additional features and customization options,
making it a popular choice for many users.

### Getting Started with Bash or Zsh

To begin, open your terminal. You can find it in your applications or use a
keyboard shortcut like `Ctrl + Alt + T` on most Linux distributions. On macOS,
you can find it in the "Utilities" folder within the "Applications" directory.

Once the terminal is open, you will see a prompt where you can start entering
commands. This is where it all begins!

![Homer GIF](/homer.gif)

### Basic Commands

Let’s start with some basic commands that you can try out in your terminal:

- `pwd` (Print Working Directory): This command displays the current directory
  you are in. For example, if you are in the home directory, running `pwd` will
  output `/home/username`.

- `ls` (List): Use this command to list the files and directories in the current
  directory. For example, running `ls` will display a list of files and
  directories in the current directory.

- `cd` (Change Directory): This command allows you to navigate to a different
  directory. For example, running `cd Documents` will change your current
  directory to the "Documents" directory.

- `mkdir` (Make Directory): Use this command to create a new directory. For
  example, running `mkdir myfolder` will create a new directory named "myfolder"
  in the current directory.

- `touch` (Create File): This command creates a new file. For example, running
  `touch myfile.txt` will create a new empty file named "myfile.txt" in the
  current directory.

Remember to press `Enter` after typing each command to execute it.

### Command Options and Arguments

Commands often come with options and arguments that modify their behavior.
Options are typically specified using a hyphen followed by a letter or word,
such as `-l` or `--help`. Arguments are additional information provided to a
command, such as a file or directory name.

For example:

- `ls -l`: Lists files in the long format. Here `-l` is the option being
  specified. Running `ls -l` will display detailed information about each file
  in the current directory, including permissions, owner, size, and modification
  date.

- `mkdir myfolder`: Creates a directory named "myfolder". Here `myfolder`
  is the argument. Running this command will create a new directory named
  "myfolder" in the current directory.

### Command History

Bash and Zsh keep track of the commands you’ve previously entered, allowing you
to access them easily. You can use the up and down arrow keys to navigate
through your command history. Press `Enter` to execute a previously entered
command.

### Tab Completion

Tab completion is a helpful feature that saves you from typing out long file or
directory names. When you start typing, press the `Tab` key, and the shell will
try to auto-complete the rest of the name for you. If there are multiple
possibilities, pressing `Tab` twice will show you the available options.

For better tab completions, auto-complete, and syntax highlighting you can
configure your `.zshrc` file. I have a [github
repository](https://github.com/achntj/dotfiles/tree/master/zsh) with sensible
defaults (in my opinion) and all the necessary configuration for a better
experience.

If you want to use a package instead you can look into ‘Oh My Zsh’.

### Scripting with Bash or Zsh

Bash and Zsh can also be used as scripting languages, allowing you to automate
tasks and create more complex programs. Shell scripts are plain text files with
a series of commands that can be executed together.

To create a script, open a text editor and save the file with a `.sh` extension
(e.g., `myscript.sh`). Make the file executable by running the command `chmod +x
myscript.sh`. Now, you can run the script by typing `./myscript.sh` in the
terminal.

### More

Here are some articles that I found useful when I started out with bash:

- [The Missing Semester of Your CS Education](https://missing.csail.mit.edu/2020/shell-tools/)

- [The ZSH docs (formatted by me)](https://zshguide.vercel.app/)

- [Parabola GNU/Linux Libre](https://wiki.parabola.nu/Zsh)

- [Moving Away From Oh-My-Zsh](https://ianyepan.github.io/posts/moving-away-from-ohmyzsh/)

### Final Thoughts

While there is much more to learn about Bash and Zsh, this guide should provide
you with a solid foundation to start exploring and using the command line
effectively. As you gain more experience, you can delve into advanced topics and
configurations to enhance your command-line experience even further.

_Note: The commands and examples provided in this article are primarily targeted
at Unix-based systems like Linux and macOS. Some commands or options may differ
on other operating systems._


Get Started with shell scripting in Bash & Zsh.

A beginner’s guide to Bash & Zsh


One issue that is of particular concern today is the widening skills gap and
economic inequality caused by the increasing use of AI and automation
technologies. As we continue to develop and deploy these technologies, it is
becoming clear that they have the potential to displace low-skill workers while
creating new opportunities in high-skill areas. In the midst of this, inadequate
labor representation continues to be a rising concern. The current system in
place doesn’t let the people affected have a voice in this issue. All of this,
in turn, can lead to a widening of the skills gap and increased economic
inequality.

The problem here is larger than one would think. The impact of increasing use of
AI and automation technologies on the job market has significant social and
economic implications. The potential displacement of low-skill jobs can result
in significant consequences for individuals, families, and communities,
particularly those who may already be vulnerable or marginalized. The creation
of new job opportunities in high-skill areas may require workers to acquire
additional education and training, which may be difficult or inaccessible for
some workers. Furthermore, the widening skills gap and economic inequality
resulting from this issue can have broader societal implications ultimately
leading to societal unrest.

Large sections of people are involved in this. The stakeholders in this issue
include these workers who may be affected by the displacement of low-skill jobs
and the need to acquire new skills, as well as employers who may benefit from
the use of AI and automation technologies. At stake are the livelihoods and
economic security of workers who may be affected by the displacement of
low-skill jobs and the need to acquire new skills for high-skill jobs.
Additionally, the ability of communities to adapt to the changing job market and
provide support for affected workers is at stake. The long-term health and
stability of the economy is also a stake, as the displacement of low-skill jobs
and the widening skills gap can have negative impacts on productivity,
innovation, and overall economic growth.

More recently, even some high-skill areas are beginning to notice the effect of
AI being able to do what experienced specialists have done for many years. This
can, in turn, lead to displacement of some high-skilled jobs too. On the other
hand, the development and deployment of AI and automation technologies require
workers with specialized skills in areas such as computer science, engineering,
and data analysis, thus creating new job opportunities in these high skill areas
while leaving behind workers who do not possess these skills. Additionally, the
automation of tasks that are repetitive and predictable, which are often found
in low-skill jobs such as data entry, can displace workers and contribute to
unemployment and underemployment. The effects of this issue are far-reaching and
significant. On an individual level, workers who are displaced by automation may
face financial insecurity and struggle to find new employment opportunities that
provide a similar level of income and stability. This can lead to increased
stress and anxiety, as well as potential health issues (Ananat et al., 2017)[^1].
On a societal level, the widening skills gap and economic inequality
can lead to a lack of social mobility and decreased opportunities for those who
are left behind. Without the labor representation in place, the disparity would
continue to increase without the workers ever getting a chance to upskill.

The significance of this argument is to improve the general understanding of the
potential consequences of this trend. It is, therefore, important to understand
the scale of this problem first. A study by Frey and Osborne (2017)[^2] examined
the potential impact of automation on the US job market and found that up to 47%
of jobs may be at risk of being automated in the coming decades. The authors
note that this trend is likely to affect workers across a wide range of
industries and skill levels, and may require significant policy interventions to
mitigate the potential negative consequences. By highlighting the causal
relationship between the increasing use of AI and automation technologies and
the displacement of low-skill jobs and economic inequality, we can better
understand the potential social and economic implications of this issue. This
can inform policy decisions, guide educational and workforce development
initiatives, and support affected workers in adapting to the changing job
market.

Research has highlighted the potential consequences of automation and AI for the
job market and broader society. For example, a study by Acemoglu and Restrepo
(2019)[^3] found that the increasing use of robots in manufacturing and related
industries has led to significant job displacement and wage stagnation,
particularly for workers with lower levels of education. The authors argue that
this trend may contribute to a widening gap in income and wealth inequality.

Furthermore, the increasing use of AI and automation technologies may have
differential impacts on various demographic groups, exacerbating existing social
and economic disparities. For instance, research has shown that marginalized
communities, including minority groups and individuals with low educational
attainment, may be disproportionately affected by the displacement of low-skill
jobs. Ananat et al. (2017)[^1] highlighted that job loss resulting from
automation can contribute to widening inequality, as those who are already
economically disadvantaged may face increased challenges in finding alternative
employment opportunities. This can further widen disparities in wealth, income,
and access to education, thus perpetuating cycles of poverty and social
inequality.

Moreover, the potential consequences of AI and automation on the job market may
also have implications for mental health and well-being. As individuals face job
displacement or uncertainty, without having a say in the situation, the stress
and anxiety associated with economic insecurity can impact their mental health,
leading to increased rates of depression, anxiety, and other mental health
disorders. This can have long-term consequences not only for individuals but
also for their families, communities, and the broader society.

Better labor representation is crucial in addressing the potential consequences
of this trend. Workers and their representatives must be included in the
conversation around AI and automation to ensure that their voices are heard and
their rights protected. This can help to lower the negative consequences of
automation, such as job displacement, and ensure that the benefits of
technological progress are shared more equitably. Better representation would
ultimately lead to development of upskilling programs for assisting workers in
transitioning careers. It is also important to focus on the perspective of
younger generations who will be most affected by the impact of AI and automation
on the job market. This includes understanding the changing nature of work, the
skills needed to succeed in the new economy, and the potential social and
economic implications of these trends for younger workers.

The causal argument regarding the impact of AI and automation on the job market
is significant because it provides the consequences of this trend and highlights
the need for policy interventions to support affected workers and communities.
In conclusion, the widening skills gap and economic inequality caused by the
increasing use of AI and automation technologies is an issue that deserves
attention from stakeholders across various fields. Better labor representation
and the development of suitable training programs is also necessary. By
understanding the causes and effects of this issue, we can work to develop
strategies to promote social mobility and ensure that the benefits of these
technologies are shared more equitably across society. Finally, more research is
needed to predict how economic inequality is going to set in as a result of the
impact of AI and automation on the job market. This includes examining the
potential impact of automation on different industries and occupations, as well
as considering the broader social and economic implications of these trends.

[^1]:
    Ananat, E. O., Gassman-Pines, A., Francis, D. V., & Gibson-Davis, C. M.
    (2017). Linking job loss, inequality, mental health, and education. Science,
    356(6343), 1127-1128.
    [^2]: Frey, C. B., & Osborne, M. A. (2017). The future of employment: How
    susceptible are jobs to computerisation?. Technological forecasting and
    social change, 114, 254-280.
    [^3]: Acemoglu, D., & Restrepo, P. (2019). Automation and new tasks: How
    technology displaces and reinstates labor. Journal of Economic Perspectives,
    33(2), 3-30.


Addressing AI's role in the widening skills gap and the need for labor representation to ensure a equitable future  of work.

AI, Automation, & the Economy


> Contentlayer is a content SDK that validates and transforms your content into type-safe JSON data you can easily import into your application.

[~ Contentlayer](https://www.contentlayer.dev/)

So that's what Contentlayer is. It gives you type safety for your data, and makes the data available across the application.

To get started with Contentlayer, you can follow this guide. It is a minimal Next.js & Contentlayer starter that comes configured with MDX support, code highlighting, and Tailwind CSS. Here's a [demo web-app](https://contentlayer-starter.vercel.app/) built with it.

## Getting Started

Clone this repository and install all dependencies

```bash
git clone https://github.com/achntj/contentlayer-next-mdx-starter/ my-blog
npm i
```

That's it! To create new posts, head over to the `content/blog` folder and create new MDX files. The name of the file is used for generating the slug while the frontmatter is used for adding the date, title, and description.

## Using custom components

To use your own components in your MDX files, import them to the pages/blog/[slug].tsx page, and add them to the `MDXcomponents` variable. To give custom name aliases to these components use the following syntax -

```js
import Image from "next/image";

const MDXcomponents = {
  // Pass Custom Components here (for use in markdown files)
  img: Image,
};
```

See more in the [Contentlayer docs](https://www.contentlayer.dev/docs/reference/next-contentlayer#usemdxcomponent)

## Custom Page Types

To create other page types, define them in the contentlayer.config.ts file, just like it is done for the `Post` type. Create a corresponding index and slug page for the type in the `pages` directory to be able to view it.

That's all! Check out the [github repo](https://github.com/achntj/contentlayer-next-mdx-starter/) for this starter, and give it a star if you like it. And don't forget to check out [Contentlayer](https://www.contentlayer.dev/)!


Get started with Contentlayer to create your Next.js and MDX blog.

Using Contentlayer with Next.js and MDX


### Step 1: Find your ~/.idlerc folder

Based on what I found on StackOverflow, it's pretty easy to find it on your
home directory. Finding it on Mac is a bit different(That's what I will talk
about next).

Open the terminal in your root directory then type-

```shell
$ cd ~/.idlerc
$ touch config-highlight.cfg
$ open .
```

### Step 2: Edit the _config-highlight.cfg_ file

This will open the ~/.idlerc folder with the custom theme config file. Now open
this file from finder or use

```bash
$ open -a TextEdit config-highlight.cfg
```

### Step 3: Update the theme on IDLE

Now paste the theme code snippet into this file and save it. It's simpler from
here on. Open IDLE Preferences, go to highlights, and choose the custom theme.


Writing

2024

Navigating Life's Choices

2023

Useful Unix Commands

A beginner’s guide to Bash & Zsh

AI, Automation, & the Economy

2022

Using Contentlayer with Next.js and MDX

2021

Using a custom theme with IDLE