Bolu must see

I was on YouTube earlier today wasting time looking for a worthwhile video to waste time on (as a normal human being does) and the thumbnail of a particular video caught my attention. It read "is it better to not have been born, given all the suffering of life?"

That's not a particularly new question and if I was asked by friends or family, I'd probably say no - we were all born for a reason etcetera. But I gave it some more thought through the day. And the conclusion I came to is that the question is not a productive question. It may be good as an intellectual exercise, but when contemplating the struggles of life, that's a useless question.

Is it better to not have been born? Hmmnn, good question. I can't help but notice that you were born years ago though. So we are past that. You are in the game already. This is not to say that life is easy. There are legitimate issues that arise in life that wreck us. Loved ones die, heartbreaks happen, disappointments occur, we disappoint ourselves. Then we begin to question our very existence. I think that is a valid response to life issues, but you have to get up. We are all bound to take L's at some points in our lives, it's inevitable. But we must get up and go on.

Because what else are you going to do? That's a question to ask yourself. What else are you going to do?

I was thinking about the blog and what I'll be writing. I honestly don't know. I just thought I'll give my friends some words of encouragement (oh I'm also testing the writing experience of our website :). I'm sure you guys would not mind that.

Elder, Anyankus Zubi, Nombuwa, Glory, and our very own entrepreneur, Samuel, I am grateful for you guys. I wish you all the best in your short-term endeavors especially school exams and other exams. To perseveranc, grit, and tenacity until the very end.

You are in the game of life already. Now, there are two choices - play your 100% and see your full potential or be mediocre and see your days waste.

To Perseverance, Grit, and Tenacity until the End

This is not my article. I just got this from https://github.com/ai/size-limit/blob/main/README.md to test my markdown parser. So yeah this is the documentation of a tech tool.

<img src="https://ai.github.io/size-limit/logo.svg" align="right"
 alt="Size Limit logo by Anton Lovchikov" width="120" height="178">

Size Limit is a performance budget tool for JavaScript. It checks every commit on CI, calculates the real cost of your JS for end-users and throws an error if the cost exceeds the limit.

* **ES modules** and **tree-shaking** support.
* Add Size Limit to **Travis CI**, **Circle CI**, **GitHub Actions**
 or another CI system to know if a pull request adds a massive dependency.
* **Modular** to fit different use cases: big JS applications
 that use their own bundler or small npm libraries with many files.
* Can calculate **the time** it would take a browser
 to download and **execute** your JS. Time is a much more accurate
 and understandable metric compared to the size in bytes.
* Calculations include **all dependencies and polyfills**
 used in your JS.


 <img src="https://github.com/ai/size-limit/raw/main/img/example.png" alt="Size Limit CLI" width="738">


With **[GitHub action]** Size Limit will post bundle size changes as a comment in pull request discussion.


<img src="https://raw.githubusercontent.com/andresz1/size-limit-action/master/assets/pr.png"
 alt="Size Limit comment in pull request about bundle size changes"
 width="686" height="289">


With `--why`, Size Limit can tell you *why* your library is of this size
and show the real cost of all your internal dependencies.
We are using [Statoscope] for this analysis.


 <img src="https://github.com/ai/size-limit/raw/main/img/why.png" alt="Statoscope example" width="650">



 <a href="https://evilmartians.com/?utm_source=size-limit">
 <img src="https://evilmartians.com/badges/sponsored-by-evil-martians.svg"
 alt="Sponsored by Evil Martians" width="236" height="54">
 </a>


[GitHub action]: https://github.com/andresz1/size-limit-action
[Statoscope]: https://github.com/statoscope/statoscope
[cult-img]: http://cultofmartians.com/assets/badges/badge.svg
[cult]: http://cultofmartians.com/tasks/size-limit-config.html

## Who Uses Size Limit

* [MobX](https://github.com/mobxjs/mobx)
* [Material-UI](https://github.com/callemall/material-ui)
* [Autoprefixer](https://github.com/postcss/autoprefixer)
* [PostCSS](https://github.com/postcss/postcss) reduced
 [25% of the size](https://github.com/postcss/postcss/commit/150edaa42f6d7ede73d8c72be9909f0a0f87a70f).
* [Browserslist](https://github.com/browserslist/browserslist) reduced
 [25% of the size](https://github.com/browserslist/browserslist/commit/640b62fa83a20897cae75298a9f2715642531623).
* [EmojiMart](https://github.com/missive/emoji-mart) reduced
 [20% of the size](https://github.com/missive/emoji-mart/pull/111)
* [nanoid](https://github.com/ai/nanoid) reduced
 [33% of the size](https://github.com/ai/nanoid/commit/036612e7d6cc5760313a8850a2751a5e95184eab).
* [React Focus Lock](https://github.com/theKashey/react-focus-lock) reduced
 [32% of the size](https://github.com/theKashey/react-focus-lock/pull/48).
* [Logux](https://github.com/logux) reduced
 [90% of the size](https://github.com/logux/logux-client/commit/62b258e20e1818b23ae39b9c4cd49e2495781e91).


## How It Works

1. Size Limit contains a CLI tool, 3 plugins (`file`, `webpack`, `time`)
 and 3 plugin presets for popular use cases (`app`, `big-lib`, `small-lib`).
 A CLI tool finds plugins in `package.json` and loads the config.
2. If you use the `webpack` plugin, Size Limit will bundle your JS files into
 a single file. It is important to track dependencies and webpack polyfills.
 It is also useful for small libraries with many small files and without
 a bundler.
3. The `webpack` plugin creates an empty webpack project, adds your library
 and looks for the bundle size difference.
4. The `time` plugin compares the current machine performance with that of
 a low-priced Android devices to calculate the CPU throttling rate.
5. Then the `time` plugin runs headless Chrome (or desktop Chrome if it’s
 available) to track the time a browser takes to compile and execute your JS.
 Note that these measurements depend on available resources and might
 be unstable. [See here](https://github.com/mbalabash/estimo/issues/5)
 for more details.


## Usage

### JS Applications

Suitable for applications that have their own bundler and send the JS bundle
directly to a client (without publishing it to npm). Think of a user-facing app
or website, like an email client, a CRM, a landing page or a blog with
interactive elements, using React/Vue/Svelte lib or vanilla JS.

<details><summary>Show instructions</summary>

1. Install the preset:

 ```sh
 npm install --save-dev size-limit @size-limit/file
 ```

2. Add the `size-limit` section and the `size` script to your `package.json`:

 ```diff
 + "size-limit": [
 + {
 + "path": "dist/app-*.js"
 + }
 + ],
 "scripts": {
 "build": "webpack ./webpack.config.js",
 + "size": "npm run build && size-limit",
 "test": "jest && eslint ."
 }
 ```

3. Here’s how you can get the size for your current project:

 ```sh
 $ npm run size

 Package size: 30.08 kB with all dependencies, minified and gzipped
 ```

4. Now, let’s set the limit. Add 25% to the current total size and use that as
 the limit in your `package.json`:

 ```diff
 "size-limit": [
 {
 + "limit": "35 kB",
 "path": "dist/app-*.js"
 }
 ],
 ```

5. Add the `size` script to your test suite:

 ```diff
 "scripts": {
 "build": "webpack ./webpack.config.js",
 "size": "npm run build && size-limit",
 - "test": "jest && eslint ."
 + "test": "jest && eslint . && npm run size"
 }
 ```

6. If you don’t have a continuous integration service running, don’t forget
 to add one — start with [Travis CI].

</details>


### JS Application and Time-based Limit

File size limit (in kB) is not the best way to describe your JS application
cost for developers. Developers will compare the size of the JS bundle
with the size of images. But browsers need much more time to parse 100 kB
of JS than 100 kB of an image since JS compilers are very complex.

This is why Size Limit support time-based limit. It runs headless Chrome
to track the time a browser takes to compile and execute your JS.

<details><summary>Show instructions</summary>

1. Install the preset:

 ```sh
 npm install --save-dev size-limit @size-limit/preset-app
 ```

2. Add the `size-limit` section and the `size` script to your `package.json`:

 ```diff
 + "size-limit": [
 + {
 + "path": "dist/app-*.js"
 + }
 + ],
 "scripts": {
 "build": "webpack ./webpack.config.js",
 + "size": "npm run build && size-limit",
 "test": "jest && eslint ."
 }
 ```

3. Here’s how you can get the size for your current project:

 ```sh
 $ npm run size

 Package size: 30.08 kB with all dependencies, minified and gzipped
 Loading time: 602 ms on slow 3G
 Running time: 214 ms on Snapdragon 410
 Total time: 815 ms
 ```

4. Now, let’s set the limit. Add 25% to the current total time and use that as
 the limit in your `package.json`:

 ```diff
 "size-limit": [
 {
 + "limit": "1 s",
 "path": "dist/app-*.js"
 }
 ],
 ```

5. Add the `size` script to your test suite:

 ```diff
 "scripts": {
 "build": "webpack ./webpack.config.js",
 "size": "npm run build && size-limit",
 - "test": "jest && eslint ."
 + "test": "jest && eslint . && npm run size"
 }
 ```

6. If you don’t have a continuous integration service running, don’t forget
 to add one — start with [Travis CI].

</details>


### Big Libraries

JS libraries > 10 kB in size.

This preset includes headless Chrome, and will measure your lib’s execution
time. You likely don’t need this overhead for a small 2 kB lib, but for larger
ones the execution time is a more accurate and understandable metric that
the size in bytes. Libraries like [React] are good examples for this preset.

<details><summary>Show instructions</summary>

1. Install preset:

 ```sh
 npm install --save-dev size-limit @size-limit/preset-big-lib
 ```

2. Add the `size-limit` section and the `size` script to your `package.json`:

 ```diff
 + "size-limit": [
 + {
 + "path": "dist/react.production-*.js"
 + }
 + ],
 "scripts": {
 "build": "webpack ./scripts/rollup/build.js",
 + "size": "npm run build && size-limit",
 "test": "jest && eslint ."
 }
 ```

3. If you use ES modules you can test the size after tree-shaking with `import`
 option:

 ```diff
 "size-limit": [
 {
 "path": "dist/react.production-*.js",
 + "import": "{ createComponent }"
 }
 ],
 ```

4. Here’s how you can get the size for your current project:

 ```sh
 $ npm run size

 Package size: 30.08 kB with all dependencies, minified and gzipped
 Loading time: 602 ms on slow 3G
 Running time: 214 ms on Snapdragon 410
 Total time: 815 ms
 ```

5. Now, let’s set the limit. Add 25% to the current total time and use that
 as the limit in your `package.json`:

 ```diff
 "size-limit": [
 {
 + "limit": "1 s",
 "path": "dist/react.production-*.js"
 }
 ],
 ```

6. Add a `size` script to your test suite:

 ```diff
 "scripts": {
 "build": "rollup ./scripts/rollup/build.js",
 "size": "npm run build && size-limit",
 - "test": "jest && eslint ."
 + "test": "jest && eslint . && npm run size"
 }
 ```

7. If you don’t have a continuous integration service running, don’t forget
 to add one — start with [Travis CI].
8. Add the library size to docs, it will help users to choose your project:

 ```diff
 # Project Name

 Short project description

 * **Fast.** 10% faster than competitor.
 + * **Small.** 15 kB (minified and gzipped).
 + [Size Limit](https://github.com/ai/size-limit) controls the size.
 ```

</details>


### Small Libraries

JS libraries < 10 kB in size.

This preset will only measure the size, without the execution time, so it’s
suitable for small libraries. If your library is larger, you likely want
the Big Libraries preset above. [Nano ID] or [Storeon] are good examples
for this preset.

<details><summary>Show instructions</summary>

1. First, install `size-limit`:

 ```sh
 npm install --save-dev size-limit @size-limit/preset-small-lib
 ```

2. Add the `size-limit` section and the `size` script to your `package.json`:

 ```diff
 + "size-limit": [
 + {
 + "path": "index.js"
 + }
 + ],
 "scripts": {
 + "size": "size-limit",
 "test": "jest && eslint ."
 }
 ```

3. Here’s how you can get the size for your current project:

 ```sh
 $ npm run size

 Package size: 177 B with all dependencies, minified and gzipped
 ```

4. If your project size starts to look bloated, run `--why` for analysis:

 ```sh
 npm run size -- --why
 ```

 > We use [Statoscope](https://github.com/statoscope/statoscope) as bundle analyzer.

5. Now, let’s set the limit. Determine the current size of your library,
 add just a little bit (a kilobyte, maybe) and use that as the limit
 in your `package.json`:

 ```diff
 "size-limit": [
 {
 + "limit": "9 kB",
 "path": "index.js"
 }
 ],
 ```

6. Add the `size` script to your test suite:

 ```diff
 "scripts": {
 "size": "size-limit",
 - "test": "jest && eslint ."
 + "test": "jest && eslint . && npm run size"
 }
 ```

7. If you don’t have a continuous integration service running, don’t forget
 to add one — start with [Travis CI].
8. Add the library size to docs, it will help users to choose your project:

 ```diff
 # Project Name

 Short project description

 * **Fast.** 10% faster than competitor.
 + * **Small.** 500 bytes (minified and gzipped). No dependencies.
 + [Size Limit](https://github.com/ai/size-limit) controls the size.
 ```

</details>


[Travis CI]: https://github.com/dwyl/learn-travis
[Storeon]: https://github.com/ai/storeon/
[Nano ID]: https://github.com/ai/nanoid/
[React]: https://github.com/facebook/react/


## Reports

Size Limit has a [GitHub action] that comments and rejects pull requests based
on Size Limit output.

1. Install and configure Size Limit as shown above.
2. Add the following action inside `.github/workflows/size-limit.yml`

```yaml
name: "size"
on:
 pull_request:
 branches:
 - master
jobs:
 size:
 runs-on: ubuntu-latest
 env:
 CI_JOB_NUMBER: 1
 steps:
 - uses: actions/checkout@v1
 - uses: andresz1/size-limit-action@v1
 with:
 github_token: ${{ secrets.GITHUB_TOKEN }}
```


## Config

### Plugins and Presets

Plugins or plugin presets will be loaded automatically from `package.json`.
For example, if you want to use `@size-limit/webpack`, you can just use
`npm install --save-dev @size-limit/webpack`, or you can use our preset
`@size-limit/preset-big-lib`.

Plugins:

* `@size-limit/file` checks the size of files with Gzip, Brotli
 or without compression.
* `@size-limit/webpack` adds your library to empty webpack project
 and prepares bundle file for `file` plugin.
* `@size-limit/webpack-why` adds reports for `webpack` plugin
 about your library is of this size to show the cost of all your
 dependencies.
* `@size-limit/webpack-css` adds css support for `webpack` plugin.
* `@size-limit/esbuild` is like `webpack` plugin, but uses `esbuild`
 to be faster and use less space in `node_modules`.
* `@size-limit/esbuild-why` add reports for `esbuild` plugin
 about your library is of this size to show the cost of all your
 dependencies.
* `@size-limit/time` uses headless Chrome to track time to execute JS.
* `@size-limit/dual-publish` compiles files to ES modules with [`dual-publish`]
 to check size after tree-shaking.

Plugin presets:

* `@size-limit/preset-app` contains `file` and `time` plugins.
* `@size-limit/preset-big-lib` contains `webpack`, `file`, and `time` plugins.
* `@size-limit/preset-small-lib` contains `esbuild` and `file` plugins.

[`dual-publish`]: https://github.com/ai/dual-publish


#### Third-Party Plugins

Third-party plugins and presets named starting with `size-limit-` are also supported.
For example:

* [`size-limit-node-esbuild`](https://github.com/un-ts/size-limit/tree/main/packages/node-esbuild)
 is like `@size-limit/esbuild` but for Node libraries.
* [`size-limit-preset-node-lib`](https://github.com/un-ts/size-limit/tree/main/packages/preset-node-lib)
 is like `@size-limit/preset-small-lib` but for Node libraries which contains
 above `node-esbuild` and core `file` plugins.


### Limits Config

Size Limits supports three ways to define limits config.

1. `size-limit` section in `package.json`:

 ```json
 "size-limit": [
 {
 "path": "index.js",
 "import": "{ createStore }",
 "limit": "500 ms"
 }
 ]
 ```

2. or a separate `.size-limit.json` config file:

 ```js
 [
 {
 "path": "index.js",
 "import": "{ createStore }",
 "limit": "500 ms"
 }
 ]
 ```

3. or a more flexible `.size-limit.js` or `.size-limit.cjs` config file:

 ```js
 module.exports = [
 {
 path: "index.js",
 import: "{ createStore }",
 limit: "500 ms"
 }
 ]
 ```

Each section in the config can have these options:

* **path**: relative paths to files. The only mandatory option.
 It could be a path `"index.js"`, a [pattern] `"dist/app-*.js"`
 or an array `["index.js", "dist/app-*.js", "!dist/app-exclude.js"]`.
* **import**: partial import to test tree-shaking. It could be `"{ lib }"`
 to test `import { lib } from 'lib'`, `*` to test all exports,
 or `{ "a.js": "{ a }", "b.js": "{ b }" }` to test multiple files.
* **limit**: size or time limit for files from the `path` option. It should be
 a string with a number and unit, separated by a space.
 Format: `100 B`, `10 kB`, `500 ms`, `1 s`.
* **name**: the name of the current section. It will only be useful
 if you have multiple sections.
* **entry**: when using a custom webpack config, a webpack entry could be given.
 It could be a string or an array of strings.
 By default, the total size of all entry points will be checked.
* **webpack**: with `false` it will disable webpack.
* **running**: with `false` it will disable calculating running time.
* **gzip**: with `false` it will disable gzip compression.
* **brotli**: with `true` it will use brotli compression and disable
 gzip compression.
* **config**: a path to a custom webpack config.
* **ignore**: an array of files and dependencies to exclude from
 the project size calculation.
* **modifyWebpackConfig**: (.size-limit.js only) function that can be used
 to do last-minute changes to the webpack config, like adding a plugin.
* **compareWith**: path to `stats.json` from another build to compare
 (when `--why` is using).
* **uiReports**: custom UI reports list (see [Statoscope docs]).

If you use Size Limit to track the size of CSS files, make sure to set
`webpack: false`. Otherwise, you will get wrong numbers, because webpack
inserts `style-loader` runtime (≈2 kB) into the bundle.

[Statoscope docs]: https://github.com/statoscope/statoscope/tree/master/packages/webpack-plugin#optionsreports-report
[pattern]: https://github.com/sindresorhus/globby#globbing-patterns

## Analyze with `--why`

You can run `size-limit --why` to analyze the bundle.

You will need to install `@size-limit/esbuild-why` or `@size-limit/webpack-why`
depends on which bundler you are using (default is `esbuild`).

For `@size-limit/esbuild-why`,
it will generate a `esbuild-why.html` at the current directory.

If you also specify `--save-bundle <DIR>`,
the report will be generated inside `<DIR>`.

If you have multiple sections in your config,
the files will be named `esbuild-why-{n}.html`,
or you can give it a custom name:

```jsonc
[
 {
 "name": "cjs",
 /* snap */
 },
 {
 "name": "esm",
 /* snap */
 }
]
```

This will produce `esbuild-why-cjs.html` and `esbuild-why-esm.html` respectively.

For `@size-limit/webpack-why`,
it will generate the report and open it in the browser automatically.

## JS API

```js
const sizeLimit = require('size-limit')
const filePlugin = require('@size-limit/file')
const webpackPlugin = require('@size-limit/webpack')

sizeLimit([filePlugin, webpackPlugin], [filePath]).then(result => {
 result //=> { size: 12480 }
})
```

It is the responsibility of every craftsman to aspire towards beauty, for it is divine

Format Testing of User Interface II

Paragraphs are separated by a blank line.

2nd paragraph. *Italic*, **bold**, and `monospace`. Itemized lists
look like:

  * this one
  * that one
  * the other one

Note that --- not considering the asterisk --- the actual text
content starts at 4-columns in.

> Block quotes are
> written like so.
>
> They can span multiple paragraphs,
> if you like.

Use 3 dashes for an em-dash. Use 2 dashes for ranges (ex., "it's all
in chapters 12--14"). Three dots ... will be converted to an ellipsis.
Unicode is supported. ☺



An h2 header
------------

Here's a numbered list:

 1. first item
 2. second item
 3. third item

Note again how the actual text starts at 4 columns in (4 characters
from the left side). Here's a code sample:

    # Let me re-iterate ...
    for i in 1 .. 10 { do-something(i) }

As you probably guessed, indented 4 spaces. By the way, instead of
indenting the block, you can use delimited blocks, if you like:

~~~
define foobar() {
    print "Welcome to flavor country!";
}
~~~

(which makes copying & pasting easier). You can optionally mark the
delimited block for Pandoc to syntax highlight it:

~~~python
import time
# Quick, count to ten!
for i in range(10):
    # (but not *too* quick)
    time.sleep(0.5)
    print i
~~~



### An h3 header ###

Now a nested list:

 1. First, get these ingredients:

      * carrots
      * celery
      * lentils

 2. Boil some water.

 3. Dump everything in the pot and follow
    this algorithm:

        find wooden spoon
        uncover pot
        stir
        cover pot
        balance wooden spoon precariously on pot handle
        wait 10 minutes
        goto first step (or shut off burner when done)

    Do not bump wooden spoon or it will fall.

Notice again how text always lines up on 4-space indents (including
that last line which continues item 3 above).

Here's a link to [a website](http://foo.bar), to a [local
doc](local-doc.html), and to a [section heading in the current
doc](#an-h2-header). Here's a footnote [^1].

[^1]: Footnote text goes here.

Tables can look like this:

size  material      color
----  ------------  ------------
9     leather       brown
10    hemp canvas   natural
11    glass         transparent

Table: Shoes, their sizes, and what they're made of

(The above is the caption for the table.) Pandoc also supports
multi-line tables:

--------  -----------------------
keyword   text
--------  -----------------------
red       Sunsets, apples, and
          other red or reddish
          things.

green     Leaves, grass, frogs
          and other things it's
          not easy being.
--------  -----------------------

A horizontal rule follows.

***

Here's a definition list:

apples
  : Good for making applesauce.
oranges
  : Citrus!
tomatoes
  : There's no "e" in tomatoe.

Again, text is indented 4 spaces. (Put a blank line between each
term/definition pair to spread things out more.)

Here's a "line block":

| Line one
|   Line too
| Line tree

and images can be specified like so:

![example image](https://firebasestorage.googleapis.com/v0/b/science-hub-blog-2b481.appspot.com/o/thumbnails%2Fperfection-min.png?alt=media&token=8764aa23-96b9-491e-8564-05ecdbac2ec7)

Inline math equations go in like so: $\omega = d\phi / dt$. Display
math should get its own line and be put in in double-dollarsigns:

$$I = \int \rho R^{2} dV$$

And note that you can backslash-escape any punctuation characters
which you wish to be displayed literally, ex.: \`foo\`, \*bar\*, etc.

![example image](https://via.placeholder.com/600x400/634949/edcc13.png?text=It+works+bro indeed it does work)

Can you really say you have done a good job if we can't see proof of the beauty

Format testing of User Interface

In a bizarre coincidence, six individuals named Ishuz, Elder, Zubby, Glory, Samuel N, and Samuel C all walked into the same bar. What made things even more interesting was that two of them shared the same first name.

As soon as they entered, the bartender couldn't help but notice the confusion on their faces. "What brings you all here?" he asked.

"It's a long story," replied Ishuz, "but basically, we're all here because we share a common interest in cereal."

At this, Elder rolled his eyes. "I thought we were here to talk about our mutual love of music?"

Zubby interjected, "No, no, we're here because we all have the same first name!"

Glory chimed in, "Actually, it's because we all have the same last name!"

Samuel N and Samuel C looked at each other, bemused. "We're not related," they said in unison.

The bartender shook his head in disbelief. "Well, regardless of why you're here, how about I pour you all a drink on the house?"

And with that, the group of six settled in for a night of unexpected camaraderie and confusion, all brought together by the strangest of coincidences.

[insert inspiring quote]