Dan Abramov's Overreacted Blog RSS Feed

Git

Configure your Git username/email
- To set your global username/email configuration
- To set repository-specific username/email configuration:
.gitignore file

Configure your Git username/email

To set your global username/email configuration

Open the command line.
Set your username: git config --global user.name "FIRST_NAME LAST_NAME"
Set your email address: git config --global user.email "MY_NAME@example.com"

To set repository-specific username/email configuration:

From the command line, change into the repository directory.
Set your username: git config user.name "FIRST_NAME LAST_NAME"
Set your email address: git config user.email "MY_NAME@example.com"
Verify your configuration by displaying your configuration file: cat .git/config

Reference

https://support.atlassian.com/bitbucket-cloud/docs/configure-your-dvcs-username-for-commits/

.gitignore file

Add global .gitignore file

Open Terminal.
Run touch ~/.gitignore - this will create global.gitignore file in your home directory.

Add some values that you would like to always ignore.

# OS generated files #
######################
.DS_Store

Run git config --global core.excludesfile ~/.gitignore. According to this page at git-scm.com this command will make all the patterns from ~/.gitignore ignored in all situations.

Reference - http://egorsmirnov.me/2015/05/04/global-gitignore-file.html

Git command to show which specific files are ignored by .gitignore

git status --ignored

Reference - https://stackoverflow.com/a/12080920

Check which .gitignore file is responsible for ignoring the file.

Using above git status --ignored command find out which files are ignored. Then use below to command to see which .gitignore file is responsible for ignoring that file.

git check-ignore -v ../../.DS_Store

Reference - https://riptutorial.com/git/example/2209/checking-if-a-file-is-ignored

(This is an article posted to my blog at overreacted.io. You can read it online by clicking here.)

Miscellaneous

Robocopy

Q - How to replicate a directory file structure with empty files?

Run below command in Windows environment.

robocopy \mydir \mydir_structure /create /e
robocopy "E:\Test\Directory with space in name" "D:\Unorganized\Directory with space in name" /create /e

Reference

https://stackoverflow.com/a/39515601

(This is an article posted to my blog at overreacted.io. You can read it online by clicking here.)

Unix Commands

Q - How to use sed to find and replace text in files in Unix shell?

Use Stream EDitor (sed) as follows:
- sed -i 's/old-text/new-text/g' input.txt
The s is the substitute command of sed for find and replace. It tells sed to find all occurrences of ‘old-text’ and replace with ‘new-text’ in a file named input.txt
Verify that file has been updated:
- more input.txt

Reference

https://www.cyberciti.biz/faq/how-to-use-sed-to-find-and-replace-text-in-files-in-linux-unix-shell/

Q - How to stop running port in mac?

lsof -i :6061
kill -QUIT <PID> // e.g. - kill -QUIT 31211

(This is an article posted to my blog at overreacted.io. You can read it online by clicking here.)

Mac OS Keyboard Shortcuts

Keyboard Shortcuts

Command	Shortcut Key	Reference
Take a screenshot on your Mac	Cmd + Shift + 3	https://support.apple.com/en-sg/HT201361#:~:text=How%20to%20take%20a%20screenshot,it%20to%20edit%20the%20screenshot.
Capture a portion of the screen and save to Desktop	Cmd + Shift + 4	https://support.apple.com/en-sg/HT201361#:~:text=How%20to%20take%20a%20screenshot,it%20to%20edit%20the%20screenshot.
Capture a portion of the screen and copy to clipboard	Cmd + Control + Shift + 4	https://support.apple.com/en-sg/HT201361#:~:text=How%20to%20take%20a%20screenshot,it%20to%20edit%20the%20screenshot.
Capture a window or menu and save to Desktop	Cmd + Shift + 4 + Space bar	https://support.apple.com/en-sg/HT201361#:~:text=How%20to%20take%20a%20screenshot,it%20to%20edit%20the%20screenshot.
View Hidden Files in Finder	Cmd + Shift + .(Period)	https://www.pcmag.com/how-to/how-to-access-your-macs-hidden-files#:~:text=View%20Hidden%20Files%20in%20Finder,%2C%20Applications%2C%20and%20Desktop%20folders.
Move file to the trash	Cmd + delete	https://www.hellotech.com/blog/most-useful-mac-keyboard-shortcuts#:~:text=Command%20%2B%20Delete%20to%20move%20a,Shift%20%2B%20Delete%20to%20empty%20Trash.

(This is an article posted to my blog at overreacted.io. You can read it online by clicking here.)

Mac OS System

System

Change the default Mac app for specific file types

Right-click on a file that uses the file type you’d like to change the default for. For example, one with a .jpg extension (a photo).
Click on Get Info in the pop-up.
Click Open With if the section isn’t already expanded.
Click the drop-down menu.
Click the app you want to use.
Click Change All…
Click Continue when the Finder asks you if you’re sure.

Reference

https://www.imore.com/how-set-mac-app-default-when-opening-file

(This is an article posted to my blog at overreacted.io. You can read it online by clicking here.)

No title

නිවන් මග ප්‍රායෝගික පුහුණුව 01 Buddothpado (methmal arana)

Reference - https://www.youtube.com/watch?v=H2pQ7t6RH3s

හැඩතලය එනකොටම කොස් ගහක් තමයි එන්නේ. මෙතන ඔබ බොහොම සිහි නුවණින් දකින්න ඕනේ. හැබැයි කොස් ගහ ඇත්ත කරගන්නේ නැහැ. කොස් ගහ තමයි එන්නේ. හැබැයි වෙනදට ඔබ රැවටිලා, බාහිරෙන් කියලයි ගන්නේ. බාහිරින් සැප දුක් හොයනවා, විදිනවා. කොස් ගහ ඇත්ත වෙලා. කලින් කපුටාගේ සිත ඉපදුන වෙලාවේ, සෝත වික්ඤාන සිතක් ඉපදුන වෙලාවේ, ඒ සද්දේ එනකොටම කපුටා එනවා. කපුටෙක්ගේ සඤ්ඤාව එනවා. නැහැ නෙමෙයි. වේගයක් තුල ඒක එනවා. එතනම ඔබ මුලින් පුහුණු වෙන්න ඕනේ. ඔබ ප්‍රායෝගික වෙන්න ඕනේ. ඔබ පුහුණු වෙන්න ඕනේ. අනුසෝතය තුල මෙච්චර කාලයක් සිද්ද වුනු දේ මේ මොහොතේ නොවෙනව කියන්න බැහැනේ. වෙනවා. නමුත් ඔබ බාහිර සද්දේ දැන්, සෝත වික්ඤාන සිත එනකොටම ඒකෙ සත්‍ය දකින්න ඕනේ. මේකයි ප්‍රතිපදාව ඔබ පුහුණු වෙනවයි කියන්නේ.

දැන් ප්‍රතිපදාවේ පලවෙනි අදියර ඔබ ගාව තියෙනවා කියල අපි හිතනවා. ඒ කියන්නේ සිත පේන්න ඕනේ. සිතට සිතුවිලි එනවා යනවා පේන්න ඕනේ. ඒකට සමතය ඉතාම වැදගත්. ඔබට මේ සිතක් ඉපදුනා නැතිවුනා කියල මනා කොට සිහි නුවණ තියෙන්න ඕනේ. ඒක තමයි වැදගත්ම. දැන් සිතක් ඉපදුනා නැතිවුනා. දැන් මට මෙවැනි සිතක් ඉපදුනා. දැන් මට වර්ණ සිතක් (චක්ඛු වික්ඤාන සිතක්) ඉපදුනා. දැන් මට ශබ්ද සිතක් (සෝත වික්ඤාන සිතක්) ඉපදුනා. දැන් මට ගන්ධ සිතක් (ඝාන වික්ඤාන සිතක්) ඉපදුනා. ජිව්හා වික්ඤාන සිතක් ඉපදුනා. පොට්ටබ්බ වික්ඤාන සිතක් ඉපදුනා. මනෝ වික්ඤාන සිතක් ඉපදුනා. සිතුවිල්ලක් ආවා. අතීතයේ කාරනාවක් මතක් වුනා. අනාගත සිතක් ඉපදුනා. මට මනෝ වික්ඤාන සිතක් ඉපදුනා. ඔබට පැහැදිලි කරන්න ඕනේ නිසා අපි කියන්නේ මේ චක්ඛු වික්ඤාන සිතක්, සෝත වික්ඤාන සිතක්, ඝාන වික්ඤාන සිතක්, ජිව්හා වික්ඤාන සිතක් කියල. ශබ්ධයක් එනවා කියන්නේ නවත්තන්න බැහැනේ. කන් දෙක වහගෙන නෙමේනේ ඉන්නේ. එහෙනම් ශබ්ධේ එනවා. ශබ්ධ සිතක් ඇතිවුනා නැතිවුනා. එච්චරයි. හොදට සතිය පිහිටවනවා කියන්නේ ඒකට. සිත ඇතිවෙනවා නැතිවෙනවා කියන එකට. ඔබ සිත් පරම්පරාව දකිනවා කියන එකට. කපුටෙක් කියන සඤ්ඤාව එනවා. පෙර මතකය එනවා. මේ අතීත සඤ්ඤානේ. ඒවා එනවා. ශබ්ද සිතක් එනවා. දැන් ඒකෙ එන්නෙම කපුටෙක්ගේ සද්දයක්. ඒත් එක්කම ඔබ හිතට ඇත්ත පෙන්නන්න. බාහිර එහෙම නැහැ. කපුටෙක් කියන්නේ හිතින් හදාගත්ත සම්මුති නාමයක්. ඒක බාහිර දෙයක් නෙමෙයි කියන එක පෙන්නන්න. සිහිය පෙන්නන්න. අමාරුවෙන් හරි පෙන්නන්න සත්‍ය. සත්‍යම විතරයි වැදගත්.

කපුටෙක් කියල තමයි එන්නේ සංඤ්ඤාව. ශබ්ධ වික්ඤාන සිත එනකොටම කපුටෙක් කියල තමයි එන්නේ. එනකොටම ඔබ පෙන්නන්න. මුලින් ඔබ ප්‍රමාදයි. මුලින් අරමුණ එනවා. අරමුණ යනවා. ඊට පස්සේ ඔබට මතක් වෙනවා. ප්‍රජානාති කියන එකට එනවා. නෑ ඒ මගේ හිත කියලා. ඒත් කමක් නැහැ. කාලය එන්න එන්න අඩු වෙයි. මුලින් ඔබ, ඔබ ඉන්න තැනින් පටන් ගන්න. සත්‍යම දකින්න උත්සාහ කරන්න. දැන් ඔබ මේ පැත්ත බලන කොට එක සිතක් නේ උපදින්නේ. ඒ පැත්ත බලන කොට ඔබට අහස පේනවා. මේ පැත්ත බලන කොට ඔබට ගෙයක් පේනවා. බෙල්ල හරවන කොට ඔබට එක එක ඒවා පේනවා. ඒ පේනවා කියන්නේ ඒ සිත් ඉපදෙනවා. සිත් ඉපදී නිරුද්ධ වෙනවා. එත් එක්කම ඒ සේරම ඔබේම සිත බව දකින්න. මේ පෙර සඤ්ඤානේ. මේ මම දන්නා ඒවනේ. අහස කියන්නේ මම දන්න සඤ්ඤාවක්. අහස කිව්වේ නැහැ අහස කියල. දැන් මේ ගඟ ගලනවා වගේ මේ දැන් සිත් පරම්පරාව යනවා. අහස, ගෙයක්, පොල් ගහක්, පොලව, දැන් මේ බෙල්ල කරකවන කොට වටේ මේ සිත් පරම්පරාව යනවා. ඒවා වර්ණ සිත්. චක්ඛු වික්ඤාන සිත්. ඒ එක්කම ඔබට එන්නේ අරමුණු. ඒ අරමුණු නේ ගලන්නේ. සිත කියන්නේ අරමුණනේ. ඒ අරමුණු තමයි ගලන්නේ. ඒ සඤ්ඤා තමයි ගලන්නේ. ඒකට ඇත්ත පෙන්නන්න. මේ මගේ සිතම කියල පෙන්නන්න ඔබ. ඒක බාහිර නැති බව එතනම එතනම පෙන්නන්න. ඒක පුරුදු වෙන්න. හැම එකම හිත කියල දකින්න පුරුදු වෙන්න. කමක් නැහැ සතියක් ගියත්. කමක් නැහැ මාසයක් ගියත්. මුලින් ඔබ ඉන්න තැන ගැන හිතන්න. ඔබ ඉන්නේ දැන් කොහොමත් රැවටිලානේ. කොහොමත් බාහිරට යනවනේ කඩාගෙන මේ හිත. ඒක නවත්තගන්න බැහැනේ. දැන් එනකොටම එන්නේ කෙලින්ම නමක්නේ එන්නේ. හොඳට බලන්න නමක් නෙමේද කියල එන්නේ. සද්දයක් ආවහම ඔය කපුටෙක්. එහෙම නැත්තන් මේ ගහක අත්තක්. එහෙම නැත්තන් ඒ මනුස්සයෙක්. අර බල්ලෙක් කෑ ගහනවා. අර කුරුල්ලෙක් කෑ ගහනවා. මෙතන රොබෝ කෙනෙක් වගේ ඔබ හැසිරෙන්නේ. ඔබේ නිවන් මගට දැන් ඔබ පුහුණු වෙනවනේ. දැන් ඔබට ධර්ම දැනුම තියෙනවනේ. දැන් දන්නවනේ අත්තක් නෙමෙයි කියල. මේක මායාවක් කියල. දැන් ඔබ මේකේ ඇත්ත පෙන්නන්න ඕනෙනේ හිතට. පුරුදු වෙන්න ඕනේ එහෙනම්. එහෙනම් ප්‍රතිපදාවට එන්න ඕනේ.

එහෙනම් ඔබ දන්නවා දැන් දුක්ඛ සත්‍යට හේතුව සමුදය සත්‍ය. දන්නවා දෙයක් කියල ගත්ත ගමන්මයි දුක. ඊට පස්සේ ඔබ දන්නවා ඒකට විසදුම නම් සත්‍ය දකින එකයි. ඒකයි මාර්ග සත්‍ය. දැන් මාර්ග සත්‍ය තුල ඔබ මාර්ගය තුල එනවා. දැන් ඔබ මේ ධර්මය දන්න කෙනා දැනගත්ත කෙනා, ඒ කියන්නේ දර්ශන ඤාණය තියෙන කෙනා. දර්ශන ඥානය තුල ඔබ සත්‍යට දැන් ඇවිල්ල ඉවරයි. ඔබ දැන් බාහිර බොරුවක් කියන එක දකිනවා. ඒක ඔබගේ දැන් මුලින් අසා දැනගත්ත දැනුමක්. දැන් ඔබ ඒක ප්‍රායෝගික වෙන්නයි කටයුතු කරන්නේ. ඒකට ප්‍රතිපදාව ඕනේ. එහෙම නම් ඔබ දැන් හිත දකින්න ඕනේ. හිත දකින එක රවට්ටන්න එපා. තමන්ටම තමන් අවංක වෙන්න. මේ එනවා. යනවා. එනවා. යනවා. ඔබ ඔබේ හිතෙන් මිදෙන්න ඕනේ. ඒක ඔබේම සිත. කාටවත් මේක හංගන්න බැහැ. තමන්ට තමන්ට හංගන්න බැහැනේ. තමන් දන්නවා හොදටම මම රැවටුනා කියල. ඔබ දන්නවා මේ සිතට මම රැවටුනා කියල. ඒක කමක් නැහැ. ඒ සිහිය ආපු මොහොත දකින්න. සිහිය මෙතන ඉතාම වැදගත්. ඔබට පුලුවන්නම් අපි මේ කියන විදිහට කටයුතු කරන්න. ඔබ දියුණුවක් ලබන්න අවශ්‍යයිනේ. ඔබට අවශ්‍යයිනේ මේ ප්‍රතිපදාව පුහුණු වෙන්න. ඔබට දැන් ධර්ම දැනුම තියෙනවනේ. ඔබ දන්නවා දැන් බාහිර ඇත්තක් නෙමෙයි කියල, ඔබ දන්නවා මේ සිතේමයි හැදෙන්නේ කියල. ඔබ දන්නවා සිතත් සත්‍යක් නෙමෙයි කියල. දැන් ඔබට ඕනේ පුහුණු වෙන්න. ප්‍රායෝගික වෙන්න ඕනේ. මේ මායාව තුල තව දුරටත් ඔබ රැවටෙන්න කැමති නැති කෙනෙක්. ධර්ම මාර්ගයට ප්‍රවේශ වුනු කෙනෙක්. එතනට ඔබ දැන් ඇවිල්ල ඉන්නේ. එහෙමනම් තවදුරටත් ඔබ දැන් මේ අසා දැනගත්ත ධර්මය ඉදිරියට ඔබ ප්‍රතිපදාව පුහුණු විය යුතුමයි. එහෙම නැත්තන් වෙන්නේ හැමදාම බන අහනවා විතරයි. කවදාවත් ඔබ දියුණුවක් ලබන්නේ නැහැ. ඔබ මාර්ගයට එන්න ඕනේ. මාධ්‍යට පැමිණෙන්න ඕනේ. මාධ්‍ය හදුනාගන්න ඕනේ.

ආර්ය අෂ්ටාංගික මාර්ගය කියන්නේ පොතක තියෙන එකක් නෙමෙයි. මේ එන අරමුණු වලටනේ කොහොමත් අපි රැවටෙන්නේ. ඒ අරමුණමනේ සිත කියන්නේ. එතනමනේ අපිට සැප දුක හදන්නේ. බුදුන් වහන්සේ ලෝකෙට හෙළි කරන්නේ දුකෙන් මිදෙන මගක්නේ. එහෙමනම් ඒ දුක හටගත්තේ මේ අරමුණනේ, සිතනේ, සිතෙන් රැවටිච්ච නිසානේ. දැන් ඇත්ත පෙන්නන්න. දැන් ඔබ එන එන සිත, ඔබටම ආවේනික ගමනක් ඔබ යන්න ඕනේ. දැන් ඔබ චන්දය, කැමැත්ත තියෙන කෙනා. මේ සිතෙන් මිදෙන්න නිවන් මගට ප්‍රවේශ වුනු කෙනා. එහෙනම් ඔබ දැන් සතර සම්‍යක් ප්‍රධාන වීර්යයෙන් ගමන යනවා. මේ ඇතිවෙන සිතුවිලි දැකල සිහිය පිහිටුවුන මොහොතේම ඒවගේ සත්‍ය දැකල පෙන්න පෙන්න යනවා. සත්‍ය දැකල පෙන්නුවා කියන්නේ ඒක උපාදාන වෙන්නේ නැහැ. ඒකයි ඇත්ත. ඒ සත්‍ය දකින එක තියෙනවනේ, ඒක එක දවසින් ඔබට වෙන්නේ නැහැනේ, එක දවසින් ඔබට ඒ සතිය පිහිටන්නේ නැහැනේ. එක දවසින් ඔබට ඒ අනිමිත්ත සමාධිය පිහිටන්නේ නැහැනේ. ඔබ රැවටෙන්න එපා. මේක මනසිකාරයක් නෙමේ. මේක තවත් සිතුවිලි හදන වෙලාවක් නෙමෙයි. මේක හොදට විසදගන්න මොකද්ද වෙන්නේ කියන එක. අපි දැන් හරියටම මේකට බැහැල කතා කරමු. දැන් සද්දෙනේ අපට එන්නේ. කපුටෙක්. අපට නාමයක්නේ එන්නේ. හැම එකේම නාමේ තමයි එන්නේ. මේක ගෙදර. ඔබ කැමති ඕනෙම අරමුණක්. මේ එන අරමුණම දකින්න. මොකක් හරි ඔබට හිතෙන දේම දකින්න. දැන් මම යන්න ඕනේ. මූන හෝදන්න ඕනේ. දැන් සිතක් ඒත් එනවා. අන්න ඒකට සිහිය පිහිටන්න. එන එන සිත යනවා එනවා, ඒකට සිහිය පිහිටන්න. එතන තමයි ඔබගේ මූලික base එක. ඔබට පේන්න ඕනේ හිත. හිත පේනවද කියල බලන්න. ඔබටම ඔබ අවංක වෙන්න. කාටවත් මේක කියන එකක් නෙමෙයිනේ. මේක සාන්දිට්ටික ධර්මයක්නේ. තමන්ගේම දියුණුව තමන්මනේ හදාගන්නේ. තමන්ම තමන්ගේ මිදීම කරන එකක්නේ. මේක පච්චුප්පන්න ධර්මයක්නේ. එතනමනේ හටගෙන නැතිවෙන එක දකින්නේ. මේ සිතින්මනේ දකින්නේ. තම හිස මත තම අතමය සෙවනැල්ල කිව්වා වගේ, ඔබ ඔබේම සිත දකින්න. පුරුදු වෙන්න. දැන් ඔබගේ පුහුණුව උඩයි, ඔබගේ දියුණුව රදා පවතින්නේ. දැන් ඔබ මාර්ගයට එනවා. දැන් ඔබ බාහිරින් මිදෙන්න ඕනේ. එහෙනම් මේ හිතට ඔබ පෙන්නන්න ඕනේ. දැන් පලවෙනි අදියර තමයි ඔබ සිහිය පිහිටවන්න ඕනේ.

දැන් ඔබ රැකියාවක් කරනවා. දැන් ඔබ යම්කිසි කටයුත්තක නියැලෙනවා. ඔබ දැන් එළවලු කපනවා. ඔබ දැන් අතුගානවා. ඔබ දැන් රෙදි හෝදනවා. ඔබ දැන් රෙදි වනනවා. මොකද්ද ඔබ කරන්නේ දැන්. ඔබ දැන් තේ වක්කරනවා. මොකද්ද ඔබ කරන්න. ඔබ දැන් ඇදුම් අදිනවා. මොකද්ද ඔබ කරන්නේ. ඔය කරන දේම සිහිය පිහිටන්න. සිහියයි, නුවණයි, සිතුවිලියි දිහා බලන්න. පුරුදු කරන්න. අවදි කරන්න ඥානය. සිහියයි නුවණයි අවදි කරනවා කියන්නේ ඥානය අවදි වෙන්නේ ඔතනින්මයි. දැන් ඔබට පෙන්න ඕනේ. මේ පේන දේ වෙන දේ දැනෙන්න ඕනේ. ඒක ඔබට දැනෙනවා කියන්නේ සිහිය අවදි වෙනවා කියන එකයි. දැන් ඔබට විවේකයක් තියෙනවා. දැන් ඔබ මොහොතකට ඔබගේ හුස්ම දිහා සිහිය පිහිටන්න. එක තැනකට හිත තියාගන්න, පුළුවන් හැම මොහොතේම.

දැන් අපි කරපු දේ අපි ඔබට කියනවා. අපි හැම මොහොතේම ආශ්වාස ප්‍රාශ්වාසයට හිත තියාගෙන හිටියා. ඒක දීර්ග කාලයක්, අපි මේ ධර්මයේ දර්ශනයට අවබෝධයට කලිනුත්, අපි මේ නොදන්න කාලෙත් අපි කලේ ආශ්වාස ප්‍රාශ්වාස ආනාපානාසති භාවනාව. දීර්ග කාලයක් තිස්සේ කළා. නොදැනත් කළා. ඒක දන්න කාලේ ඉදන්, පොඩි කාලේ ඉදන් කළා. ඒක කවුරුත් කියල නෙමෙයි. ඒක අපේම ඇතුලාන්තයෙන් ආපු ඒවත් එක්කලයි ඒක සිද්ද වුනේ. ඒක තුල හැම මොහොතේම අපේ හුස්මත් එක්ක තමයි අපේ සිහිය පිහිටුවේ. ආශ්වාස ප්‍රාශ්වාසයට අපි හිත යොමුකරගෙන හිටියා. දීර්ග කාලයක් ඒක තියෙනවා. ඒකෙම ප්‍රතිපලයක් තමයි අවසානයේ අපට මේ මාර්ගයේ ප්‍රත්‍යක්ෂතාවයට එන්න හේතු වුනේ. අපි හැම තිස්සෙම අභ්‍යන්තරයට focus කරනවා. ඒක automatically සිද්ධ වෙනවා. අපිට නිතරම හිත පේනවා. ඒක සාමාන්‍ය දෙයක්. ඒක අමුතුවෙන් හිතනවා නෙමෙයි. අපිට පේන්නේ එලිය නෙමෙයි. අපිට පේන්නේ හිත. සතියට බල ගැන්විලා. ඉන්ද්‍රිය ධර්ම බල ධර්ම වෙනවනේ. එතනට පත්වෙලා. මගපල ඔලුවේ තියාගෙන නෙමෙයි මේ ගමන යන්නේ. මේක තමන්ගේම අභ්‍යන්තරයේ තියෙන පිරිසුදු භාවයෙන් යන ගමනක්. ඔබ එතනට එන්න ඕනේ. හිත දකින්න. සිහිය පිහිටන්න පුළුවන් වෙලාවට. අඩුගානේ නිකන් විවේකීව ඉන්න වෙලාවට, වාඩිවෙලා හරි ඉන්නවනේ කොහේ හරි, අලවෙලා හරි ඉන්නවා කියල හිතන්න, ඔබ ඉන්න මොන ඉරියව්වේ හරි, ඒ විවේක මොහොතේ හිත විසිරෙනවනේ. ඔබට පේනවනේ සිත විසිරෙනවා කියල. එහෙට මෙහෙට යනවා කියල. එක තැනක තියාගන්න. විසිරෙන එක හැම තිස්සෙම අඩු කරගන්න. පුලුවන්නම් ආශ්වාස ප්‍රාශ්වාසයට හිත තියාගන්න. අපි එතන තමයි නිතරම හිත තියාගෙන හිටියේ මුල් කාලයේ. එකයි අපි කිව්වේ, සතිය තමයි අපේ ගෙදර කියල. එහෙම දේශනයක් දාල තියෙනවා. අපි ගෙදර ඉන්නවා කියල හිටියේ සතියේ. සතිය කියන්නේ සිහිය. හිත විසිරෙන්නේ නැහැ පිට යන්නේ නැහැ. අපි ඉන්නේ ආශ්වාස ප්‍රාශ්වාසයට සිහිය පිහිටවාගෙන. එහෙම නැත්තන් අපි ඉන්න ඉරියව්වට හිත තියාගෙන. එහෙම නැත්තන් අපි යමක්ද කරන්නේ එතනට සිහියයි. ඒ කියන්නේ නිරායාසයෙන්ම හැම දෙයක්ම සිහියෙන් කරනවා කියන එකයි.

ඔබට දැන් කරන්න පුළුවන් දේ වෙන්නේ, බාහිරට යොමු වුනු සිහිය, සිහිය දැන් බාහිරට යොමු වෙලා තියෙන්නේ. විසිරෙනවා කියන්නේ ඒකයි. දැන් ඔබ බාහිර ඇත්ත කරගෙන ඉන්නේ. දැන් මේක අනිත් පැත්තට හරවනවා. ටෝර්ච් එක එලියට ගහන්නේ නැතුව තමන්ගේ පැත්තට ගහනව වගේ. ඔබ සිහිය පවත්වන්න ඕනේ ඔබේ සිතට. ඔබට ඔබේ එන එන සිත පේන්න ඕනේ. හොදට පේන්න ඕනේ. ඒ අනුව තමයි ඔබගේ දියුණුව තියෙන්නේ. මේ අපි කතා කරන්නේ මූලිකම අදියර.

අපි දැන් මල් පූජා කරනවා. අපි ආමිස පූජාවන් කරනවා. අපි දාන දෙනවා. අපි පින් දහම් කරනවා. අපි එකක්වත් නවත්තන්න ඕනේ නැහැ. ඒ ගුණ ධර්ම නැති කරගන්න එපා. එතන එතන සිතක් ඇති වෙනවා නැති වෙනවා දකින්න. ක්‍රියාව කියන එකට ඇලෙන්න ගැටෙන්න යන්න එපා. කොයි ක්‍රියාවක් වුනත් ඒක ක්‍රියාවක් විතරයි. ඒකට ඇලුනත් වැඩක් නැහැ. ගැටුනත් වැඩක් නැහැ. මල් පූජා කරන්න ඒ වෙලාවේ බැරි වුනා කියල කම්පා වෙනවා නම්, හදුනා ගන්න ඒ සිත එතන උපාදාන වෙලා. ඒ කියන්නේ ඒක ඔබට අත් ඇරගන්න බැහැනේ. ඔබ දෘෂ්ටියකට කොටු වෙලා. මල් පූජා කරන එකත් දෘෂ්ටියකට එනවා. ඔබට ඒක අත් හැරගන්න බැහැ . ඒක වෙලාවට කරන්න බැරිවුනා කියල දුකක් ඇතිවෙනවා. එතනත් උපාදාන වුන තැන, දුක තියෙන්නේ. මේ බන යම්කිසි විදිහකින් අහන්න බැරි වුනා. එතන කේන්ති යනවා. උපාදාන වුන නිසයි, එහෙම වෙන්නේ. ඒ සිත දකින්න. ඒ සිතෙන් මිදෙන්න ඕනේ. ඒ සිත ඇතිවෙලා නැතිවෙනවා. මම මේක අහන්නම ඕනේ කියන දෘෂ්ටිය, අන්න එතන ඔබ ඉන්නවා. ඔබ කියන කෙනාගෙන් නිදහස් වෙන්නයි මේ යන්නේ. කෙනෙක් නැහැ මෙතන.

33.20

(This is an article posted to my blog at overreacted.io. You can read it online by clicking here.)

No title

වචන අර්ථ

හේතුව - ශබ්ධ වර්ණ, ඵලය - ආත්මය
නාමය - නම් කරන ලද දෙය නාමයයි
සංඛාරා - සකස් කරන ලද දෙය
අවිද්‍යාව/ නොදැනුවත්කම - මනෝමය චිත්‍ර ඇත්ත කරගෙන සිටීම
පින - සතුට
කුසලය - කුසලතාවය
උගන්නනවා කියන්නේ ආලෝක හැඩතල ඇහැට දිදී කනට ශබ්ධ දාන එක.

සිත හැදෙන හැටි

Ice cream ගැන ආශාවක් පොඩි ළමයෙකුට ඉපදුනේ කොහොමද
මාස 6 ක පොඩි ළමයෙකුගේ දෙමව්පියන් accident එකකින් මිය ගිහාම, ඒ පොඩි ළමයා දෙමව්පියන්ගේ මිනී පෙට්ටිය යට සෙල්ලම් කරන්නේ කොහොමද

ආත්මීය දැනීම හැදෙන හැටි

ශබ්ද වර්ණ එකතු වෙලා ආත්මීය දැනීමක් හදනවා. ආත්මීය දැනීම ශබ්ද වර්ණ කියල පෙන්නන්නේ නැහැ. ආත්මයක් කියල පෙන්නනවා.

තද ගතිය කියන හිත හැදෙන හැටි

දැන් ඇස් දෙක පියාගන්න. පොලවේ කකුල ගෑවිලා තියෙනවා දැනෙනවා නේද? දැන් ඇස් දෙක පියාගෙනම බලන්න කකුල සහ පොලව කියන සංකල්ප දෙක කොහෙද තියෙන්නේ? පොලව මානසික රූප, චිත්ත රූප විදිහට නේද තියෙන්නේ. කකුලත් චිත්ත රූප විදිහට නේද තියෙන්නේ. එතකොට මේ දෙක හරහා දැනීමක් තියෙනවා කියන එක, ඒකත් චිත්ත රූපයක් විදිහට නේද තියෙන්නේ. එතකොට දැන් තද ගතියක් දැනෙනවා. අපි දැන් තද ගතියට නම දාගෙන තියෙනවා, පොලව, කකුල, දැනෙනවා කියල 3 කින්. ඒත් ඇත්තටම තියෙන්නේ මේ තුනද, තද ගතියද? මුලික වශයෙන් තියෙන්නේ තද ගතිය නේද? එතකොට අර 3 ද්විතීකව හදා ගත්තු නම්. ඊලගට අපි තද ගතිය කියල label එකක් නමක් ගහගෙන තියෙනවනේ. ඒකත් අපි තද ගතියට නැතුව පස්සේ හදාගත්ත එකක්.

ශබ්දයක් ඇසෙන කොට හිත හැදෙන හැටි

ඔබ ඔබගේ සිත දිහා බලමින් සිතට එන අරමුණු දිහා සිහිය පවත්වමින්, ඒ අරමුණේ සත්‍ය දැකල, සිතට එන අරමුණට සත්‍ය පෙන්නනවනම්, ඔබ මාර්ගය තුල කටයුතු කරනවා. මේ මොහොතේ ඔබට එන සිත දිහා බලන්න. ඔබට ශබ්දයක් ඇහෙනවා. ඒක ශබ්ද සිතක්. ඒ ශබ්දෙට අපි නමක් තියනවා. ඒ ශබ්දය ඇහෙනකොටම අපිට, ඒ කපුටෙක්ගේ ශබ්දේ කියන එක සිහි වෙනවා. ඒ කියන්නේ අපි මායාවට හසු වෙලා ඉන්නේ. සත්‍ය නම් ඒකයි. ශබ්දයක් කියනකොටම එන්නේ කපුටෙක්ගේ සංඤ්ඤාවක්. හැබැයි එතනම සත්‍ය දකිනවා. ශබ්දේ එන්නේ නැතුව නෙමෙයි. ශබ්දේ එනවා. කාක් කාක් කියන ශබ්දේ එනවා. එනකොටම කපුටෙකේ කියන සංඤ්ඤාව එතනම එනවා. පෙර සංඤ්ඤාව එනවා. හැබැයි ඒත් එක්කම ඔබ, විශේෂ දෙයක් තියෙනවා වෙනදා වගේ රැවටෙන්නේ නැහැ. ඒ තමන්ගේම සිත බව දකිනවා. දැන් මේ විදිහට ඔබ පුහුණු වෙනවා. හැම සිතක්ම දකින්න ඕනේ. දැන් ඔබට හැඩතලයක් පේනවා. ඒ එනකොටම ඔබ කියනවා කොස් ගහක් කියල. ඒ හැඩතලය එනකොටම කොස් ගහ තමයි එන්නේ. අපි දැන් ධර්මය දන්නවා. දන්නවා බාහිරින් දෙයක් නැති බව. මේ තමන්ගේම සිත තුලම හැදෙන කොස් ගහ කියන එක තමයි එන්නේ.

ලෝකය බොරුවක් වන්නේ කෙසේද?

ලංකාව කියන්නේ මේකයි කියල දහ දෙනෙක් හිතන් ඉන්නේ දහ විදිහකට. ලෝකය විශ්වය කියන්නේ මේකයි කියල දහ දෙනෙක් හිතන් ඉන්නේ දහ විදිහකට. ඒ ඇයි කියල බැලුවොත්, ඔවුන් අහල තියෙන කතන්දර වෙනස්. අහල තියෙන කතන්දර වෙනස් නිසා ඔවුන් ලෝකය විශ්වය මේකයි කියල මැවිලා තියෙන මනෝමය චිත්‍ර වෙනස්.

කාලය

කාලය ගැන සංකල්ප හැදෙන හැටි

පොඩි දරුවෙකුට කාලය ගැන හැගීමක් නොමැති හැටි

පොඩි දරුවෙකුට කාලය ගැන හැගීමක් නැහැ. පොඩි දරුවෙකුට ඊලග අවුරුද්ද, ඊලග මාසේ, ඊලග සතිය කියල අදහසක් නැහැ. වෙලාව දන්නේ නැහැ. වෙලාව ගැන කියන්න තේරුමක් නැහැ. අපිටත් මුලින් එහෙම එකක් තිබුනේ නැහැ. පොඩි ළමයෙක් කාලය කියන එකෙන් නිදහස් වෙලා ඉන්නේ. පොඩි දරුවෙකුට අනාගත බය කියල දෙයක් තිබ්බේ නැහැ.

පැය, දින, සති, මාස, අවුරුදු හැදෙන හැටි

අපිට නොයෙකුත් කතන්දර, සංකල්ප දානව. එතකොට අපිට පැය, දින, සති, මාස, අවුරුදු කියල දැනෙනවා. එතකොට ලොකු කාලයක් තියෙනවා කියල දැනෙන්න පටන් ගන්නව. හැබැයි මේක කලින් තිබ්බ එකක් නෙමෙයි.

විශ්වය, පෘථිවිය අවුරුදු බිලියන ගානකට කලින් හැදෙන හැටි

ඔබ තවත් කතන්දර අහනවා. අවුරුදු බිලියන ගානකට කලින් විශ්වය මෙහෙම හැදුනා, පෘථිවිය මෙහෙම හැදුනා කියල විද්‍යාව පැත්තෙන් කතන්දර ටිකක් ඇහුනහම ඔන්න තවත් එකක් හැදෙනවා.

සංසාරේ අනන්ත බව හැදෙන හැටි

අනන්ත සංසාරේ මෙහෙම අනන්තයි. මෙහෙම නැවත ඉපදෙමින් මැරෙමින් යනවා කියල බණකට ඇහුනහම, ආයිත් මනෝමය චිත්ත රූපයක් හැදෙනවා.

අතීතය, අනාගතය පනවන්න බැහැ

අතීතය තියෙන්නේ කොහෙද? මේ මොහොතේ සිතුවිල්ලක විතරයි. අනාගතය තියෙන්නේ කොහෙද? මේ මොහොතේ සිතුවිල්ලක විතරයි. කාලය කියල දෙයක් පනවන්න බැහැ.

වර්තමානය කියල දේකුත් පනවන්න බැහැ

අතීතය තියෙන්නේ වර්තමානයට සාපේක්ෂකව, වර්තමානයෙමයි. අනාගතය තියෙන්නේත් වර්තමානයට සාපේක්ෂකව, වර්තමානයෙමයි. වර්තමානය තියෙන්නෙත් වර්තමානයෙමයි. එතකොට අතීතයකුත් වර්තමානයකුත් ඇත්තටම නැති කොට වර්තමානය යනු කුමක්ද? එහෙම බැලුවහම වර්තමානය කියල දේකුත් නැති වෙනවා. මේක තමයි බුදු දහම අකාලිකයි කියන්නේ.

අවකාශය

දළදා මාලිගාව තියෙන්නේ කොහෙද? නුවර තියෙන්නේ කොහෙද? එහෙම ඇහුවම හිතෙන්නේ ගෙදර ඉදන් මෙච්චර දුරකින් තියෙනවා කියල. ඒක තිබ්බේ සිතුවිල්ලක . දිව්‍ය ලෝකය තියෙන්නේ කොහෙද? සිතුවිල්ලක. අපාය තියෙන්නේ කොහෙද? සිතුවිල්ලක. ඒක හින්ද අවකාශය කියල දෙයක් පනවන්න බැහැ.

අවබෝධය ලැබූ පුද්ගලයා සහ නොලැබූ පුද්ගලයාගේ අවසානය

හිතන්න ඔබ තව 10 දෙනෙකු සමග වාහනයක ගමන් කරනවා කියල. කොළඹ ඉදන් නුවරට ගමන් කරනවා කියල හිතන්න. 10 දෙනාගේම අවසානය නුවර. හැබැයි මේ නුවරට යන අතරේ එක්කෙනෙකුට බය වෙලා යන්න පුළුවන්. තව කෙනෙකුට හිනා වෙලා සතුටින් යන්න පුළුවන්. තව කෙනෙක්ට අඩ අඩා යන්න පුළුවන්. එතකොට මේ යන අතරේදී හිනා වෙලා ඉන්නවද අඬල ඉන්නවද කියන එක විතරයි වැදගත්.

ප්‍රායෝගික පුහුණුව

ප්‍රශ්නයේ මුල විමසන්න

නිවන් මාර්ගය තෝරාගන්න කලින් බලන්න, ඇයි නිවන් දැකිය යුත්තේ කියල. සත්වයෙක් උත්පත්තිය ලැබූ මොහොතේ සිට යමක් හොයනවා. මේ හොයපු දේ මොකද්ද, හොයපු දේ අපිට ලැබුනද, හොයපු දේ හින්ද අපිට මොනවාද වුනේ කියල කෙනෙක් ඉස්සෙල්ල විමර්ශනය කරන්න ඕනේ. නිවන මොකද්ද කියල හොයන්න කලින් අපි හොයාගන්න ඕනේ සසර මොකද්ද කියන එක.

සිතුවිලි පාලනය කරන්න එපා

ඔබට එන හැගීම් ඔබ ඇති කරගන්නා ඒවා නෙමෙයි, ඒවා අවස්ථානුකූලව ඇතිවෙන ඒවායි. තියෙන හේතු වලට අනුව ඔබට මනෝ භාවයක් එනවා. ප්‍රශ්නය තමයි අපි ගන්නවා, මේක මම කරන එකක් සහ මේක මගේ එකක් කියලා. මේ මනෝ භාවය මගේ එකක් කියලා එක්කෝ ඒක පවත්වන්න යනවා. නැත්නම් ඒක නැති කරන්න යනවා. ඒක අවස්ථානුකූලව හටගන්නා නිසා ඒක අමුතුවෙන් නැති කරන්න දේකුත් නැහැ, අමුතුවෙන් පවත්වන්න දේකුත් නැහැ. ඒකෙ විශේෂ දෙයක් නැහැ. ඒක මට වෙච්ච එකක්වත් ඒක මම කරන එකක්වත් නෙමෙයි. ඔබ බලන්න, සිතුවිල්ලක් කියල එකක් ඔබ ගොඩනගනවද, ඔබ හදනවද කියල. ඔබට හදන්න පුලුවන්ද කියල බලන්න.

ලෝකය දැනගෙන රගපාන්න

ලෝකය දැනගෙන රගපාන්න. අපේ අධ්‍යක්ෂක වරයෙක් ඉන්නවා. අධ්‍යක්ෂක සහ ප්‍රේක්ෂකයන් ඉල්ලන චරිතය අපි දැනගෙන රගපාමු. ඒක චරිතයක් බව දැනගෙන serious ගන්නේ නැතුව, makeup ටික දාගෙන ඇදුම් ටික ඇදගෙන රගපාල, වේදිකාවෙන් බැහැල යනකොට ඉවත් කරලා යනවා. එහෙමත් නැත්නම් ඔබගේ අධ්‍යක්ෂක ඔබම වන්න. ඔබගේ ප්‍රේක්ෂක ඔබමත් වන්න. ප්‍රේක්ෂකයෝ සතුටු කිරීම සහ අධ්‍යක්ෂක සතුටු කිරීම ඇත ඇරලා දාන්නත් පුළුවන් ඕනෙනම්.

මතවාදයක් තියාගන්න එපා

අපි යම් මතවාදයක් හදාගෙන, එක්කෝ ඒක සුද්ද කරලා, ඒක පවත්වන්න හදනවා. නැත්නම් අලුත් මතවාදයක් හදාගන්න හදනවා. එහෙම කිසිම මතවාදයක, අදහසක, නිගමනයක එලබිලා ජීවත් වෙන්න එපා. කිසිම ස්ථාවර නිගමනයක් ඉන්න එපා.

අවබෝධය යනු මුලාවක් බව දැනගන්න

අපි සම්මුතිය කියන එක මායාවක්, මුලාවක්, බොරුවක් කියල දැනගන්නවා. අපි සම්මුතිය මායාවක්, මුලාවක්, බොරුවක් කියල ගන්න අදහසත්, තවත් සම්මුතියක් විතරයි. ඒක වලංගු වෙන්නේ ඔබ කවුරු හරි එක්ක ධර්මය කතා කරන කොට විතරයි. අනිත් අවස්ථාවලදී, ඒ සම්මුතිය වලංගු වෙන්නේ නැහැ. අනිත් තැන්වලදී ඔබ ඉන්න ඕනේ සම්මුතිය කියන එක යතාර්ථයක් කියන සම්මුතියේ තමයි. සම්මුතිය කියන එක මායාවක් කියල ඉන්න හැදුවොත් ඒක තවත් දෘෂ්ටියක් වෙනවා. ඔබ නිදහස්ව ඉන්න. අවස්තානුකුලාව පාවිච්චි කරන්න. ඇත විදිහට ගන්න ඕනේ තැන්වලදී ඇත විදිහට ගන්න. නැත විදිහට ගන්න ඕනේ තැන්වලදී නැත විදිහට ගන්න.

(This is an article posted to my blog at overreacted.io. You can read it online by clicking here.)

youtube-dl

Q - How to download a youtube playlist with 360p video quality with custom name?

youtube-dl -f 18 -o "%(upload_date) - %(title)s.%(ext)s" -cit https://www.youtube.com/playlist?list=PLGHAZGDPdsqsoJC12tAZRNLMRcJc5KgG5

18 - 360p 133 - 240p

Reference

(This is an article posted to my blog at overreacted.io. You can read it online by clicking here.)

Minikube

Mon, 02 May 2022 00:00:00 GMT

Install Minikube with podman

Install Minikube with podman

Setup Podman

Set noproxy for minikube in .bash_profile, .bash_rc, .zh_profile and .zhrc and source the .bash_profile to terminal session
- Reference - https://minikube.sigs.k8s.io/docs/handbook/vpn_and_proxy/

export HTTP_PROXY=http://<proxy hostname:port>
export HTTPS_PROXY=https://<proxy hostname:port>
export NO_PROXY=localhost,127.0.0.1,10.96.0.0/12,192.168.59.0/24,192.168.39.0/24,10.88.0.5

Create podman with adequate specs and tweak the connections

podman machine init --cpus 6 --memory 12288 --disk-size 50
podman machine start
podman system connection default podman-machine-default-root

Verify podman can pull images
```
podman pull nginx:alpine
```

Setup minikube

Start minikube
- Reference
- https://minikube.sigs.k8s.io/docs/start/
```
minikube start --driver=podman --container-runtime=cri-o
```
Verify all the resources are running correctly
- Note: If you see errors, disconnect VPN and try.
```
kubectl get po -A
```
Start minikube dashboard
- Miniube dashboard will open in below port. http://127.0.0.1:51651/
```
minikube dashboard
```

Deploy application in minikube

Create a sample deployment and expose it on port 8080:
- Note: The container image mentioned in minikube tutorial does work on M1(arm64).
- Reference - https://matt-wxw.medium.com/kubernetes-on-apple-m1-using-minikube-21ea1b08e7d6

kubectl create deployment hello-minikube --image=docker/getting-started --replicas=2
kubectl expose deployment hello-minikube --type=NodePort --port=80

Access this service by letting minikube launch a web browser for you
```
minikube service hello-minikube
```

Troubleshooting

standardinitlinux.go:228: exec user process caused: exec format error

If you are getting below error when running container in the logs, it is due to the image not supported for arm64. Try using a arm64 plaform image or build your image to support arm64 platform

Reference - https://stackoverflow.com/a/70614305

(This is an article posted to my blog at overreacted.io. You can read it online by clicking here.)

Test

Sun, 24 Apr 2022 00:00:00 GMT

(This is an article posted to my blog at overreacted.io. You can read it online by clicking here.)

Concurrent Mode and Suspense

Sun, 24 Apr 2022 00:00:00 GMT

Concurrent Mode and Suspense

Concurrent Mode and Suspense

Reference - https://reactjs.org/docs/concurrent-mode-intro.html

Q - What Is Concurrent Mode?

Concurrent Mode is a set of new features that help React apps stay responsive and gracefully adjust to the user’s device capabilities and network speed.

Q - What are the two rendering strategies?

Blocking rendering
Interruptible Rendering

Q - Explain Concurrent Mode by taking version control as a metaphor?

If you work on a team, you probably use a version control system like Git and work on branches. When a branch is ready, you can merge your work into master so that other people can pull it.

Before version control existed, the development workflow was very different. There was no concept of branches. If you wanted to edit some files, you had to tell everyone not to touch those files until you’ve finished your work. You couldn’t even start working on them concurrently with that person — you were literally blocked by them.

This illustrates how UI libraries, including React, typically work today. Once they start rendering an update, including creating new DOM nodes and running the code inside components, they can’t interrupt this work. We’ll call this approach “blocking rendering”.

In Concurrent Mode, rendering is not blocking. It is interruptible. This improves the user experience. It also unlocks new features that weren’t possible before. Before we look at concrete examples in the next chapters, we’ll do a high-level overview of new features.

Q - Explain interruptible rendering which is used in Concurrent mode.

Consider a filterable product list. Have you ever typed into a list filter and felt that it stutters on every key press? Some of the work to update the product list might be unavoidable, such as creating new DOM nodes or the browser performing layout. However, when and how we perform that work plays a big role.

A common way to work around the stutter is to “debounce” the input. When debouncing, we only update the list after the user stops typing. However, it can be frustrating that the UI doesn’t update while we’re typing. As an alternative, we could “throttle” the input, and update the list with a certain maximum frequency. But then on lower-powered devices we’d still end up with stutter. Both debouncing and throttling create a suboptimal user experience.

The reason for the stutter is simple: once rendering begins, it can’t be interrupted. So the browser can’t update the text input right after the key press. No matter how good a UI library (such as React) might look on a benchmark, if it uses blocking rendering, a certain amount of work in your components will always cause stutter. And, often, there is no easy fix.

Concurrent Mode fixes this fundamental limitation by making rendering interruptible. This means when the user presses another key, React doesn’t need to block the browser from updating the text input. Instead, it can let the browser paint an update to the input, and then continue rendering the updated list in memory. When the rendering is finished, React updates the DOM, and changes are reflected on the screen.

Conceptually, you can think of this as React preparing every update “on a branch”. Just like you can abandon work in branches or switch between them, React in Concurrent Mode can interrupt an ongoing update to do something more important, and then come back to what it was doing earlier. This technique might also remind you of double buffering in video games.

Concurrent Mode techniques reduce the need for debouncing and throttling in UI. Because rendering is interruptible, React doesn’t need to artificially delay work to avoid stutter. It can start rendering right away, but interrupt this work when needed to keep the app responsive.

Q - how Concurrent mode solves the problem of having jarring loading experience when navigating between screens. (Intentional loading sequence)

We’ve said before that Concurrent Mode is like React working “on a branch”. Branches are useful not only for short-term fixes, but also for long-running features. Sometimes you might work on a feature, but it could take weeks before it’s in a “good enough state” to merge into master. This side of our version control metaphor applies to rendering too.

Imagine we’re navigating between two screens in an app. Sometimes, we might not have enough code and data loaded to show a “good enough” loading state to the user on the new screen. Transitioning to an empty screen or a large spinner can be a jarring experience. However, it’s also common that the necessary code and data doesn’t take too long to fetch. Wouldn’t it be nicer if React could stay on the old screen for a little longer, and “skip” the “bad loading state” before showing the new screen?

While this is possible today, it can be difficult to orchestrate. In Concurrent Mode, this feature is built-in. React starts preparing the new screen in memory first — or, as our metaphor goes, “on a different branch”. So React can wait before updating the DOM so that more content can load. In Concurrent Mode, we can tell React to keep showing the old screen, fully interactive, with an inline loading indicator. And when the new screen is ready, React can take us to it.

Q - What are the two most problems Concurrent mode is solving?

Let’s recap the two examples above and see how Concurrent Mode unifies them. In Concurrent Mode, React can work on several state updates concurrently — just like branches let different team members work independently:

For CPU-bound updates (such as creating DOM nodes and running component code), concurrency means that a more urgent update can “interrupt” rendering that has already started.
For IO-bound updates (such as fetching code or data from the network), concurrency means that React can start rendering in memory even before all the data arrives, and skip showing jarring empty loading states.

Importantly, the way you use React is the same. Concepts like components, props, and state fundamentally work the same way. When you want to update the screen, you set the state.

React uses a heuristic to decide how “urgent” an update is, and lets you adjust it with a few lines of code so that you can achieve the desired user experience for every interaction.

Q - How Concurrency mode integrate the findings from Human-Computer Interaction research in to real UIs?

There is a common theme around Concurrent Mode features. Its mission is to help integrate the findings from the Human-Computer Interaction research into real UIs.

For example, research shows that displaying too many intermediate loading states when transitioning between screens makes a transition feel slower. This is why Concurrent Mode shows new loading states on a fixed “schedule” to avoid jarring and too frequent updates.

Similarly, we know from research that interactions like hover and text input need to be handled within a very short period of time, while clicks and page transitions can wait a little longer without feeling laggy. The different “priorities” that Concurrent Mode uses internally roughly correspond to the interaction categories in the human perception research.

Teams with a strong focus on user experience sometimes solve similar problems with one-off solutions. However, those solutions rarely survive for a long time, as they’re hard to maintain. With Concurrent Mode, our goal is to bake the UI research findings into the abstraction itself, and provide idiomatic ways to use them. As a UI library, React is well-positioned to do that.

(This is an article posted to my blog at overreacted.io. You can read it online by clicking here.)

Pracical Interview Questions

Sun, 24 Apr 2022 00:00:00 GMT

Practical Interview Questions

Practical Interview Questions

Q - Write code using a ref hook to toggle the case of input text to uppercase and lower case upon clicking a button.

import { useRef, useState } from "react";
import "./App.css";

function App() {
  const inputField = useRef(null);

  const [textCase, setTextCase] = useState("lowercase");

  const toggleInputCase = () => {
    const currentValue = inputField.current.value;
    if (textCase === "lowercase") {
      inputField.current.value = currentValue.toUpperCase();
      setTextCase("uppercase");
    } else {
      inputField.current.value = currentValue.toLowerCase();
      setTextCase("lowercase");
    }
  };

  return (
    <div>
      <input type="text" ref={inputField} />
      <button type="button" onClick={toggleInputCase}>
        Toggle Case
      </button>
    </div>
  );
}

export default App;

Q - Say if you have a child component which is having a deep tree itself. If we want to prevent unnecessary rerendering for that component, how could we achieve that?

shouldComponentUpdate method in class based components React.memo in functional components

Q - Say I need to derive a value for a variable by doing expensive computation, and I need to show this variable value in the component. Is there any way that I could only do this computation once and use it with next rerenders?

useMemo hook

React.lazy

Q - Say I want to show a counter value in the screen and this value should be incremented every second. And upon clicking a button, you want to stop this counter getting incremented automatically. How would you do this?

Setup a setInterval timer in the useEffect method and assign the timer reference to a useRef
Do clearInterval of the timer reference in the button click method

(This is an article posted to my blog at overreacted.io. You can read it online by clicking here.)

React Architecuture

Sun, 24 Apr 2022 00:00:00 GMT

React Architecture

React Architecture

Q - What is React?

React is a front-end JavaScript library developed by Facebook in 2011.
It follows the component based approach which helps in building reusable UI components.
It is used for developing complex and interactive web and mobile UI.
Even though it was open-sourced only in 2015, it has one of the largest communities supporting it.

Q - What are the features of React?

It uses the virtual DOM instead of the real DOM.
It uses server-side rendering.
It follows uni-directional data flow or data binding.

Q - What are the advantages of using React?

It increases the application’s performance
It can be conveniently used on the client as well as server side. This enables improved SEO and performance.
Because of JSX, code’s readability increases. It is also really easy to see the layout, or how components are plugged/combined with each other.
React is easy to integrate with other frameworks like Meteor, Angular, etc as it is only a view layer.
Using React, writing UI test cases become extremely easy

Q - What are the limitations of React?

React is just a library, not a full-blown framework
Its library is very large and takes time to understand
Coding gets complex as it uses inline templating and JSX

Q - How does React work?

React creates a virtual DOM. When state changes in a component it firstly runs a “diffing” algorithm, which identifies what has changed in the virtual DOM. The second step is reconciliation, where it updates the DOM with the results of diff.

Q - What do you understand by Virtual DOM? Explain its working.

A virtual DOM is a lightweight JavaScript object which originally is just the copy of the real DOM. It is a node tree that lists the elements, their attributes and content as Objects and their properties.
React’s render function creates a node tree out of the React components. It then updates this tree in response to the mutations in the data model which is caused by various actions done by the user or by the system.
This Virtual DOM works in three simple steps.
1. Whenever any underlying data changes, the entire UI is re-rendered in Virtual DOM representation.
2. Then it runs a “diffing” algorithm, which identifies the difference between the previous DOM representation and the new one.
3. Next step is reconciliation which is that the real DOM will be updated with only the things that have actually changed.

Q - Differentiate between Real DOM and Virtual DOM.

Real DOM

It updates slow.
Can directly update HTML.
Creates a new DOM if element updates.
DOM manipulation is very expensive.
Too much of memory wastage.

Virtual DOM

It updates faster.
Can’t directly update HTML.
Updates the JSX if element updates.
DOM manipulation is very easy.
No memory wastage.

(This is an article posted to my blog at overreacted.io. You can read it online by clicking here.)

Hooks

Sun, 24 Apr 2022 00:00:00 GMT

Hooks

Hooks

Q - Which versions of React include Hooks?

Starting with 16.8.0, React includes a stable implementation of React Hooks for:

React DOM
React Native
React DOM Server
React Test Renderer
React Shallow Renderer

Note that to enable Hooks, all React packages need to be 16.8.0 or higher. Hooks won’t work if you forget to update, for example, React DOM.

React Native 0.59 and above support Hooks.

Q - What can I do with Hooks that I couldn’t with classes?

Hooks offer a powerful and expressive new way to reuse functionality between components. “Building Your Own Hooks” provides a glimpse of what’s possible. This article by a React core team member dives deeper into the new capabilities unlocked by Hooks.

Q - Should I use Hooks, classes, or a mix of both?

When you’re ready, we’d encourage you to start trying Hooks in new components you write. You can’t use Hooks inside of a class component, but you can definitely mix classes and function components with Hooks in a single tree. Whether a component is a class or a function that uses Hooks is an implementation detail of that component. In the longer term, we expect Hooks to be the primary way people write React components.

Q - Do Hooks cover all use cases for classes?

Our goal is for Hooks to cover all use cases for classes as soon as possible. There are no Hook equivalents to the uncommon getSnapshotBeforeUpdate and componentDidCatch lifecycles yet, but we plan to add them soon.

Q - Do Hooks replace render props and higher-order components?

Often, render props and higher-order components render only a single child. We think Hooks are a simpler way to serve this use case. There is still a place for both patterns (for example, a virtual scroller component might have a renderItem prop, or a visual container component might have its own DOM structure). But in most cases, Hooks will be sufficient and can help reduce nesting in your tree.

Q - What exactly do the lint rules enforce?

We provide an ESLint plugin that enforces rules of Hooks to avoid bugs. It assumes that any function starting with ”use” and a capital letter right after it is a Hook. We recognize this heuristic isn’t perfect and there may be some false positives, but without an ecosystem-wide convention there is just no way to make Hooks work well — and longer names will discourage people from either adopting Hooks or following the convention.

In particular, the rule enforces that:

Calls to Hooks are either inside a PascalCase function (assumed to be a component) or another useSomething function (assumed to be a custom Hook).
Hooks are called in the same order on every render.
There are a few more heuristics, and they might change over time as we fine-tune the rule to balance finding bugs with avoiding false positives.

From Classes to Hooks

Q - How do lifecycle methods correspond to Hooks?

constructor: Function components don’t need a constructor. You can initialize the state in the useState call. If computing the initial state is expensive, you can pass a function to useState.
getDerivedStateFromProps: Schedule an update while rendering instead.
shouldComponentUpdate: See React.memo below.
render: This is the function component body itself.
componentDidMount, componentDidUpdate, componentWillUnmount: The useEffect Hook can express all combinations of these (including less common cases).
componentDidCatch and getDerivedStateFromError: There are no Hook equivalents for these methods yet, but they will be added soon.

Q - How can I do data fetching with Hooks?

Here is a small demo to get you started. To learn more, check out this article about data fetching with Hooks.

Q - Should I use one or many state variables?

If you’re coming from classes, you might be tempted to always call useState() once and put all state into a single object. You can do it if you’d like. Here is an example of a component that follows the mouse movement. We keep its position and size in the local state:

function Box() {
  const [state, setState] = useState({ left: 0, top: 0, width: 100, height: 100 });
  // ...
}

Now let’s say we want to write some logic that changes left and top when the user moves their mouse. Note how we have to merge these fields into the previous state object manually:

  // ...
  useEffect(() => {
    function handleWindowMouseMove(e) {
      // Spreading "...state" ensures we don't "lose" width and height      setState(state => ({ ...state, left: e.pageX, top: e.pageY }));    }
    // Note: this implementation is a bit simplified
    window.addEventListener('mousemove', handleWindowMouseMove);
    return () => window.removeEventListener('mousemove', handleWindowMouseMove);
  }, []);
  // ...

This is because when we update a state variable, we replace its value. This is different from this.setState in a class, which merges the updated fields into the object.

If you miss automatic merging, you can write a custom useLegacyState Hook that merges object state updates. However, instead we recommend to split state into multiple state variables based on which values tend to change together.

For example, we could split our component state into position and size objects, and always replace the position with no need for merging:

function Box() {
  const [position, setPosition] = useState({ left: 0, top: 0 });  const [size, setSize] = useState({ width: 100, height: 100 });

  useEffect(() => {
    function handleWindowMouseMove(e) {
      setPosition({ left: e.pageX, top: e.pageY });    }
    // ...

Separating independent state variables also has another benefit. It makes it easy to later extract some related logic into a custom Hook, for example:

function Box() {
  const position = useWindowPosition();  const [size, setSize] = useState({ width: 100, height: 100 });
  // ...
}

function useWindowPosition() {  const [position, setPosition] = useState({ left: 0, top: 0 });
  useEffect(() => {
    // ...
  }, []);
  return position;
}

Note how we were able to move the useState call for the position state variable and the related effect into a custom Hook without changing their code. If all state was in a single object, extracting it would be more difficult.

Both putting all state in a single useState call, and having a useState call per each field can work. Components tend to be most readable when you find a balance between these two extremes, and group related state into a few independent state variables. If the state logic becomes complex, we recommend managing it with a reducer or a custom Hook.

Q - Can I run an effect only on updates?

This is a rare use case. If you need it, you can use a mutable ref (Q-Is there something like instance variables?) to manually store a boolean value corresponding to whether you are on the first or a subsequent render, then check that flag in your effect. (If you find yourself doing this often, you could create a custom Hook for it.)

Q - How to get the previous props or state?

Currently, you can do it manually with a ref:

function Counter() {
  const [count, setCount] = useState(0);

  const prevCountRef = useRef();
  useEffect(() => {
    prevCountRef.current = count;  });
  const prevCount = prevCountRef.current;
  return <h1>Now: {count}, before: {prevCount}</h1>;
}

This might be a bit convoluted but you can extract it into a custom Hook:

function Counter() {
  const [count, setCount] = useState(0);
  const prevCount = usePrevious(count);  return <h1>Now: {count}, before: {prevCount}</h1>;
}

function usePrevious(value) {  const ref = useRef();
  useEffect(() => {
    ref.current = value;
  });
  return ref.current;
}

Note how this would work for props, state, or any other calculated value.

function Counter() {
  const [count, setCount] = useState(0);

  const calculation = count * 100;
  const prevCalculation = usePrevious(calculation);  // ...

It’s possible that in the future React will provide a usePrevious Hook out of the box since it’s a relatively common use case.

Q - Why am I seeing stale props or state inside my function?

Any function inside a component, including event handlers and effects, “sees” the props and state from the render it was created in. For example, consider code like this:

function Example() {
  const [count, setCount] = useState(0);

  function handleAlertClick() {
    setTimeout(() => {
      alert('You clicked on: ' + count);
    }, 3000);
  }

  return (
    <div>
      <p>You clicked {count} times</p>
      <button onClick={() => setCount(count + 1)}>
        Click me
      </button>
      <button onClick={handleAlertClick}>
        Show alert
      </button>
    </div>
  );
}

If you first click “Show alert” and then increment the counter, the alert will show the count variable **at the time you clicked the “Show alert” button. This prevents bugs caused by the code assuming props and state don’t change.

If you intentionally want to read the latest state from some asynchronous callback, you could keep it in a ref, mutate it, and read from it.

Finally, another possible reason you’re seeing stale props or state is if you use the “dependency array” optimization but didn’t correctly specify all the dependencies. For example, if an effect specifies [] as the second argument but reads someProp inside, it will keep “seeing” the initial value of someProp. The solution is to either remove the dependency array, or to fix it. Here’s how you can deal with functions, and here’s other common strategies to run effects less often without incorrectly skipping dependencies.

We provide an exhaustive-deps ESLint rule as a part of the eslint-plugin-react-hooks package. It warns when dependencies are specified incorrectly and suggests a fix.

Q - What can I do if my effect dependencies change too often?

Sometimes, your effect may be using state that changes too often. You might be tempted to omit that state from a list of dependencies, but that usually leads to bugs:

function Counter() {
  const [count, setCount] = useState(0);

  useEffect(() => {
    const id = setInterval(() => {
      setCount(count + 1); // This effect depends on the `count` state    }, 1000);
    return () => clearInterval(id);
  }, []); // 🔴 Bug: `count` is not specified as a dependency
  return <h1>{count}</h1>;
}

The empty set of dependencies, [], means that the effect will only run once when the component mounts, and not on every re-render. The problem is that inside the setInterval callback, the value of count does not change, because we’ve created a closure with the value of count set to 0 as it was when the effect callback ran. Every second, this callback then calls setCount(0 + 1), so the count never goes above 1.

Specifying [count] as a list of dependencies would fix the bug, but would cause the interval to be reset on every change. Effectively, each setInterval would get one chance to execute before being cleared (similar to a setTimeout.) That may not be desirable. To fix this, we can use the functional update form of setState. It lets us specify how the state needs to change without referencing the current state:

function Counter() {
  const [count, setCount] = useState(0);

  useEffect(() => {
    const id = setInterval(() => {
      setCount(c => c + 1); // ✅ This doesn't depend on `count` variable outside    }, 1000);
    return () => clearInterval(id);
  }, []); // ✅ Our effect doesn't use any variables in the component scope
  return <h1>{count}</h1>;
}

(The identity of the setCount function is guaranteed to be stable so it’s safe to omit.)

Now, the setInterval callback executes once a second, but each time the inner call to setCount can use an up-to-date value for count (called c in the callback here.)

In more complex cases (such as if one state depends on another state), try moving the state update logic outside the effect with the useReducer Hook. This article offers an example of how you can do this. The identity of the dispatch function from useReducer is always stable — even if the reducer function is declared inside the component and reads its props.

As a last resort, if you want something like this in a class, you can use a ref to hold a mutable variable. Then you can write and read to it. For example:

function Example(props) {
  // Keep latest props in a ref.  let latestProps = useRef(props);  useEffect(() => {    latestProps.current = props;  });
  useEffect(() => {
    function tick() {
      // Read latest props at any time      console.log(latestProps.current);    }

    const id = setInterval(tick, 1000);
    return () => clearInterval(id);
  }, []); // This effect never re-runs}

Only do this if you couldn’t find a better alternative, as relying on mutation makes components less predictable. If there’s a specific pattern that doesn’t translate well, file an issue with a runnable example code and we can try to help.

Q - How do I implement `shouldComponentUpdate`?

You can wrap a function component with React.memo to shallowly compare its props:

const Button = React.memo((props) => {
  // your component
});

It’s not a Hook because it doesn’t compose like Hooks do. React.memo is equivalent to PureComponent, but it only compares props. (You can also add a second argument to specify a custom comparison function that takes the old and new props. If it returns true, the update is skipped.)

React.memo doesn’t compare state because there is no single state object to compare. But you can make children pure too, or even optimize individual children with useMemo.

Q - How to memoize calculations?

The useMemo Hook lets you cache calculations between multiple renders by “remembering” the previous computation:

const memoizedValue = useMemo(() => computeExpensiveValue(a, b), [a, b]);

This code calls computeExpensiveValue(a, b). But if the dependencies [a, b] haven’t changed since the last value, useMemo skips calling it a second time and simply reuses the last value it returned.

Remember that the function passed to useMemo runs during rendering. Don’t do anything there that you wouldn’t normally do while rendering. For example, side effects belong in useEffect, not useMemo.

You may rely on useMemo as a performance optimization, not as a semantic guarantee. In the future, React may choose to “forget” some previously memoized values and recalculate them on next render, e.g. to free memory for offscreen components. Write your code so that it still works without useMemo — and then add it to optimize performance. (For rare cases when a value must never be recomputed, you can lazily initialize a ref.)

Conveniently, useMemo also lets you skip an expensive re-render of a child:

function Parent({ a, b }) {
  // Only re-rendered if `a` changes:
  const child1 = useMemo(() => <Child1 a={a} />, [a]);
  // Only re-rendered if `b` changes:
  const child2 = useMemo(() => <Child2 b={b} />, [b]);
  return (
    <>
      {child1}
      {child2}
    </>
  )
}

Note that this approach won’t work in a loop because Hook calls can’t be placed inside loops. But you can extract a separate component for the list item, and call useMemo there.

Q - How to create expensive objects lazily?

useMemo lets you memoize an expensive calculation if the dependencies are the same. However, it only serves as a hint, and doesn’t guarantee the computation won’t re-run. But sometimes you need to be sure an object is only created once.

The first common use case is when creating the initial state is expensive:

function Table(props) {
  // ⚠️ createRows() is called on every render
  const [rows, setRows] = useState(createRows(props.count));
  // ...
}

To avoid re-creating the ignored initial state, we can pass a function to useState:

function Table(props) {
  // ✅ createRows() is only called once
  const [rows, setRows] = useState(() => createRows(props.count));
  // ...
}

React will only call this function during the first render. See the useState API reference.

You might also occasionally want to avoid re-creating the useRef() initial value. For example, maybe you want to ensure some imperative class instance only gets created once:

function Image(props) {
  // ⚠️ IntersectionObserver is created on every render
  const ref = useRef(new IntersectionObserver(onIntersect));
  // ...
}

useRef does not accept a special function overload like useState. Instead, you can write your own function that creates and sets it lazily:

function Image(props) {
  const ref = useRef(null);

  // ✅ IntersectionObserver is created lazily once
  function getObserver() {
    if (ref.current === null) {
      ref.current = new IntersectionObserver(onIntersect);
    }
    return ref.current;
  }

  // When you need it, call getObserver()
  // ...
}

This avoids creating an expensive object until it’s truly needed for the first time. If you use Flow or TypeScript, you can also give getObserver() a non-nullable type for convenience.

Q - Are Hooks slow because of creating functions in render?

No. In modern browsers, the raw performance of closures compared to classes doesn’t differ significantly except in extreme scenarios.

In addition, consider that the design of Hooks is more efficient in a couple ways:

Hooks avoid a lot of the overhead that classes require, like the cost of creating class instances and binding event handlers in the constructor.
Idiomatic code using Hooks doesn’t need the deep component tree nesting that is prevalent in codebases that use higher-order components, render props, and context. With smaller component trees, React has less work to do.

Traditionally, performance concerns around inline functions in React have been related to how passing new callbacks on each render breaks shouldComponentUpdate optimizations in child components. Hooks approach this problem from three sides.

The useCallback Hook lets you keep the same callback reference between re-renders so that shouldComponentUpdate continues to work:

// Will not change unless `a` or `b` changes
const memoizedCallback = useCallback(() => {  doSomething(a, b);
}, [a, b]);

The useMemo Hook makes it easier to control when individual children update, reducing the need for pure components.
Finally, the useReducer Hook reduces the need to pass callbacks deeply, as explained below.

Q - How to avoid passing callbacks down?

We’ve found that most people don’t enjoy manually passing callbacks through every level of a component tree. Even though it is more explicit, it can feel like a lot of “plumbing”.

In large component trees, an alternative we recommend is to pass down a dispatch function from useReducer via context:

const TodosDispatch = React.createContext(null);

function TodosApp() {
  // Note: `dispatch` won't change between re-renders  const [todos, dispatch] = useReducer(todosReducer);
  return (
    <TodosDispatch.Provider value={dispatch}>
      <DeepTree todos={todos} />
    </TodosDispatch.Provider>
  );
}

Any child in the tree inside TodosApp can use the dispatch function to pass actions up to TodosApp:

function DeepChild(props) {
  // If we want to perform an action, we can get dispatch from context.  const dispatch = useContext(TodosDispatch);
  function handleClick() {
    dispatch({ type: 'add', text: 'hello' });
  }

  return (
    <button onClick={handleClick}>Add todo</button>
  );
}

This is both more convenient from the maintenance perspective (no need to keep forwarding callbacks), and avoids the callback problem altogether. Passing dispatch down like this is the recommended pattern for deep updates.

Note that you can still choose whether to pass the application state down as props (more explicit) or as context (more convenient for very deep updates). If you use context to pass down the state too, use two different context types — the dispatch context never changes, so components that read it don’t need to rerender unless they also need the application state.

Q - How to read an often-changing value from `useCallback`?

Note

We recommend to pass dispatch down in context rather than individual callbacks in props. The approach below is only mentioned here for completeness and as an escape hatch.

Also note that this pattern might cause problems in the concurrent mode. We plan to provide more ergonomic alternatives in the future, but the safest solution right now is to always invalidate the callback if some value it depends on changes.

In some rare cases you might need to memoize a callback with useCallback but the memoization doesn’t work very well because the inner function has to be re-created too often. If the function you’re memoizing is an event handler and isn’t used during rendering, you can use ref as an instance variable, and save the last committed value into it manually:

function Form() {
  const [text, updateText] = useState('');
  const textRef = useRef();

  useEffect(() => {
    textRef.current = text; // Write it to the ref  });

  const handleSubmit = useCallback(() => {
    const currentText = textRef.current; // Read it from the ref    alert(currentText);
  }, [textRef]); // Don't recreate handleSubmit like [text] would do

  return (
    <>
      <input value={text} onChange={e => updateText(e.target.value)} />
      <ExpensiveTree onSubmit={handleSubmit} />
    </>
  );
}

This is a rather convoluted pattern but it shows that you can do this escape hatch optimization if you need it. It’s more bearable if you extract it to a custom Hook:

function Form() {
  const [text, updateText] = useState('');
  // Will be memoized even if `text` changes:
  const handleSubmit = useEventCallback(() => {    alert(text);
  }, [text]);

  return (
    <>
      <input value={text} onChange={e => updateText(e.target.value)} />
      <ExpensiveTree onSubmit={handleSubmit} />
    </>
  );
}

function useEventCallback(fn, dependencies) {  const ref = useRef(() => {
    throw new Error('Cannot call an event handler while rendering.');
  });

  useEffect(() => {
    ref.current = fn;
  }, [fn, ...dependencies]);

  return useCallback(() => {
    const fn = ref.current;
    return fn();
  }, [ref]);
}

In either case, we don’t recommend this pattern and only show it here for completeness. Instead, it is preferable to avoid passing callbacks deep down.

useState Hook

Q - Explain useState hook.

const [state, setState] = useState(initialState);

Returns a stateful value, and a function to update it.

During the initial render, the returned state (state) is the same as the value passed as the first argument (initialState).

The setState function is used to update the state. It accepts a new state value and enqueues a re-render of the component.

setState(newState);

During subsequent re-renders, the first value returned by useState will always be the most recent state after applying updates.

Note

React guarantees that setState function identity is stable and won’t change on re-renders. This is why it’s safe to omit from the useEffect or useCallback dependency list.

Q - How to do the functional updates with useState hook?

If the new state is computed using the previous state, you can pass a function to setState. The function will receive the previous value, and return an updated value. Here’s an example of a counter component that uses both forms of setState:

function Counter({initialCount}) {
  const [count, setCount] = useState(initialCount);
  return (
    <>
      Count: {count}
      <button onClick={() => setCount(initialCount)}>Reset</button>
      <button onClick={() => setCount(prevCount => prevCount + 1)}>+</button>
      <button onClick={() => setCount(prevCount => prevCount - 1)}>-</button>
    </>
  );
}

The ”+” and ”-” buttons use the functional form, because the updated value is based on the previous value. But the “Reset” button uses the normal form, because it always sets the count back to the initial value.

Note

Unlike the setState method found in class components, useState does not automatically merge update objects. You can replicate this behavior by combining the function updater form with object spread syntax:
setState(prevState => {
  // Object.assign would also work
  return {...prevState, ...updatedValues};
});
Another option is useReducer, which is more suited for managing state objects that contain multiple sub-values.

Q - How to set the initial state lazily with setState hook?

The initialState argument is the state used during the initial render. In subsequent renders, it is disregarded. If the initial state is the result of an expensive computation, you may provide a function instead, which will be executed only on the initial render:

const [state, setState] = useState(() => {
  const initialState = someExpensiveComputation(props);
  return initialState;
});

Q - Will React bail out of a state update if you update a State Hook to the same value as the current state?

If you update a State Hook to the same value as the current state, React will bail out without rendering the children or firing effects. (React uses the Object.is comparison algorithm.)

Note that React may still need to render that specific component again before bailing out. That shouldn’t be a concern because React won’t unnecessarily go “deeper” into the tree. If you’re doing expensive calculations while rendering, you can optimize them with useMemo.

useEffect Hook

Q - Explain useEffect hook.

useEffect(didUpdate);

Accepts a function that contains imperative, possibly effectful code.

Mutations, subscriptions, timers, logging, and other side effects are not allowed inside the main body of a function component (referred to as React’s render phase). Doing so will lead to confusing bugs and inconsistencies in the UI.

Instead, use useEffect. The function passed to useEffect will run after the render is committed to the screen. Think of effects as an escape hatch from React’s purely functional world into the imperative world.

By default, effects run after every completed render, but you can choose to fire it only when certain values have changed.

Q - How to clean up an effect?

Often, effects create resources that need to be cleaned up before the component leaves the screen, such as a subscription or timer ID. To do this, the function passed to useEffect may return a clean-up function. For example, to create a subscription:

useEffect(() => {
  const subscription = props.source.subscribe();
  return () => {
    // Clean up the subscription
    subscription.unsubscribe();
  };
});

The clean-up function runs before the component is removed from the UI to prevent memory leaks. Additionally, if a component renders multiple times (as they typically do), the previous effect is cleaned up before executing the next effect. In our example, this means a new subscription is created on every update. To avoid firing an effect on every update, refer to the next section.

Q - Explain the timing of effects such as the fact that useEffect is fired after layout and paint.

Unlike componentDidMount and componentDidUpdate, the function passed to useEffect fires after layout and paint, during a deferred event. This makes it suitable for the many common side effects, like setting up subscriptions and event handlers, because most types of work shouldn’t block the browser from updating the screen.

However, not all effects can be deferred. For example, a DOM mutation that is visible to the user must fire synchronously before the next paint so that the user does not perceive a visual inconsistency. (The distinction is conceptually similar to passive versus active event listeners.) For these types of effects, React provides one additional Hook called useLayoutEffect. It has the same signature as useEffect, and only differs in when it is fired.

Although useEffect is deferred until after the browser has painted, it’s guaranteed to fire before any new renders. React will always flush a previous render’s effects before starting a new update.

Q - How to conditionally fire an effect such as reacting to it’s dependencies change?

The default behavior for effects is to fire the effect after every completed render. That way an effect is always recreated if one of its dependencies changes.

However, this may be overkill in some cases, like the subscription example from the previous section. We don’t need to create a new subscription on every update, only if the source props has changed.

To implement this, pass a second argument to useEffect that is the array of values that the effect depends on. Our updated example now looks like this:

useEffect(
  () => {
    const subscription = props.source.subscribe();
    return () => {
      subscription.unsubscribe();
    };
  },
  [props.source],
);

Now the subscription will only be recreated when props.source changes.

Note

If you use this optimization, make sure the array includes all values from the component scope (such as props and state) that change over time and that are used by the effect. Otherwise, your code will reference stale values from previous renders. Learn more about how to deal with functions and what to do when the array values change too often.

If you want to run an effect and clean it up only once (on mount and unmount), you can pass an empty array ([]) as a second argument. This tells React that your effect doesn’t depend on any values from props or state, so it never needs to re-run. This isn’t handled as a special case — it follows directly from how the dependencies array always works.

If you pass an empty array ([]), the props and state as inside the effect will always have their initial values. While passing [] as the second argument is closer to the familiar componentDidMount and componentWillUnmount mental model, there are usually better solutions to avoid re-running effects too often. Also, don’t forget that React defers running useEffect until after the browser has painted, so doing extra work is less of a problem.

We recommend using the exhaustive-deps rule as part of our eslint-plugin-react-hooks package. It warns when dependencies are specified incorrectly and suggests a fix.

The array of dependencies is not passed as arguments to the effect function. Conceptually, though, that’s what they represent: every value referenced inside the effect function should also appear in the dependencies array. In the future, a sufficiently advanced compiler could create this array automatically.

Q - If you only use some functions inside an effect, why you should move them directly into that effect?

Reference - https://overreacted.io/a-complete-guide-to-useeffect/#moving-functions-inside-effects

A common mistake is to think functions shouldn’t be dependencies. For example, this seems like it could work:

function SearchResults() {
  const [data, setData] = useState({ hits: [] });

  async function fetchData() {
    const result = await axios(
      'https://hn.algolia.com/api/v1/search?query=react',
    );
    setData(result.data);
  }

  useEffect(() => {
    fetchData();
  }, []); // Is this okay?
  // ...

(This example is adapted from a great article by Robin Wieruch — check it out!)

And to be clear, this code does work. But the problem with simply omitting local functions is that it gets pretty hard to tell whether we’re handling all cases as the component grows!

Imagine our code was split like this and each function was five times larger:

function SearchResults() {
  // Imagine this function is long
  function getFetchUrl() {
    return 'https://hn.algolia.com/api/v1/search?query=react';
  }

  // Imagine this function is also long
  async function fetchData() {
    const result = await axios(getFetchUrl());
    setData(result.data);
  }

  useEffect(() => {
    fetchData();
  }, []);

  // ...
}

Now let’s say we later use some state or prop in one of these functions:

function SearchResults() {
  const [query, setQuery] = useState('react');

  // Imagine this function is also long
  function getFetchUrl() {
    return 'https://hn.algolia.com/api/v1/search?query=' + query;  }

  // Imagine this function is also long
  async function fetchData() {
    const result = await axios(getFetchUrl());
    setData(result.data);
  }

  useEffect(() => {
    fetchData();
  }, []);

  // ...
}

If we forget to update the deps of any effects that call these functions (possibly, through other functions!), our effects will fail to synchronize changes from our props and state. This doesn’t sound great.

Luckily, there is an easy solution to this problem. If you only use some functions inside an effect, move them directly into that effect:

function SearchResults() {
  // ...
  useEffect(() => {
    // We moved these functions inside!    function getFetchUrl() {      return 'https://hn.algolia.com/api/v1/search?query=react';    }    async function fetchData() {      const result = await axios(getFetchUrl());      setData(result.data);    }
    fetchData();
  }, []); // ✅ Deps are OK
  // ...
}

(Here’s a demo.)

So what is the benefit? We no longer have to think about the “transitive dependencies”. Our dependencies array isn’t lying anymore: we truly aren’t using anything from the outer scope of the component in our effect.

If we later edit getFetchUrl to use the query state, we’re much more likely to notice that we’re editing it inside an effect — and therefore, we need to add query to the effect dependencies:

function SearchResults() {
  const [query, setQuery] = useState('react');

  useEffect(() => {
    function getFetchUrl() {
      return 'https://hn.algolia.com/api/v1/search?query=' + query;    }

    async function fetchData() {
      const result = await axios(getFetchUrl());
      setData(result.data);
    }

    fetchData();
  }, [query]); // ✅ Deps are OK
  // ...
}

(Here’s a demo.)

By adding this dependency, we’re not just “appeasing React”. It makes sense to refetch the data when the query changes. The design of useEffect forces you to notice the change in our data flow and choose how our effects should synchronize it — instead of ignoring it until our product users hit a bug.

Thanks to the exhaustive-deps lint rule from the eslint-plugin-react-hooks plugin, you can analyze the effects as you type in your editor and receive suggestions about which dependencies are missing. In other words, a machine can tell you which data flow changes aren’t handled correctly by a component.

Pretty sweet.

Q - What are the solutions, if you can’t put a function inside an effect?

Note - This is a follow up question of “Q - If you only use some functions inside an effect, why you should move them directly into that effect?”

Reference - https://overreacted.io/a-complete-guide-to-useeffect/#but-i-cant-put-this-function-inside-an-effect

Sometimes you might not want to move a function inside an effect. For example, several effects in the same component may call the same function, and you don’t want to copy and paste its logic. Or maybe it’s a prop.

Should you skip a function like this in the effect dependencies? I think not. Again, effects shouldn’t lie about their dependencies. There are usually better solutions. A common misconception is that “a function would never change”. But as we learned throughout this article, this couldn’t be further from truth. Indeed, a function defined inside a component changes on every render!

That by itself presents a problem. Say two effects call getFetchUrl:

function SearchResults() {
  function getFetchUrl(query) {
    return 'https://hn.algolia.com/api/v1/search?query=' + query;
  }

  useEffect(() => {
    const url = getFetchUrl('react');
    // ... Fetch data and do something ...
  }, []); // 🔴 Missing dep: getFetchUrl

  useEffect(() => {
    const url = getFetchUrl('redux');
    // ... Fetch data and do something ...
  }, []); // 🔴 Missing dep: getFetchUrl

  // ...
}

In that case you might not want to move getFetchUrl inside either of the effects since you wouldn’t be able to share the logic.

On the other hand, if you’re “honest” about the effect dependencies, you may run into a problem. Since both our effects depend on getFetchUrl (which is different on every render), our dependency arrays are useless:

function SearchResults() {
  // 🔴 Re-triggers all effects on every render  function getFetchUrl(query) {    return 'https://hn.algolia.com/api/v1/search?query=' + query;  }
  useEffect(() => {
    const url = getFetchUrl('react');
    // ... Fetch data and do something ...
  }, [getFetchUrl]); // 🚧 Deps are correct but they change too often

  useEffect(() => {
    const url = getFetchUrl('redux');
    // ... Fetch data and do something ...
  }, [getFetchUrl]); // 🚧 Deps are correct but they change too often

  // ...
}

A tempting solution to this is to just skip the getFetchUrl function in the deps list. However, I don’t think it’s a good solution. This makes it difficult to notice when we are adding a change to the data flow that needs to be handled by an effect. This leads to bugs like the “never updating interval” we saw earlier.

Instead, there are two other solutions that are simpler.

First of all, if a function doesn’t use anything from the component scope, you can hoist it outside the component and then freely use it inside your effects:

// ✅ Not affected by the data flowfunction getFetchUrl(query) {  return 'https://hn.algolia.com/api/v1/search?query=' + query;}
function SearchResults() {
  useEffect(() => {
    const url = getFetchUrl('react');
    // ... Fetch data and do something ...
  }, []); // ✅ Deps are OK

  useEffect(() => {
    const url = getFetchUrl('redux');
    // ... Fetch data and do something ...
  }, []); // ✅ Deps are OK

  // ...
}

There’s no need to specify it in deps because it’s not in the render scope and can’t be affected by the data flow. It can’t accidentally depend on props or state.

Alternatively, you can wrap it into the useCallback Hook:

function SearchResults() {
  // ✅ Preserves identity when its own deps are the same  const getFetchUrl = useCallback((query) => {    return 'https://hn.algolia.com/api/v1/search?query=' + query;  }, []);  // ✅ Callback deps are OK
  useEffect(() => {
    const url = getFetchUrl('react');
    // ... Fetch data and do something ...
  }, [getFetchUrl]); // ✅ Effect deps are OK

  useEffect(() => {
    const url = getFetchUrl('redux');
    // ... Fetch data and do something ...
  }, [getFetchUrl]); // ✅ Effect deps are OK

  // ...
}

useCallback is essentially like adding another layer of dependency checks. It’s solving the problem on the other end — rather than avoid a function dependency, we make the function itself only change when necessary.

Let’s see why this approach is useful. Previously, our example showed two search results (for 'react' and 'redux' search queries). But let’s say we want to add an input so that you can search for an arbitrary query. So instead of taking query as an argument, getFetchUrl will now read it from local state.

We’ll immediately see that it’s missing a query dependency:

function SearchResults() {
  const [query, setQuery] = useState('react');
  const getFetchUrl = useCallback(() => { // No query argument
    return 'https://hn.algolia.com/api/v1/search?query=' + query;
  }, []); // 🔴 Missing dep: query  // ...
}

If I fix my useCallback deps to include query, any effect with getFetchUrl in deps will re-run whenever the query changes:

function SearchResults() {
  const [query, setQuery] = useState('react');

  // ✅ Preserves identity until query changes  const getFetchUrl = useCallback(() => {    return 'https://hn.algolia.com/api/v1/search?query=' + query;  }, [query]);  // ✅ Callback deps are OK
  useEffect(() => {
    const url = getFetchUrl();
    // ... Fetch data and do something ...
  }, [getFetchUrl]); // ✅ Effect deps are OK

  // ...
}

Thanks to useCallback, if query is the same, getFetchUrl also stays the same, and our effect doesn’t re-run. But if query changes, getFetchUrl will also change, and we will re-fetch the data. It’s a lot like when you change some cell in an Excel spreadsheet, and the other cells using it recalculate automatically.

This is just a consequence of embracing the data flow and the synchronization mindset. The same solution works for function props passed from parents:

function Parent() {
  const [query, setQuery] = useState('react');

  // ✅ Preserves identity until query changes  const fetchData = useCallback(() => {    const url = 'https://hn.algolia.com/api/v1/search?query=' + query;    // ... Fetch data and return it ...  }, [query]);  // ✅ Callback deps are OK
  return <Child fetchData={fetchData} />
}

function Child({ fetchData }) {
  let [data, setData] = useState(null);

  useEffect(() => {
    fetchData().then(setData);
  }, [fetchData]); // ✅ Effect deps are OK

  // ...
}

Since fetchData only changes inside Parent when its query state changes, our Child won’t refetch the data until it’s actually necessary for the app.

Q - Is it safe to omit functions from the list of dependencies?

Note

This is another explanations for the same questions of ‘Q - If you only use some functions inside an effect, why you should move them directly into that effect?’ and ‘Q - What are the solutions, if you can’t put a function inside an effect?’

Reference - https://reactjs.org/docs/hooks-faq.html#is-it-safe-to-omit-functions-from-the-list-of-dependencies

Generally speaking, no.

function Example({ someProp }) {
  function doSomething() {
    console.log(someProp);  }

  useEffect(() => {
    doSomething();
  }, []); // 🔴 This is not safe (it calls `doSomething` which uses `someProp`)}

It’s difficult to remember which props or state are used by functions outside of the effect. This is why usually you’ll want to declare functions needed by an effect inside of it. Then it’s easy to see what values from the component scope that effect depends on:

function Example({ someProp }) {
  useEffect(() => {
    function doSomething() {
      console.log(someProp);    }

    doSomething();
  }, [someProp]); // ✅ OK (our effect only uses `someProp`)}

If after that we still don’t use any values from the component scope, it’s safe to specify []:

useEffect(() => {
  function doSomething() {
    console.log('hello');
  }

  doSomething();
}, []); // ✅ OK in this example because we don't use *any* values from component scope

Depending on your use case, there are a few more options described below.

Note

We provide the exhaustive-deps ESLint rule as a part of the eslint-plugin-react-hooks package. It helps you find components that don’t handle updates consistently.

Let’s see why this matters.

If you specify a list of dependencies as the last argument to useEffect, useMemo, useCallback, or useImperativeHandle, it must include all values used inside that participate in the React data flow. That includes props, state, and anything derived from them.

It is only safe to omit a function from the dependency list if nothing in it (or the functions called by it) references props, state, or values derived from them. This example has a bug:

function ProductPage({ productId }) {
  const [product, setProduct] = useState(null);

  async function fetchProduct() {
    const response = await fetch('http://myapi/product' + productId); // Uses productId prop    const json = await response.json();
    setProduct(json);
  }

  useEffect(() => {
    fetchProduct();
  }, []); // 🔴 Invalid because `fetchProduct` uses `productId`  // ...
}

The recommended fix is to move that function inside of your effect. That makes it easy to see which props or state your effect uses, and to ensure they’re all declared:

function ProductPage({ productId }) {
  const [product, setProduct] = useState(null);

  useEffect(() => {
    // By moving this function inside the effect, we can clearly see the values it uses.    async function fetchProduct() {      const response = await fetch('http://myapi/product' + productId);      const json = await response.json();      setProduct(json);    }
    fetchProduct();
  }, [productId]); // ✅ Valid because our effect only uses productId  // ...
}

This also allows you to handle out-of-order responses with a local variable inside the effect:

  useEffect(() => {
    let ignore = false;    async function fetchProduct() {
      const response = await fetch('http://myapi/product/' + productId);
      const json = await response.json();
      if (!ignore) setProduct(json);    }

    fetchProduct();
    return () => { ignore = true };  }, [productId]);

We moved the function inside the effect so it doesn’t need to be in its dependency list.

Tip

Check out this small demo and this article to learn more about data fetching with Hooks.

If for some reason you can’t move a function inside an effect, there are a few more options:

You can try moving that function outside of your component. In that case, the function is guaranteed to not reference any props or state, and also doesn’t need to be in the list of dependencies.
If the function you’re calling is a pure computation and is safe to call while rendering, you may call it outside of the effect instead, and make the effect depend on the returned value.
As a last resort, you can add a function to effect dependencies but wrap its definition into the useCallback Hook. This ensures it doesn’t change on every render unless its own dependencies also change:

function ProductPage({ productId }) {
  // ✅ Wrap with useCallback to avoid change on every render  const fetchProduct = useCallback(() => {    // ... Does something with productId ...  }, [productId]); // ✅ All useCallback dependencies are specified
  return <ProductDetails fetchProduct={fetchProduct} />;
}

function ProductDetails({ fetchProduct })
  useEffect(() => {
    fetchProduct();
  }, [fetchProduct]); // ✅ All useEffect dependencies are specified
  // ...
}

Note that in the above example we need to keep the function in the dependencies list. This ensures that a change in the productId prop of ProductPage automatically triggers a refetch in the ProductDetails component.

useContext hook

Q - Explain useContext hook.

const value = useContext(MyContext);

Accepts a context object (the value returned from React.createContext) and returns the current context value for that context. The current context value is determined by the value prop of the nearest <MyContext.Provider> above the calling component in the tree.

When the nearest <MyContext.Provider> above the component updates, this Hook will trigger a rerender with the latest context value passed to that MyContext provider.

Don’t forget that the argument to useContext must be the context object itself:

Correct: useContext(MyContext)
Incorrect: useContext(MyContext.Consumer)
Incorrect: useContext(MyContext.Provider)

A component calling useContext will always re-render when the context value changes. If re-rendering the component is expensive, you can optimize it by using memoization.

Tip

If you’re familiar with the context API before Hooks, useContext(MyContext) is equivalent to static contextType = MyContext in a class, or to <MyContext.Consumer>.

useContext(MyContext) only lets you read the context and subscribe to its changes. You still need a <MyContext.Provider> above in the tree to provide the value for this context.

useReducer hook

Q - Explain useReducer hook.

const [state, dispatch] = useReducer(reducer, initialArg, init);

An alternative to useState. Accepts a reducer of type (state, action) => newState, and returns the current state paired with a dispatch method. (If you’re familiar with Redux, you already know how this works.)

useReducer is usually preferable to useState when you have complex state logic that involves multiple sub-values or when the next state depends on the previous one. useReducer also lets you optimize performance for components that trigger deep updates because you can pass dispatch down instead of callbacks.

Here’s the counter example from the useState section, rewritten to use a reducer:

const initialState = {count: 0};

function reducer(state, action) {
  switch (action.type) {
    case 'increment':
      return {count: state.count + 1};
    case 'decrement':
      return {count: state.count - 1};
    default:
      throw new Error();
  }
}

function Counter() {
  const [state, dispatch] = useReducer(reducer, initialState);
  return (
    <>
      Count: {state.count}
      <button onClick={() => dispatch({type: 'increment'})}>+</button>
      <button onClick={() => dispatch({type: 'decrement'})}>-</button>
    </>
  );
}

Note

React guarantees that dispatch function identity is stable and won’t change on re-renders. This is why it’s safe to omit from the useEffect or useCallback dependency list.

Q - How to specify the initial state in useReducer hook?

There are two different ways to initialize useReducer state. You may choose either one depending on the use case. The simplest way is to pass the initial state as a second argument:

  const [state, dispatch] = useReducer(
    reducer,
    {count: initialCount}  );

Note

React doesn’t use the state = initialState argument convention popularized by Redux. The initial value sometimes needs to depend on props and so is specified from the Hook call instead. If you feel strongly about this, you can call useReducer(reducer, undefined, reducer) to emulate the Redux behavior, but it’s not encouraged.

Q - How to do the lazy initialization in useReducer hook?

You can also create the initial state lazily. To do this, you can pass an init function as the third argument. The initial state will be set to init(initialArg).

It lets you extract the logic for calculating the initial state outside the reducer. This is also handy for resetting the state later in response to an action:

function init(initialCount) {  return {count: initialCount};}
function reducer(state, action) {
  switch (action.type) {
    case 'increment':
      return {count: state.count + 1};
    case 'decrement':
      return {count: state.count - 1};
    case 'reset':      return init(action.payload);    default:
      throw new Error();
  }
}

function Counter({initialCount}) {
  const [state, dispatch] = useReducer(reducer, initialCount, init);  return (
    <>
      Count: {state.count}
      <button
        onClick={() => dispatch({type: 'reset', payload: initialCount})}>        Reset
      </button>
      <button onClick={() => dispatch({type: 'increment'})}>+</button>
      <button onClick={() => dispatch({type: 'decrement'})}>-</button>
    </>
  );
}

Q - Will React bail out without rendering, if you return the same value from a useReducer Hook as the current state?

If you return the same value from a Reducer Hook as the current state, React will bail out without rendering the children or firing effects. (React uses the Object.is comparison algorithm.)

useCallback hook

Q - Explain useCallback hook.

const memoizedCallback = useCallback(
  () => {
    doSomething(a, b);
  },
  [a, b],
);

Returns a memoized callback.

Pass an inline callback and an array of dependencies. useCallback will return a memoized version of the callback that only changes if one of the dependencies has changed. This is useful when passing callbacks to optimized child components that rely on reference equality to prevent unnecessary renders (e.g. shouldComponentUpdate).

useCallback(fn, deps) is equivalent to useMemo(() => fn, deps).

Note

The array of dependencies is not passed as arguments to the callback. Conceptually, though, that’s what they represent: every value referenced inside the callback should also appear in the dependencies array. In the future, a sufficiently advanced compiler could create this array automatically.

We recommend using the exhaustive-deps rule as part of our eslint-plugin-react-hooks package. It warns when dependencies are specified incorrectly and suggests a fix.

useMemo hook

Q - Explain useMemo hook.

const memoizedValue = useMemo(() => computeExpensiveValue(a, b), [a, b]);

Returns a memoized value.

Pass a “create” function and an array of dependencies. useMemo will only recompute the memoized value when one of the dependencies has changed. This optimization helps to avoid expensive calculations on every render.

If no array is provided, a new value will be computed on every render.

Note

The array of dependencies is not passed as arguments to the function. Conceptually, though, that’s what they represent: every value referenced inside the function should also appear in the dependencies array. In the future, a sufficiently advanced compiler could create this array automatically.

We recommend using the exhaustive-deps rule as part of our eslint-plugin-react-hooks package. It warns when dependencies are specified incorrectly and suggests a fix.

useRef hook

Q - Explain useRef hook.

const refContainer = useRef(initialValue);

useRef returns a mutable ref object whose .current property is initialized to the passed argument (initialValue). The returned object will persist for the full lifetime of the component.

A common use case is to access a child imperatively:

function TextInputWithFocusButton() {
  const inputEl = useRef(null);
  const onButtonClick = () => {
    // `current` points to the mounted text input element
    inputEl.current.focus();
  };
  return (
    <>
      <input ref={inputEl} type="text" />
      <button onClick={onButtonClick}>Focus the input</button>
    </>
  );
}

Essentially, useRef is like a “box” that can hold a mutable value in its .current property.

You might be familiar with refs primarily as a way to access the DOM. If you pass a ref object to React with <div ref={myRef} />, React will set its .current property to the corresponding DOM node whenever that node changes.

However, useRef() is useful for more than the ref attribute. It’s handy for keeping any mutable value around similar to how you’d use instance fields in classes.

This works because useRef() creates a plain JavaScript object. The only difference between useRef() and creating a {current: ...} object yourself is that useRef will give you the same ref object on every render.

Keep in mind that useRef doesn’t notify you when its content changes. Mutating the .current property doesn’t cause a re-render. If you want to run some code when React attaches or detaches a ref to a DOM node, you may want to use a callback ref instead.

Q - Is there something like instance variables?

Yes! The useRef() Hook isn’t just for DOM refs. The “ref” object is a generic container whose current property is mutable and can hold any value, similar to an instance property on a class.

You can write to it from inside useEffect:

function Timer() {
  const intervalRef = useRef();
  useEffect(() => {
    const id = setInterval(() => {
      // ...
    });
    intervalRef.current = id;    return () => {
      clearInterval(intervalRef.current);
    };
  });

  // ...
}

If we just wanted to set an interval, we wouldn’t need the ref (id could be local to the effect), but it’s useful if we want to clear the interval from an event handler:

// ...
function handleCancelClick() {
  clearInterval(intervalRef.current);}
// ...

Conceptually, you can think of refs as similar to instance variables in a class. Unless you’re doing lazy initialization, avoid setting refs during rendering — this can lead to surprising behavior. Instead, typically you want to modify refs in event handlers and effects.

Q - How can I measure a DOM node?

In order to measure the position or size of a DOM node, you can use a callback ref. React will call that callback whenever the ref gets attached to a different node. Here is a small demo:

function MeasureExample() {
  const [height, setHeight] = useState(0);

  const measuredRef = useCallback(node => {    if (node !== null) {      setHeight(node.getBoundingClientRect().height);    }  }, []);
  return (
    <>
      <h1 ref={measuredRef}>Hello, world</h1>      <h2>The above header is {Math.round(height)}px tall</h2>
    </>
  );
}

We didn’t choose useRef in this example because an object ref doesn’t notify us about changes to the current ref value. Using a callback ref ensures that even if a child component displays the measured node later (e.g. in response to a click), we still get notified about it in the parent component and can update the measurements.

Note that we pass [] as a dependency array to useCallback. This ensures that our ref callback doesn’t change between the re-renders, and so React won’t call it unnecessarily.

If you want, you can extract this logic into a reusable Hook:

function MeasureExample() {
  const [rect, ref] = useClientRect();  return (
    <>
      <h1 ref={ref}>Hello, world</h1>
      {rect !== null &&
        <h2>The above header is {Math.round(rect.height)}px tall</h2>
      }
    </>
  );
}

function useClientRect() {
  const [rect, setRect] = useState(null);
  const ref = useCallback(node => {
    if (node !== null) {
      setRect(node.getBoundingClientRect());
    }
  }, []);
  return [rect, ref];
}

useImperativeHandle hook

Q - Explain useImperativeHandle hook.

useImperativeHandle(ref, createHandle, [deps])

useImperativeHandle customizes the instance value that is exposed to parent components when using ref. As always, imperative code using refs should be avoided in most cases. useImperativeHandle should be used with forwardRef:

function FancyInput(props, ref) {
  const inputRef = useRef();
  useImperativeHandle(ref, () => ({
    focus: () => {
      inputRef.current.focus();
    }
  }));
  return <input ref={inputRef} ... />;
}
FancyInput = forwardRef(FancyInput);

In this example, a parent component that renders <FancyInput ref={fancyInputRef} /> would be able to call fancyInputRef.current.focus().

useDeferredValue hook

useDeferredValue accepts a value and returns a new copy of the value that will defer to more urgent updates. If the current render is the result of an urgent update, like user input, React will return the previous value and then render the new value after the urgent render has completed.
This hook is similar to user-space hooks which use debouncing or throttling to defer updates. The benefits to using useDeferredValue is that React will work on the update as soon as other work finishes (instead of waiting for an arbitrary amount of time), and like startTransition, deferred values can suspend without triggering an unexpected fallback for existing content.
useDeferredValue is mainly useful when the value comes from above and you don’t actually have control over the corresponding setState call that is related to the laggish behaviour. If we do have control over it, using startTransition and the useTransition Hook in general is preferable as it’s seems.

const deferredValue = useDeferredValue(value);

Memoizing deferred children

useDeferredValue only defers the value that you pass to it. If you want to prevent a child component from re-rendering during an urgent update, you must also memoize that component with React.memo or React.useMemo:

function Typeahead() {
  const query = useSearchQuery('');
  const deferredQuery = useDeferredValue(query);

  // Memoizing tells React to only re-render when deferredQuery changes,
  // not when query changes.
  const suggestions = useMemo(() =>
    <SearchSuggestions query={deferredQuery} />,
    [deferredQuery]
  );

  return (
    <>
      <SearchInput query={query} />
      <Suspense fallback="Loading results...">
        {suggestions}
      </Suspense>
    </>
  );
}

Q - Which versions of React include Hooks?

Starting with 16.8.0, React includes a stable implementation of React Hooks for:

React DOM
React Native
React DOM Server
React Test Renderer
React Shallow Renderer

Note that to enable Hooks, all React packages need to be 16.8.0 or higher. Hooks won’t work if you forget to update, for example, React DOM.

React Native 0.59 and above support Hooks.

Q - What can I do with Hooks that I couldn’t with classes?

Q - Should I use Hooks, classes, or a mix of both?

Q - Do Hooks cover all use cases for classes?

Q - Do Hooks replace render props and higher-order components?

Q - What exactly do the lint rules enforce?

In particular, the rule enforces that:

Calls to Hooks are either inside a PascalCase function (assumed to be a component) or another useSomething function (assumed to be a custom Hook).
Hooks are called in the same order on every render.
There are a few more heuristics, and they might change over time as we fine-tune the rule to balance finding bugs with avoiding false positives.

From Classes to Hooks

Q - How do lifecycle methods correspond to Hooks?

constructor: Function components don’t need a constructor. You can initialize the state in the useState call. If computing the initial state is expensive, you can pass a function to useState.
getDerivedStateFromProps: Schedule an update while rendering instead.
shouldComponentUpdate: See React.memo below.
render: This is the function component body itself.
componentDidMount, componentDidUpdate, componentWillUnmount: The useEffect Hook can express all combinations of these (including less common cases).
componentDidCatch and getDerivedStateFromError: There are no Hook equivalents for these methods yet, but they will be added soon.

Q - How can I do data fetching with Hooks?

Here is a small demo to get you started. To learn more, check out this article about data fetching with Hooks.

Q - Should I use one or many state variables?

function Box() {
  const [state, setState] = useState({ left: 0, top: 0, width: 100, height: 100 });
  // ...
}

Now let’s say we want to write some logic that changes left and top when the user moves their mouse. Note how we have to merge these fields into the previous state object manually:

  // ...
  useEffect(() => {
    function handleWindowMouseMove(e) {
      // Spreading "...state" ensures we don't "lose" width and height      setState(state => ({ ...state, left: e.pageX, top: e.pageY }));    }
    // Note: this implementation is a bit simplified
    window.addEventListener('mousemove', handleWindowMouseMove);
    return () => window.removeEventListener('mousemove', handleWindowMouseMove);
  }, []);
  // ...

This is because when we update a state variable, we replace its value. This is different from this.setState in a class, which merges the updated fields into the object.

For example, we could split our component state into position and size objects, and always replace the position with no need for merging:

function Box() {
  const [position, setPosition] = useState({ left: 0, top: 0 });  const [size, setSize] = useState({ width: 100, height: 100 });

  useEffect(() => {
    function handleWindowMouseMove(e) {
      setPosition({ left: e.pageX, top: e.pageY });    }
    // ...

Separating independent state variables also has another benefit. It makes it easy to later extract some related logic into a custom Hook, for example:

function Box() {
  const position = useWindowPosition();  const [size, setSize] = useState({ width: 100, height: 100 });
  // ...
}

function useWindowPosition() {  const [position, setPosition] = useState({ left: 0, top: 0 });
  useEffect(() => {
    // ...
  }, []);
  return position;
}

Q - Can I run an effect only on updates?

Q - How to get the previous props or state?

Currently, you can do it manually with a ref:

function Counter() {
  const [count, setCount] = useState(0);

  const prevCountRef = useRef();
  useEffect(() => {
    prevCountRef.current = count;  });
  const prevCount = prevCountRef.current;
  return <h1>Now: {count}, before: {prevCount}</h1>;
}

This might be a bit convoluted but you can extract it into a custom Hook:

function Counter() {
  const [count, setCount] = useState(0);
  const prevCount = usePrevious(count);  return <h1>Now: {count}, before: {prevCount}</h1>;
}

function usePrevious(value) {  const ref = useRef();
  useEffect(() => {
    ref.current = value;
  });
  return ref.current;
}

Note how this would work for props, state, or any other calculated value.

function Counter() {
  const [count, setCount] = useState(0);

  const calculation = count * 100;
  const prevCalculation = usePrevious(calculation);  // ...

It’s possible that in the future React will provide a usePrevious Hook out of the box since it’s a relatively common use case.

Q - Why am I seeing stale props or state inside my function?

Any function inside a component, including event handlers and effects, “sees” the props and state from the render it was created in. For example, consider code like this:

function Example() {
  const [count, setCount] = useState(0);

  function handleAlertClick() {
    setTimeout(() => {
      alert('You clicked on: ' + count);
    }, 3000);
  }

  return (
    <div>
      <p>You clicked {count} times</p>
      <button onClick={() => setCount(count + 1)}>
        Click me
      </button>
      <button onClick={handleAlertClick}>
        Show alert
      </button>
    </div>
  );
}

If you intentionally want to read the latest state from some asynchronous callback, you could keep it in a ref, mutate it, and read from it.

We provide an exhaustive-deps ESLint rule as a part of the eslint-plugin-react-hooks package. It warns when dependencies are specified incorrectly and suggests a fix.

Q - What can I do if my effect dependencies change too often?

Sometimes, your effect may be using state that changes too often. You might be tempted to omit that state from a list of dependencies, but that usually leads to bugs:

function Counter() {
  const [count, setCount] = useState(0);

  useEffect(() => {
    const id = setInterval(() => {
      setCount(count + 1); // This effect depends on the `count` state    }, 1000);
    return () => clearInterval(id);
  }, []); // 🔴 Bug: `count` is not specified as a dependency
  return <h1>{count}</h1>;
}

(This is an article posted to my blog at overreacted.io. You can read it online by clicking here.)

Patterns

Sat, 23 Apr 2022 00:00:00 GMT

Patterns
- Q - Explain Observer Pattern in React.
- Q - Explain Provider Pattern in React.

Patterns

Q - Explain Observer Pattern in React.

https://medium.com/javascript-in-plain-english/programming-patterns-with-react-hooks-329c22b96461

Q - Explain Provider Pattern in React.

https://medium.com/javascript-in-plain-english/programming-patterns-with-react-hooks-329c22b96461

(This is an article posted to my blog at overreacted.io. You can read it online by clicking here.)

Transitions

Sat, 23 Apr 2022 00:00:00 GMT

Introduction
Transition APIs
- React.startTransition
- React.useTransition

Introduction

Transitions are a new concurrent feature introduced in React 18.
They allow you to mark updates as transitions, which tells React that they can be interrupted and avoid going back to Suspense fallbacks for already visible content.

Transition APIs

React.startTransition

React.startTransition(callback)

React.startTransition lets you mark updates inside the provided callback as transitions.
This method is designed to be used when React.useTransition is not available for example in class based components.
React.startTransition does not provide an isPending flag. To track the pending status of a transition see React.useTransition.

React.useTransition

const [isPending, startTransition] = useTransition();

Returns a stateful value for the pending state of the transition, and a function to start it.
startTransition lets you mark updates in the provided callback as transitions:
The idea is that you can wrap state updates with startTransition, if they should be treated with a lower priority. For example, inside of that function, you perform your logic especially your state updating logic that should be treated with a lower priority.

startTransition(() => {
  setCount(count + 1);
})

isPending indicates when a transition is active to show a pending state.
you could use isPending to update the UI, to show some fallback content whilst you’re waiting for the main state update to complete.

function App() {
  const [isPending, startTransition] = useTransition();
  const [count, setCount] = useState(0);
  
  function handleClick() {
    startTransition(() => {
      setCount(c => c + 1);
    })
  }

  return (
    <div>
      {isPending && <Spinner />}
      <button onClick={handleClick}>{count}</button>
    </div>
  );
}

(This is an article posted to my blog at overreacted.io. You can read it online by clicking here.)

Web Components with React

Sat, 23 Apr 2022 00:00:00 GMT

Introduction
Using Web Components in React

Introduction

Web Components provide strong encapsulation for reusable components, while React provides a declarative library that keeps the DOM in sync with your data.
As a developer, you are free to use React in your Web Components, or to use Web Components in React, or both.

Using Web Components in React

class HelloMessage extends React.Component {
  render() {
    return <div>Hello <x-search>{this.props.name}</x-search>!</div>;
  }
}

A video Web Component might expose play() and pause() functions. To access the imperative APIs of a Web Component, you will need to use a ref to interact with the DOM node directly.
If you are using third-party Web Components, the best solution is to write a React component that behaves as a wrapper for your Web Component.
Events emitted by a Web Component may not properly propagate through a React render tree. You will need to manually attach event handlers to handle these events within your React components.

(This is an article posted to my blog at overreacted.io. You can read it online by clicking here.)

Helm

Fri, 22 Apr 2022 00:00:00 GMT

What is Helm?
What is Helm Chart?
- Helm Chart Structure
- Value injection to template files
Helm as Template Engine

What is Helm?

Helm is a tool that streamlines installing and managing Kubernetes applications. It is a package manager for Kubernetes. Think of it like apt/yum/homebrew for Kubernetes.
Convenient way for packaging kubernetes yaml files and distributing them in private and public repositories.
Helm renders your templates and communicates with the Kubernetes API

What is Helm Chart?

Charts are Helm packages that contain at least two things:
- A description of the package (Chart.yaml)
- One or more templates, which contain Kubernetes manifest files
Charts can be stored on disk, or fetched from remote chart repositories (like Debian or RedHat packages)

Helm Chart Structure

Top level mychart folder - name of chart
chart.yaml - Meta info about chart like name, version, dependencies, etc.
values.yaml - Values for template files. Default values which you can override later.
charts folder - chart dependencies. If this chart depend on other charts, those chart dependencies will be stored here
templates folder - The actual template files. When execute helm install <chartname> command, template files will be filled with the values from values.yaml producing valid kubernetes manifest

Value injection to template files

Override the default values using file.

helm install --values=my-values.yaml <chartname>

Override the values using command line flag

helm install --set version=2.0.0

Helm as Template Engine

Helm acts as a templating engine.
Define a common blueprint.
Dynamic values are replaced by placeholders. Values are taken from external coniguration named values.yaml or with --set flag

(This is an article posted to my blog at overreacted.io. You can read it online by clicking here.)

Kubernetes Jobs

Fri, 22 Apr 2022 00:00:00 GMT

Introduction to jobs
Job Types
Commands
Sample job yaml

Introduction to jobs

A Job creates Pods that run until successful termination (i.e., exit with 0). In contrast, a regular Pod will continually restart regardless of its exit code.
Jobs are useful for things you only want to do once, such as database migrations, backup or batch jobs.
A pod that is started by a Job must have its restartPolicy set to OnFailure or Never
- OnFailure will re-run the container on the same Pod
- Never will re-run the failing container in a new Pod

Job Types

3 different job types can be started, which is specified by the completions and parellelism parameters
- Non-parallel Jobs - one Pod is started, unless the Pod fails
- completions=1
- parallelism=1
- Parallel Jobs with a fixed completion count - the Job is complete after successfully running as many times as specified in jobs.spec.completions
- completions=n
- parallelism=m
- Parallel Jobs with a work queue - multiple Jobs are started, when one completes successfully, the Job is complete
- completions=1
- parallelism=n

Commands

List the jobs

kubectl get jobs

See the job spec yaml

kubectl get jobs -o yaml | less

Inspect the job

kubectl describe jobs [job-name]

Delete the job

kubectl delete jobs [job-name]

Extract the log if you know the name of the specific job instance. With a little help from grep and cut the name of the job is extracted and passed to the logs command

export JOB_ID=$(kubectl describe jobs oneshot | grep -o 'Created pod: .*' | cut -f3- -d' ')

echo $JOB_ID

kubectl logs $JOB_ID

Sample job yaml

apiVersion: batch/v1
kind: Job
metadata:
  name: oneshot
  labels:
    chapter: jobs
spec:
  template:
    metadata:
      labels:
        chapter: jobs
    spec:
      containers:
      - name: kuard
        image: gcr.io/kuar-demo/kuard-amd64:1
        imagePullPolicy: Always
        args:
        - "--keygen-enable"
        - "--keygen-exit-on-complete"
        - "--keygen-num-to-gen=10"
      restartPolicy: OnFailure

(This is an article posted to my blog at overreacted.io. You can read it online by clicking here.)

AWS VPC

Fri, 22 Apr 2022 00:00:00 GMT

What is AWS VPC?

VPC stands for Virtual private cloud
Basically Amazon giving you it’s software defined network for your own use
VPC is an isolated network in a region.
VPC spans all availability zones in a region

VPC Components

VPC
Subnet
Route Table
Security Groups
Network ACLs

What is Subnet

Subnets are basically sub networks inside a VPC. It is like network in the network.
Each subnet can be one availability zone

What is Internet Gateway

All the internet access happens through internet gateway
This is important for all the traffic leaving VPC

What is Security Group

Security groups are applied on per instance level.
We assign security group to VPCs. And every instance running on the VPC can be attached to the security groups which are assigned to the VPC.
Security groups are one way of controlling which access is allowed to the instances and which traffic may leave the instances. That basically acts like a firewall.

What is Network Control List (NACL)

These apply on subnet level
We can define which traffic may enter the subnet
Security group is bit more granular, but NACL allows to really configure the whole subnet.

Routing table

Route the traffic differently with Route table
Specify is traffic allowed to reach other instances in the VPC, is it allowed to leave the VPC
Can control the assignment of public IPs

Public and Private Subnets

Private Subnet
- Block outgoing traffic to deny internet access or doesn’t assign any public IPs
- Can use to holds database service. These shouldn’t need to access from internet. They only need to accessed from your web servers.
Public Subnet
- Allow outgoing traffic to internet or have Public (Elastic) IPs
- Can use to hold web servers which have to be accessible from the internet and which should send traffic to the internet

NAT Gateway

Sometimes we still want our private subnet instances can reach out to the internet because they should be install updates of a software fro example. We do this by redirecting outgoing internet access to a NAT gateway instead of blocking it.
NAT stands for network address translation
It translates internal IPs to public ones. NAT Gateway has a public IP. Forwards to the internet gateway. Still access the internet indirectly with private instances.

CIDR Block

Notation for IP address ranges
- e.g. 1.0.0.0/16
https://jodies.de/ipcalc
With the netmask (value after slash) we decide how many binary figures are fixed.
32 is the highest. It means it’s a one IP. Everything is fixed.
192.168.0.1/16 - 16 will fix the firest two blocks. This means .0.1 will be variable.

(This is an article posted to my blog at overreacted.io. You can read it online by clicking here.)

Micro Frontends

Sun, 01 Aug 2021 00:00:00 GMT

Refer the Microsoft Word documents within the same folder

(This is an article posted to my blog at overreacted.io. You can read it online by clicking here.)

සිවු වැදෑරුම් ආහාර

Wed, 20 May 2020 00:00:00 GMT

http://www.budusarana.lk/budusarana/2009/04/09/tmp.asp?ID=vision03

බුදුරජණන් වහන්සේ විසින් සත්ත්වයා නැවත උපතක් කරා යාම සඳහා හේතු වන කරුණු 4ක් පිළිබඳ වදාළ දෙසුම කුමක්ද?

සංයුත්ත නිකායෙහි අභිසමය සංයුත්තයට අයත් අත්ථිරාග සූත්‍රය

පුද්ගලයා නැවත භවයක් කරා ගෙන යාම සඳහා මූලික වන කාරණා 4 කුමක්ද?

කබලිංකාර ආහාරය
ඵස්ස ආහාරය
මනෝසංචේතනික ආහාරය
විඤ්ඤාණ ආහාරය යන ආහාර හතරයි.

මෙම ආහාර පුද්ගලයා නැවත සසර උපතක් කරා රැගෙන යන්නේ කෙසේද?

පුද්ගලයා නැවත සසර උපතක් කරා රැගෙන යන්නේ මෙම ආහාර පවතින නිසා නොව, මෙකී සිව් ආකාර ආහාර පිළිබඳ පවතින ඡන්ද රාගය නිසාය.

කබලිංකාර ආහාර අපව නැවත උපතක් කරා ගෙනයාමට හේතු වන්නේ කෙසේද?

අප ශරීර පෝෂණය පිණිස මුඛ මාර්ගයෙන් ගන්නා මෙම කබලින්කාර ආහාර කිසියම් හේතුවක් මුල්කොට අපව නැවත උපතක් කරා ගෙනයාමට හේතු වන්නේ යැයි සඳහන් කර කළ හැකි ය. ඒ කෙසේද යත් කිසියම් කබලිංකාර ආහාරයක් අනුභව කරන විට එහි රසය ජිව්හා ඉන්ද්‍රිය මගින් අපට දැනෙන්ට වෙයි. එසේ දිවට දැනුන මෙම කබලිංකාර ආහාරයෙහි රසය ඳහිර නම්, එම රස පිළිබඳව තණ්හාව හටගන්නේ ය. කබලිංකාර ආහාරය කෙරෙහියම් ඡන්ද රාගයක් තමා තුළ උපදී ද එම ආහාරය කෙරෙහි ඇල්ම, තෘෂ්ණාව උපදී ද, එහි විඤ්ඤාණය පිහිටියා වන්නේ ය. යම් තැනක විඤ්ඤාණය පිහිටියේ ද, වැඩුණේ ද, එහි නාම රූපයන්ගෙන් බැස ගැන්මක් ඇතිවන බව තේරුම්ගත යුතු ය. එම නිසා එහි සංස්කාරයන්ගේ් වැඩීම ද සිදු වන්නේය. බුද්ධ දේශනාවෙහි සඳහන් පරිදි යම් සංස්කාරයක් හටගනී ද, (සංස්කාර යනු චේතනා සහිත කර්ම රැස්වීම යැයි දත යුතු ය) එය නැවත නැවත උපතක් කරා මේ ජීවිතය රැගෙන යාමට හේතුවන කරුණක් වන්නේ ය.

කබලිංකාර ආහාර පිළිබඳ පිළිපැදිය යුතු ආකාරය කුමක්ද?

සසරින් නිදහස් වීම සඳහා පිළිවෙත් පුරන ශ්‍රාවකයා කබලිංකාර ආහාර පිළිබඳ පිළිපැදිය යුතු ආකාරය බුදුරදුන් විසින් පැහැදිලි කර දී ඇත. ආහාර අනුභව කරන විට එම ආහාරය තමන්ගේ රස තෘෂ්ණාව වැඩීම පිණිස නොව, මදය හා ජවය වර්ධනය පිණිස නොව, තම ජීවිකාවෙහි පැවැත්ම පිණිස පමණක් විය යුතු බව මෙනෙහි කළ යුතු බවයි, බුදුරදුන්ගේ අනුශාසනාව.

(This is an article posted to my blog at overreacted.io. You can read it online by clicking here.)

Maybe Absolute Links?

Sat, 09 May 2020 00:00:00 GMT

An error message suddenly appeared from Gatsby while building this site

info changed file at /Users/oisu/Workspace/blog.oisulab.com/src/pages/started-my-blog/index.md
[ { GraphQLError: Cannot query field "maybeAbsoluteLinks" on type "fields_4".
    at Object.Field (/Users/oisu/Workspace/blog.oisulab.com/node_modules/graphql/validation/rules/FieldsOnCorrectType.js:65:31)
    at Object.enter (/Users/oisu/Workspace/blog.oisulab.com/node_modules/graphql/language/visitor.js:324:29)
    at Object.enter (/Users/oisu/Workspace/blog.oisulab.com/node_modules/graphql/language/visitor.js:366:25)
    at visit (/Users/oisu/Workspace/blog.oisulab.com/node_modules/graphql/language/visitor.js:254:26)
    at visitUsingRules (/Users/oisu/Workspace/blog.oisulab.com/node_modules/graphql/validation/validate.js:74:22)
    at validate (/Users/oisu/Workspace/blog.oisulab.com/node_modules/graphql/validation/validate.js:59:10)
    at graphqlImpl (/Users/oisu/Workspace/blog.oisulab.com/node_modules/graphql/graphql.js:106:50)
    at /Users/oisu/Workspace/blog.oisulab.com/node_modules/graphql/graphql.js:66:223
    at Promise._execute (/Users/oisu/Workspace/blog.oisulab.com/node_modules/bluebird/js/release/debuggability.js:313:9)
    at Promise._resolveFromExecutor (/Users/oisu/Workspace/blog.oisulab.com/node_modules/bluebird/js/release/promise.js:483:18)
    at new Promise (/Users/oisu/Workspace/blog.oisulab.com/node_modules/bluebird/js/release/promise.js:79:10)
    at graphql (/Users/oisu/Workspace/blog.oisulab.com/node_modules/graphql/graphql.js:63:10)
    at graphqlRunner (/Users/oisu/Workspace/blog.oisulab.com/node_modules/gatsby/dist/bootstrap/index.js:372:14)
    at Promise (/Users/oisu/Workspace/blog.oisulab.com/gatsby-node.js:25:7)
    at Promise._execute (/Users/oisu/Workspace/blog.oisulab.com/node_modules/bluebird/js/release/debuggability.js:313:9)
    at Promise._resolveFromExecutor (/Users/oisu/Workspace/blog.oisulab.com/node_modules/bluebird/js/release/promise.js:483:18)
    message: 'Cannot query field "maybeAbsoluteLinks" on type "fields_4".',
    locations: [ [Object] ],
    path: undefined } ]

I don’t dig into this yet, but realized that it’s not shown if an internal link to the other post in markdown like this exists anywhere in my whole posts:

[this](/started-my-blog/)

So, this is the post only for solving the problem! Anyway, the error disappeared because I wrote the line above 😂

(This is an article posted to my blog at overreacted.io. You can read it online by clicking here.)

VS Code

Sun, 29 Dec 2019 00:00:00 GMT

Keyboard Shortcuts

Reference - https://code.visualstudio.com/shortcuts/keyboard-shortcuts-windows.pdf

My Customized VS Code Keyboard Shortcuts

Command	Shortcut Key	Reference
Delete Line	Ctrl+D
Go Forward	Cmd + Alt + Right
Redo	Cmd + Y
Go To File…	Cmd + Enter
View: Quick Open Previous Recently Used Editor in Group	Cmd + K Cmd + K

Frequently Used VS Code Keyboard Shortcuts

Command	Shortcut Key	Reference
Preferences: OPen Keyboard Shortcuts	Ctrl+K Ctrl+S
View: Toggle Side bar Visibility	Ctrl+B
View: Toggle bottom panel	Ctrl+J
Go to last edited location	Alt+LeftArrow

Settings changes

Formatting on save and on paste
- Settings -> User -> Text Editor -> Formatting
  - Format on Save - True
  - Format on Paste - True
Project files tree indentation
- Settings -> User -> Workbench -> Appearance
  - Workbench Tree: Indent - 20

Settings file locations

Depending on the platform, the user settings file is located here:

Windows %APPDATA%\Code\User\settings.json
macOS $HOME/Library/Application\ Support/Code/User/settings.json
Linux $HOME/.config/Code/User/settings.json

Reference - https://code.visualstudio.com/docs/getstarted/settings#_settings-file-locations

Useful Extensions

Prettier - Code formatter
Git Lens - Git supercharged
Debugger for Chrome
vscode-icons
Visual Studio IntelliCode
JavaScript (ES6) code snippets
HTML Snippets
HTML CSS Support
Auto Close Tag
Auto Rename Tag
npm
npm intellisense
IntelliSense for CSS class names in HTML
Live Server
Color Picker
React Native Tools
Code Spell Checker
ES Lint

Extensions location

Extensions are installed in a per user extensions folder. Depending on the platform, the location is in the following folder:

Windows %USERPROFILE%\.vscode\extensions
macOS ~/.vscode/extensions
Linux ~/.vscode/extensions

Reference - https://code.visualstudio.com/docs/editor/extension-marketplace#_where-are-extensions-installed

Extension - Jira and Bitbucket (Atlassian Labs)

Configuration

Set below configuration options in Settings file.

"yaml.schemas": {
    "file:///Users/nuwan/.vscode/extensions/atlassian.atlascode-2.10.12/resources/schemas/pipelines-schema.json": "bitbucket-pipelines.yml"
},
"atlascode.bitbucket.enabled": true,
"http.proxyAuthorization": null,
"atlascode.outputLevel": "debug",
"atlascode.enableHttpsTunnel": true,

Set extension settings as below by setting Bitbucket site and credentials.

Extension - Paste Image

Activation command

Command + Optin + v

Configuration

Set below configuration options in Settings file.

"pasteImage.path": "${currentFileDir}/assets",
"pasteImage.showFilePathConfirmInputBox": true

(This is an article posted to my blog at overreacted.io. You can read it online by clicking here.)

දහ අට වංගුව

Sun, 01 Dec 2019 00:00:00 GMT

දහ අට වංගුව

http://18wanguwa.blogspot.com/p/blog-page.html

පළමුවැනි වංගුව පටන් ගන්නා තැන සිට පහත බලන්න. කළු පැහැති යෝධ උරගයෙක් දඟර ගැසී දිවයන්නා සේ දැන් පෙනෙන්නේ දහඅට වංගු මාර්ගය යි. ඔබ එය දුටුවේ යෝධ සර්පිලයක් ලෙස නම් එය අපූරු කල්පනාවකි.

වංගු දහ අට උස

”මේ පළමුවැනි වංගුවේ ඉඳලා අන්තිම වංගුව දක්වා හරි කෙළින් නූලක් පහතට දැම්මොත් ඒක කොච්චර දිග වෙයිද …?” ”… මීටර් පන්සීයකටත් වඩා අඩුයි.” අප සමඟ වුන් ඉංජිනේරු තැන සෘජු පිළිතුරක් දුන්නේය. ”ඒ කියන්නෙ වංගු දහ අටම තියෙන්නේ උසින් කිලෝමීටර් භාගයකටත් වඩා අඩු දුරකින්?” ”ඔව් මීටර හාරසිය ගණනක් තියෙන්නේ” මෙවැනි ප්‍රපාතාකාර බෑවුමක කන්ද වටේ හැරෙමින් මහා මාර්ගයක් තැනීම සුළුපටු කාරියක් නොවේ. කිලෝමීටර භාගයක දුර නඟින්නට හෝ බසින්නට ඔබ කිලෝමීටර හතක දුරක් කන්ද වටේ සැරිසැරිය යුතුය.

ඉතිහාස කතාව

කෝපි කාලේ සුද්දෙක්; අක්කරය සිලිං පහ ගණනේ කඳු යායක් මිලට ගත්තේය. ගමන අශ්වයා පිටිනි. දුම්බර කඳු වළල්ලේ සිට බින්තැන්න දෙසට ඇදී ගිය ඒ අඩි පාර පසු කලෙක ගුරු පාරක් බවට පළල් විය. ඊටත් පසුව එය ගල් තාර යෙදූ මහා මාර්ගයක් බවට වැඩි දියුණු කෙරුණේ කොළඹ වරාය දක්වා තේ - කෝපි ප්‍රවාහනය කිරීමට ය. ඒ දහ අට වංගුවේ ඉතිහාස කතාවය.

(This is an article posted to my blog at overreacted.io. You can read it online by clicking here.)

සිරිපාදය

Thu, 07 Nov 2019 00:00:00 GMT

සිරිපාදය

http://www.colombotoday.com/42233-2463/ https://roar.media/sinhala/main/travel/the-sripada-trek/

ආරම්භය

ඒ අනුව පැල්මඩුල්ල, ගල්පොත්තාවෙල ශ්‍රී පාද රජමහා විහාරස්ථානයේ තැන්පත් කර ඇති සධාතික කරඞුව සමන්දේව ප්‍රතිමාව හා දේවාභරණ, නියමිත දිනයේ යෙදෙන සුබ මොහොතින් දොරට වැඩීම සිදුකෙරෙන අතර, ඒවා පෙරහරින් සමනළ කඳු මුදුනේ පිහිටි දේවාලය වෙත ගෙනයනු ලබනවා. ඒ, සිරිපා වන්දනාවේ ආරම්භක අවස්ථාවයි.

දෙසැම්බර් මස උඳුවප් පොහොය දිනයෙන් ඇරඹෙන මේ සිරිපා කරුණා සමය මැයි මස වෙසක් පොහොය දිනයෙන් අවසන් වනවා.

ශ්‍රී පාදයේ ඉතිහාසය

බුදුරජාණන් වහන්සේ බුද්ධත්වයෙන් අට වන වර්ෂයේදී ලංකාවට වැඩම කර තිබෙනවා. ඒ, එවකට කැළණියේ රජ කල මණිඅක් නම් නා රජුගේ ආරාධනාවකට අනුවයි. එම අවස්ථාවේදී එතැනට පැමිණි සුමන සමන් දෙවියන්ගේ ඉල්ලීමකට අනුව බුදුන් වහන්සේ සමනළ කන්දට වැඩම කර තිබෙනවා. එහිදී තථාගතයන් වහන්සේ කඳු මුදුනේ වම් ශ්‍රී පා සටහන පිහිටවූ බවයි බෞද්ධ මූලාශ්‍ර වල දැක්වෙන්නේ. සමන් දෙවියන්ගේ අඩවිය, සමනළ කන්ද ලෙස හැඳින්වෙනවා. සමන් දෙවියන්, මිට පෙර බුදුන් වහන්සේ ලංකාවට පැමිණි අවස්ථාවකදී බණ අසා සෝවාන් වූ දෙවියෙකු දෙස ප්‍රචලිතයි.

බුදුන් වහන්සේගේ ශ්‍රී පා සළකුණ සටහන් වන ස්ථාන හතර

බෞද්ධ ඉතිහාසයට අනුව බුදුන් වහන්සේගේ ශ්‍රී පා සළකුණ සටහන් වන ස්ථාන හතරක් ගැන කියවෙනවා.

එක් සිරිපා සටහනක් නර්මදා නදී තීරයේ ද, දෙවැන්න සච්චබද්ධ පර්වතයේ ද, තුන්වැන්න සමන්තකූට පර්වතයේ ද, අනෙක යෝනක පුරයෙහිද පිහිටා ඇතිබවයි.

ඒ හැරුණු විට අනුරාධපුර අභයගිරි චෛත්‍ය පිහිටි ස්ථානයේද බුදුරජාණන් වහන්සේගේ සිරිපා සටහනක් පැවති බව ක්‍රි.ව. 5 වන සියවසට අයත් ෆාහියන් වාර්තාවේ දක්නට ලැබෙනවා. එහෙත් එවැනි ශ්‍රී පාද ලාංජනයක් ලංකාවේ බැතිමතුන්ගේ වන්දනාවට භාජනය වී පැවති බවට තොරතුරු පසුකාලීනව දක්නට ලැබෙන්නේ නැහැ.

සිරිපතුල් වන්දනාව

පාද ලාංජන වන්දනාව බුද්ධ කාලයේ සිට පැවත එන්නක් බව බුද්ධ චරිතයේ විවිධ අවස්ථා නිරීක්ෂණයේදී අපට පැහැදිලි වෙනවා. මේ අනුව බුදුන් වහන්සේගේ පරිනිර්වාණ අවස්ථාවේදී මහාකාශ්‍යප හිමියන් විසින් බුදුන්ගේ පාද ස්පර්ශය කර පාදවලට නමස්කාර කරනවා. ඉන්පසු චිතය ගිනි දැල්වුණු බවයි මහා පරිනිර්වාණ සූත්‍රයේ සඳහන් වෙන්නේ.

සාමාන්‍යයෙන් බුදුන්වහන්සේ පා ගමනින් වඩින විට උන්වහන්සේගේ පා සටහන් පිහිටන්නේ නැහැ. එවැන්නක් සිදුවන්නේ උන්වහන්සේ අධිෂ්ඨාන කළහොත් (අධිට්ඨාන වසෙන) පමණක් බව පාලි අටුවාව පැහැදිලි කරනවා.

සිරිපා වන්දනාවට සබැඳි ජනප‍්‍රිය ම ඉතිහාසය ඇත්තේ ශ‍්‍රී නිශ්ශංකමල්ල රජුට යි. එතුමාගේ රාජ්‍ය සමයේ දී ශ‍්‍රී පාදය සොයාගත් බව දැක්වෙන කතාවක් ද ජනප‍්‍රවාදයේ එනවා. මෙතැන් සිට රාජ්‍ය අනුග්‍රහයද සහිතව සිරිපා වන්දනාව ආරම්භවී ඇති බවයි සඳහන් වෙන්නේ.

පද්මේ වඳින්නට පෙර පිරිසිදුකම

ශ්‍රීපාදය වන්දනාවට පෙර සතියකට පෙර සිටවත් මස්මාලු කිලි වලින් තොරව ප්‍රවේසම් වෙමින්, ලක ලැහැස්ති වෙමින් මේ පූජනීය ගමනට සැරසීමේ ක්‍රමයක් අතීතයේ සිට පැවතුණා.

සිරිපාද වන්දනාව ගැන ඔබ මුලින් දැනගත යුතු කාරණා

පළවෙනි පාරට සිරිපාදේ යනවා නම් එයාව හඳුන්වන්නේ කෝඩුකාරයා කියලයි. කෝඩුකාරයින් වර්ග දෙකයි. ප්‍රථම වරට සිරිපා ගමන් කරන්නා වැඩිහිටියෙකු නම් “දඬුකෝඩු“. කුඩා දරුවෙකු හෝ දැරියක ප්‍රථම වරට ගමන් කිරීම “කිරිකෝඩු” කියලයි හඳුන්වන්නේ.

බෞද්ධ සිද්ධස්ථාන වැඳීමට යන වෙන ගමන් වන්දනා ලෙස හැඳින්වූවාට සිරිපා වන්දනාව හඳුන්වන්නේ “කරුණා කරනවා” කියලයි.

ගමන “කරුණා කිරීම” කියලා හඳුන්වන අතර, යන කණ්ඩායම “නඩේ” නමින් හඳුන්වනවා.

ගමෙහි සිරිපා කරුණාව සඳහා එකතු වන සමූහය අතර අත්දැකීම් බහුල වැඩිහිටියා, බොහෝවිට ගමන සංවිධානය කරන්නා එම නායකයාය. ඔහු “නඩේගුරා“ය. නඩේගුරා සිරිපා වන්දනාව පිළිබඳ හසල අත්දැකීම් ඇත්තෙකි.

අරගෙන යන බඩු මල්ල බර වුනාට අපි ඒක හඳුන්වන්නේ සැහැල්ලුව කියලා තමයි.

ඒ වගේම තමයි සිරිපා මලුවේ සිට හිරු නැගීම නැරඹීම හඳුන්වන්නේ ඉරසේවය කියලයි.

වන්දනා කරුවන් සිරිපා මගේ පාගමනින් යනවිට එකිනෙකාට බොහොම විනීතව කවියෙන් ආමන්ත්‍රණය කිරීම. එකිනෙකාට කරුණාවයි, ඒවැනි කවි එකිනෙකාට කියා ගැනීම. මේවා විවිධ අයුරින් වර නැගීම හෝ වෙනස් කර කීම ගමන් මහන්සිය දුරුකර ගැනීම වෙනුවෙන් ගොඩක් නඩ තවමත් කරන දෙයක්.

වඳින්ඩ යන මේ නඩේට සුමන සමන් දෙවි පිහිටයි
වැඳල බහින මේ නඩේට සුමන සමන් දෙවි පිහිටයි
කරුණාවයි – කරුණාවයි

කන්දේ වැඩි බෑවුම් සහිත ප්‍රදේශය සහ ශීතලෙන් වැඩිම කොටස හිමේ නමින් හඳුන්වනවා. ඒවගේ ම හිමය කියා සමනොළ කන්ද ආශ්‍රිත වනාන්තරය හැඳින්වීමත් කරනවා.

ඉර සේවය

සූර්ය උදාවට කලින් කඳු මුදුනට නැගීම තමයි සෑම ශ්‍රීපාද වන්දනාකරුගේම අභිප්‍රාය. කඳු මුදුනේ දී සූර්ය උදාව නැරඹීම “ ඉර සේවය ” නමින් ජන වහරේ මෙය හඳුන්වනවා.

සමනොල කඳු මුදුනේ සිට බලන විට මධ්‍යම කඳුකරයේ කොටපොල කඳු මුදුනින් එක් වරකට පෙනෙමින්ද තවත් වරකට සැඟවෙමින්ද නොයෙක් ආකාරයෙන් විවිධ රැස් ධාරා පතුරවමින් සුර්යයා එක්වරම උදාවන ආකාරය සැබැවින්ම මනස්කාන්තයි.

හිරු එළිය කඳු මුදුනට වැටී අවට තැනිතලා යන්නේ පහල භූමියේ ත්‍රිකෝණාකාර සෙවණැල්ලක් පෙන්නුම් කරමිනුයි. හිරු ඉහළට නැඟීමත් සමගම සෙවනැල්ල වේගයෙන් පහතට ගමන් කරනවා. මෙවැනි දර්ශනීය සුර්ය උදාවක් ලොව අන් කවර තැනකවත් දැකිය නො හැකි බව තතු දත් අය පවසනවා.

සිරිපාදයට යන මාර්ග

ශ්‍රී පාද වන්දනාවට ප්‍රධාන වශයෙන් මාර්ග දෙකක් තිබෙනවා. ඒ තමයි රත්නපුර පලාබද්දල මාර්ගය සහ හැටන් නල්ලතන්නිය පෙදෙසින් යන මාර්ගය.

පලාබද්දල මාර්ගය

දුරින් වැඩි වුනත් හෙල් ගතිය අඩු නිසා අඩු මහන්සියකින් යන්නට හැකියාව තිබෙනවා. ඒවගේම තමයි දුරින් වැඩි වුනත් නියමම මුල් ගමන් මාර්ගය විදියට සැලකෙන්නේ මේ පලාබද්දල මාර්ගය තමයි.

මෙහිදී අපිට ප්‍රධාන ස්ථාන කිහිපයක් හමුවෙනවා මේ සියල්ලම වන්දනා කරුවන් අතර ඉතා ජනප්‍රිය ස්ථාන. අපි එකින් එක ඒවා හඳුනා ගමු

ලිහිණි හෙල අම්බලම
- ලිහිණි හෙළ ගැන අතීත කතා කිහිපයක්ම තිබුනත්, වඩා ප්‍රචලිත කතාව තමා ලිහිණි නමැති කාන්තාවක් තම සැමියාගෙන් අත්වන දුක්ගැහැට ඉවසාගන්නට නොහැකිව ඔය ගල තිබෙන තැනින් පහලට පැන්නාය කියල කියන එක, තවමත් ඔතනින් යන සමහර කෝඩුකාරයෝ “ලිහිණි අක්කේ අපි ආවෝ කියලා කෑ ගැහුවාම. ලිහිණි ගලෙන් උත්තර දෙනවා කියලා කිව්වට ඒ ඇහෙන්නේ ඔවුන්ගේ හඬේ “රැවුදීම” තමයි.
ධර්මරාජ ගල
- අතීතයේ ධර්මරාජ ගල සිට අලි ඇතුන් සිරිපා වන්දනා කළා කියලා මතයක් තිබුනා. දැන්නම් එහෙම දෙයක් වෙන්නේ නැහැ.
ගෙත්තම් පාන/ඉඳිකටු පාන
- බුදු රජාණන් වහන්සේ සිරිපාදයට වැඩම කරන අවස්ථාවේදී තමන්ගේ සිවුරෙහි ඉරුණු තැන් මසා පිළිසකර කරගත් ස්ථානය හැටියටයි ගෙත්තම්පාන හඳුන්වන්නේ. ඒ අවස්ථාවේ මාරයා සුවිශාල වර්ෂාවක් වැස්ස වුවද, මහා බුද්ධ තේජසින් උන්වහන්සේ වැඩ සිටි ස්ථානයට වැසි දිය බිඳක් වත් වැටිලා නැහැ.
- මුලින් සිරිපා කරුණා කරන කෝඩුකාරයෝ මෙතන ඉඳිකටු නූල් ගෙනල්ල ගෙත්තමක් කරලා තමා යන්නේ. එහෙම ගියේ නැහැ කියලා කිසිවක් වෙන්නේ නැති වුනාට, ගෙත්තම් කරන්නේ නැතුව ගෙත්තම් පාන පහුකරලා ගිහින් මොකටද?
සීතගඟුල
- බැතිමතුන් සිසිල් දිය නා සුදු පිරුවට හැඳ පේවෙන්නේ මෙහිදීයි.
ඇහැල කණුව
- අතීතයේ සීත ගඟුලෙන් නා පිරිසිදු වන නඩය පිරුවට හැඳගන්නේ මෙතන සිටයි.
අහස්ගව්ව
- මේ ආශ්‍රිත ප්‍රදේශය “හිමය” නමින්ද හඳුන්වනවා. ඒ වගේම සුළංකපොල්ලක් වන නිසා බොහොම ප්‍රවේසමින් යායුතු ස්ථානයක් ද වෙනවා.
මහගිරිදඹය
- අපහසුම කොටසේත් අපහසුම කොටස තමා මහගිරිදඹය. වර්තමානයේ නම් අත්වැල් සහ ආධාරක තිබුනත් අතීතයේ තමන්ගේ සමබරතාව රැකගන්නට නොහැකිව වැටී අතුරුදන් වූ අය අනන්තය අප්‍රමාණයි.

හැටන් නල්ලතන්නි මාර්ගය

දුරින් අඩු වුනත් පහසුවෙන්ම පද්මය ආසන්නයටම වාහන වලින් ගොසින් කි.මි 6 ක් පමණ ගෙවා පද්මයට ලඟා වන්නට හැකි නිසා මේ පාර වන්දනාකරුවන්ගේ තවත් තෝරාගැනීමක් වෙලා තිබෙනවා.

සිරිපාද වන්දනා ගාථාව

කල්‍යාණීතෝ ගගනතෝ මුණියත්ථ ගන්ත්වා
දස්සේයී චක්කවරලක්ඛණ පාදලඤ්ඡං
ලංකාමහීවරවධු මකුටෝපමානං
වන්දාමහං සුමණකූට සිලුච්චයන්තං

(This is an article posted to my blog at overreacted.io. You can read it online by clicking here.)

REST

Fri, 01 Nov 2019 00:00:00 GMT

REST

Q - What is an OPTIONS Request and why is it made by the browser?

Reference - https://stackoverflow.com/questions/29954037/why-is-an-options-request-sent-and-can-i-disable-it

OPTIONS requests are what we call pre-flight requests in Cross-origin resource sharing (CORS).

This pre-flight request is made by some browsers as a safety measure to ensure that the request being done is trusted by the server. Meaning the server understands that the method, origin and headers being sent on the request are safe to act upon.

Your server should not ignore but handle these requests whenever you’re attempting to do cross origin requests.

A way to handle these to get comfortable is to ensure that for any path with OPTIONS method the server sends a response with this header

Access-Control-Allow-Origin: *

This will tell the browser that the server is willing to answer requests from any origin.

According to the CORS strategy You can’t just force the browser to stop sending OPTIONS request if it thinks it needs to.

There are two ways you can work around it:

Make sure your request is a “simple request”
Set Access-Control-Max-Age for the OPTIONS request

Simple request

A simple cross-site request is one that meets all the following conditions:

The only allowed methods are:

GET
HEAD
POST

Apart from the headers set automatically by the user agent (e.g. Connection, User-Agent, etc.), the only headers which are allowed to be manually set are:

Accept
Accept-Language
Content-Language
Content-Type

The only allowed values for the Content-Type header are:

application/x-www-form-urlencoded
multipart/form-data
text/plain

A simple request will not cause a pre-flight OPTIONS request.

Set a cache for the OPTIONS check

You can set a Access-Control-Max-Age for the OPTIONS request, so that it will not check the permission again until it is expired.

Access-Control-Max-Age gives the value in seconds for how long the response to the preflight request can be cached for without sending another preflight request.

(This is an article posted to my blog at overreacted.io. You can read it online by clicking here.)

JavaScript

Fri, 01 Nov 2019 00:00:00 GMT

Basics

Q - What is the !! (not not) operator in JavaScript?

Reference - https://love2dev.com/blog/javascript-not-operator/

This is really a shorthand way to convert any value to a boolean.

Some say the way to remember this trick is, “bang bang, you’re boolean”.

Q - What are the things that evaluate to falsey in JavaScript?

Reference - https://love2dev.com/blog/javascript-not-operator/

undefined
null
NaN
0
"" (empty string)
false

Q - What is AMD, CommonJS, and UMD?

Reference - https://www.davidbcalhoun.com/2014/what-is-amd-commonjs-and-umd/

Q - Define primitive types.

A primitive (primitive value, primitive data type) is data that is not an object and has no methods.

All primitives are immutable, i.e., they cannot be altered.

Q - What are the primitive types in JavaScript?

String : typeof instance === "string"
Number : typeof instance === "number"
Boolean : typeof instance === "boolean"
BigInt : typeof instance === "bigint"
undefined : typeof instance === "undefined"
Symbol : typeof instance === "symbol"

Reference - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures

Q - What are the non-primitive types (Object references) in JavaScript?

null : typeof instance === "object"
Object : typeof instance === "object" Special non data but Structural type for any constructed instance

new Object, new Array, new Map, new Set, new WeakMap, new WeakSet, new Date and almost everything made with new keyword;
Function: typeof instance === "function"

Q - What is a Closure?

A closure is the combination of a function bundled together (enclosed) with references to its surrounding state (the lexical environment).

In other words, a closure gives you access to an outer function’s scope from an inner function.

In other words, a closure is nothing but functions with preserved data.

Reference - https://medium.com/javascript-scene/master-the-javascript-interview-what-is-a-closure-b2f0d2152b36

Reference - https://www.youtube.com/watch?v=71AtaJpJHw0&ab_channel=techsith

Q - Give an example of a closure.

var addTo = function(passed) {
  var add = function(inner) {
    return passed + inner;
  };
  return add;
}
var addThree = addTo(3); 
var addFour = addTo(4);

console.log(addThree(1)); // 4
console.log(addFour(1));  // 5

Reference - https://www.youtube.com/watch?v=71AtaJpJHw0&ab_channel=techsith

Advanced

Tree Shaking

Q - What is tree shaking?

It is the process used to remove dead code.
The module bundlers (e.g. webpack, rollup) would automatically remove unused modules in the bundle during the build process.
This only works with import and export.
It won’t work with CommonJS require syntax.

References

Q - What is the benefit of tree shaking?

Tree shaking helps to significantly reduce the bundle size thus improving performance.

References

https://medium.com/@netxm/what-is-tree-shaking-de7c6be5cadd

(This is an article posted to my blog at overreacted.io. You can read it online by clicking here.)

JavaScript Tools

Fri, 01 Nov 2019 00:00:00 GMT

Yarn

Q - How to install yarn dependency as a dev dependency?

yarn add <package...> --dev

Q - How to install yarn dependency as a dev dependency?

yarn add <package...>

Q - How to uninstall yarn dependency?

yarn remove <package...>

Running yarn remove foo will remove the package named foo from your direct dependencies updating your package.json and yarn.lock files in the process.

Other developers working on the project can run yarn install to sync their own node_modules directories with the updated set of dependencies.

When you remove a package, it is removed from all types of dependencies: dependencies, devDependencies, etc.

(This is an article posted to my blog at overreacted.io. You can read it online by clicking here.)

Applications

Tue, 29 Oct 2019 00:00:00 GMT

SourceTree

Q - How to notify SourceTree to use latest credentials when SCB account password is updated?

Go to Keychain and remove SourceTree credentials entry. (Select all the entries in the keychain application and look for ‘Where: SourceTree’ in the entry. Delete such entry.)
Go to SourceTree and ‘pull’ or ‘fetch from origin’. It will ask for you to enter password.
Add the new password and click the checkbox of ‘Store Password in Keychain’

Q - In MacOS, when you make a change in the code, sourceTree might show that entire file is changed. How to fix this?

This would happen because of the line separators used in the file.
In Such case follow the step “Change line separator for a file currently opened in the editor” in following documentation
https://www.jetbrains.com/help/webstorm/configuring-line-endings-and-line-separators.html

iTerm

Q - How can I save tabs in iTerm 2 so they restore the next time the app is run?

You can Save and Restore Window Arrangement with ⇧ ⌘ S and ⇧ ⌘ R options under the Window screen in iTerm2
You can add arrangements with the ⇧ ⌘ S and manage them under Preferences -> Arrangements tab .
You can start the default Arrangement Option to enable are at Preferences -> General -> Startup -> Open default window arrangement .
https://apple.stackexchange.com/a/25084

Chrome

Keyboard Shortcuts

Command	Shortcut Key
Focus on the address bar	Mac - Command + L , Windows - Control + L

Extensions

Vimium
- Allows keyboard navigation
- Useful Vimium Keyboard shortcuts

Command	Shortcut Key
Open a link in the current tab (LinkHints.activateMode)	f
Open a link in a new tab (LinkHints.activateModeToOpenInNewTab)	F
Reload the page (reload)	r
Open URL, bookmark or history entry (Vomnibar.activate)	o
Open URL, bookmark or history entry in a new tab (Vomnibar.activateInNewTab)	O
Search through your open tabs (Vomnibar.activateTabSelection)	T

Open chrome by disabling web-security to avoid CORS issue

Run below command in Run dialog [Windows+R]

# MacOS (in Terminal)
open -na Google\ Chrome --args --user-data-dir=/tmp/temporary-chrome-profile-dir --disable-web-security --disable-site-isolation-trials

# Windows (from "Run" dialog [Windows+R])
chrome.exe --disable-web-security --disable-site-isolation-trials --user-data-dir="C:\\Users\Username\temp\Chrome"

Reference - https://stackoverflow.com/a/58658101

(This is an article posted to my blog at overreacted.io. You can read it online by clicking here.)

CSharp Notes

Mon, 02 Sep 2019 00:00:00 GMT

Dotnet CLI

Q - What are the useful dotnet cli commands?

Run project with release configuration - dotnet run --project ./Web.Api.csproj -configuration Release

SQL Connection Strings

Q - What are the useful connection string formats?

PostgreSQL connection string - Host=localhost;Database=dbname;Username=postgres;Password=password
SQL Express with windows authentication connection string - Data Source=.\SQLExpress;Initial Catalog=dbname;Integrated Security=true;Trusted_Connection=true;

(This is an article posted to my blog at overreacted.io. You can read it online by clicking here.)

React Notes

Mon, 02 Sep 2019 00:00:00 GMT

create-react-app
- Q - Why would you eject from create-react-app?
Components
State
Lifecycle
- Q - Name the different lifecycle methods.
- Q - Where in a React component should you make an AJAX request?
Rendering Elements
- Q - What is Children?
JSX
- Q - What is JSX?
Ref
- Q - What are refs used for in React?
Redux
Redux Thunk
- Q - What is Redux Thunk used for?
Redux Saga
- Q - When to use fork and takeEvery?
Performance
- Q - When rendering a list what is a key and what is its purpose?
Linting
Testing

create-react-app

Q - Why would you eject from create-react-app?

Until you eject you are unable to configure webpack or babel presets.

Components

Q - What is the difference between a Presentational component and a Container component?

Presentational components are concerned with how things look. They generally receive data and callbacks exclusively via props. These components rarely have their own state, but when they do it generally concerns UI state, as opposed to data state. Container components are more concerned with how things work. These components provide the data and behavior to presentational or other container components. They call Flux actions and provide these as callbacks to the presentational components. They are also often stateful as they serve as data sources.

Q - What are the differences between a class component and functional component?

Class components allows you to use additional features such as local state and lifecycle hooks. Also, to enable your component to have direct access to your store and thus holds state. When your component just receives props and renders them to the page, this is a ‘stateless component’, for which a pure function can be used. These are also called dumb components or presentational components.

Q - What are controlled components?

In HTML, form elements such as input html element, textarea html element, and select html element typically maintain their own state and update it based on user input. When a user submits a form the values from the aforementioned elements are sent with the form. With React it works differently. The component containing the form will keep track of the value of the input in its state and will re-render the component each time the callback function e.g. onChange is fired as the state will be updated. An input form element whose value is controlled by React in this way is called a “controlled component”.

Q - What is a higher order component?

A higher-order component is a function that takes a component and returns a new component. HOC’s allow you to reuse code, logic and bootstrap abstraction. The most common is probably Redux’s connect function. Beyond simply sharing utility libraries and simple composition, HOCs are the best way to share behavior between React Components. If you find yourself writing a lot of code in different places that does the same thing, you may be able to refactor that code into a reusable HOC.

State

Q - What is state in react?

State is similar to props, but it is private and fully controlled by the component. State is essentially an object that holds data and determines how the component renders and behaves.

Q - What is the difference between state and props?

The state is a data structure that starts with a default value when a Component mounts. It may be mutated across time, mostly as a result of user events. Props (short for properties) are a Component’s configuration. They are received from above and immutable as far as the Component receiving them is concerned. A Component cannot change its props, but it is responsible for putting together the props of its child Components. Props do not have to just be data - callback functions may be passed in as props.

Q - Why is it advised to pass a callback function to setState as opposed to an object?

Because this.props and this.state may be updated asynchronously, you should not rely on their values for calculating the next state.

Lifecycle

Q - Name the different lifecycle methods.

componentWillMount lifecycle method - this is most commonly used for App configuration in your root component.
componentDidMount lifecycle method - here you want to do all the setup you couldn’t do without a DOM, and start getting all the data you need. Also if you want to set up event listeners etc. this lifecycle hook is a good place to do that.
componentWillReceiveProps lifecycle method - this lifecycle acts on particular prop changes to trigger state transitions.
shouldComponentUpdate lifecycle method - if you’re worried about wasted renders shouldComponentUpdate is a great place to improve performance as it allows you to prevent a rerender if component receives new prop. shouldComponentUpdate should always return a boolean and based on what this is will determine if the component is re rendered or not.
componentWillUpdate lifecycle method - rarely used. It can be used instead of componentWillReceiveProps on a component that also has shouldComponentUpdate (but no access to previous props).
componentDidUpdate lifecycle method - also commonly used to update the DOM in response to prop or state changes.
componentWillUnmount lifecycle method - here you can cancel any outgoing network requests, or remove all event listeners associated with the component.

Q - Where in a React component should you make an AJAX request?

componentDidMount is where an AJAX request should be made in a React component. This method will be executed when the component “mounts” (is added to the DOM) for the first time. This method is only executed once during the component’s life. Importantly, you can’t guarantee the AJAX request will have resolved before the component mounts. If it doesn’t, that would mean that you’d be trying to setState on an unmounted component, which would not work. Making your AJAX request in componentDidMount will guarantee that there’s a component to update.

Rendering Elements

Q - What is Children?

In JSX expressions that contain both an opening tag and a closing tag, the content between those tags is passed to components automatically as a special prop called props.children. There are a number of methods available in the React API to work with this children prop. These include React.Children.map, React.Children.forEach, React.Children.count, React.Children.only, React.Children.toArray

JSX

Q - What is JSX?

JSX is a shorthand for JavaScript XML.
This is a type of file used by React which utilizes the expressiveness of JavaScript along with HTML like template syntax. This makes the HTML file really easy to understand.
You can embed any JavaScript expression in JSX by wrapping it in curly braces.
JSX produces React “elements”. After compilation, JSX expressions become regular JavaScript objects.
You can use JSX inside of if statements and for loops, assign it to variables, accept it as arguments, and return it from functions.

render(){
  return(        
    <div>
      <h1> Hello World from Edureka!!</h1>
    </div>
  );
}

Ref

Q - What are refs used for in React?

Refs are used to get reference to a DOM node or an instance of a component in React. Good examples of when to use refs are for managing focus/text selection, triggering imperative animations, or integrating with third-party DOM libraries. You should avoid using string refs and inline ref callbacks. Callback refs are advised by React.

Redux

Q - What is redux?

The basic idea of redux is that the entire application state is kept in a single store. The store is simply a javascript object. The only way to change the state is by firing actions from your application and then writing reducers for these actions that modify the state. The entire state transition is kept inside reducers and should not have any side-effects.

Q - What is a store in redux?

The store is a javascript object that holds application state. Along with this it also has the following responsibilities: Allows access to state via getState() Allows state to be updated via dispatch(action) Registers listeners via subscribe(listener) Handles unregistering of listeners via the function returned by subscribe(listener).

Q - What is an action?

Actions are plain javascript objects. They must have a type indicating the type of action being performed. In essence, actions are payloads of information that send data from your application to your store.

Q - What is a reducer?

A reducer is simply a pure function that takes the previous state and an action, and returns the next state.

Redux Thunk

Q - What is Redux Thunk used for?

Redux thunk is middleware that allows you to write action creators that return a function instead of an action. The thunk can then be used to delay the dispatch of an action if a certain condition is met. This allows you to handle the asynchronous dispatching of actions.

Redux Saga

Q - When to use `fork` and `takeEvery`?

Reference - https://stackoverflow.com/questions/42938520/redux-saga-when-to-use-fork

Question

What would be the difference between the two approaches below? When do I need to use fork and when not?

export function* watchLoginUser() {
  yield takeEvery(USER_LOGIN, loginUser)
}
export function* watchLogoutUser() {
  yield takeEvery(USER_LOGOUT, logoutUser)
}
export function* watchGetParties() {
  yield takeEvery(PARTIES_GET, getParties)
}
export default function* root() {
  yield [
    fork(watchLoginUser),
    fork(watchLogoutUser),
    fork(watchGetParties)
  ]
}

export default function* root() {
  yield [
    takeEvery(USER_LOGIN, loginUser),
    takeEvery(USER_LOGOUT, logoutUser),
    takeEvery(PARTIES_GET, getParties)
  ]
}

Answer

In general, fork is useful when a saga needs to start a non-blocking task. Non-blocking here means: the caller starts the task and continues executing without waiting for it to complete.

There is a variety of situations where this can be useful, but the 2 main ones are:

grouping sagas by logical domain
keeping a reference to a task in order to be able to cancel/join it

Your top-level saga can be an example of the first use-case. You’ll likely have something like:

yield fork(authSaga);
yield fork(myDomainSpecificSaga);
// you could use here something like yield [];
// but it wouldn't make any difference here

Where authSaga will likely include things like:

yield takeEvery(USER_REQUESTED_LOGIN, authenticateUser);
yield takeEvery(USER_REQUESTED_LOGOUT, logoutUser);

You can see that this example is equivalent to what you suggested, calling with fork a saga yielding a takeEvery call. But in practice, you only need to do this for code organisation purposes. takeEvery is itself a forked task, so in most cases, this would be uselessly redundant.

An example of the second use-case would be something like:

yield take(USER_WAS_AUTHENTICATED);
const task = yield fork(monitorUserProfileUpdates);
yield take(USER_SIGNED_OUT);
yield cancel(task);

You can see in this example that the monitorUserProfileUpdates will execute while the caller saga resumes, and gets to wait to the USER_SIGNED_OUT action to be dispatched. It can in addition keep a reference to it in order to cancel it when needed.

For the sake of completeness, there is another way to start non-blocking calls: spawn. fork and spawn differ in how errors and cancellations bubble from child to parent saga.

Performance

Q - When rendering a list what is a key and what is its purpose?

Keys help React identify which items have changed, are added, or are removed. Keys should be given to the elements inside the array to give the elements a stable identity. The best way to pick a key is to use a string that uniquely identifies a list item among its siblings. Most often you would use IDs from your data as keys. When you don’t have stable IDs for rendered items, you may use the item index as a key as a last resort. It is not recommend to use indexes for keys if the items can reorder, as that would be slow.

Linting

Prettier

Prettier configuration

Create a .prettierrc file in the root of the project
Reference - https://prettier.io/docs/en/configuration.html

Sample prettier rules for a React project

{
  "singleQuote": true,
  "arrowParens": "always",
  "printWidth": 100
}

Reference - https://prettier.io/docs/en/options.html
arrowParens - Include parentheses around a sole arrow function parameter.
- Reference - https://github.com/prettier/prettier/pull/3324
singleQuote - Use single quotes instead of double quotes.

Testing

Q - How to print HTML like string of the wrapper for debugging purposes using Enzyme?

Following could be used to print out to the console when tests are not passing when you expect them to.

const wrapper = shallow(<Book title="Huckleberry Finn" />);
console.log(wrapper.debug());

Below gets outputs to console

<div>
 <h1 className="title">Huckleberry Finn</h1>
</div>

Q - How to force a re-render with enzyme?

.update() could be used to force a re-render in component. Useful to run before checking the render output if something external may be updating the state of the component somewhere.

NOTE: can only be called on a wrapper instance that is also the root instance.

class ImpureRender extends React.Component {
  constructor(props) {
    super(props);
    this.count = 0;
  }

  render() {
    this.count += 1;
    return <div>{this.count}</div>;
  }
}

const wrapper = shallow(<ImpureRender />);
expect(wrapper.text()).to.equal('0');
wrapper.update();
expect(wrapper.text()).to.equal('1');

Q - How to mock fetch request with Jest

import { mount } from 'enzyme';

import ExampleComponent from './ExampleComponent';

jest.mock('../../../../services/api/index.js', () => ({
  serviceConnector: (apiName) => {
    const response = {
      getUsers: {
        status: 'SUCCESS',
        users: [
          {
            id: 1,
            name: 'User 1'
          },
          {
            id: 2,
            name: 'User 2'
          }
        ]
      },
      getOrders: {
        orders: [
          {
            id: 1,
            name: 'Order 1'
          },
          {
            id: 2,
            name: 'Order 2'
          }
        ]
      }
    };

    return new Promise((resolve, reject) => {
      if (
        apiName === 'api/get-users'
      ) {
        return resolve(response.getUsers);
      } else if (
        apiName === 'api/get-orders'
      ) {
        return resolve(response.getOrders);
      } else {
        return reject(new Error('No response Found'));
      }
    });
  }
}));

describe('ExampleComponent', () => {
  // By passing the done function here, we’re telling Jest to wait until the done callback is 
  // called before finishing the test. See Testing Asynchronous Code docs for more details.
  it('fetches data from server when server returns a successful response', async (done) => {
    // We invoke Enzyme to mount render, which also invokes the React lifecycle methods
    
    const onUsersLoaded = jest.fn();
    const exampleComponent = mount(<ExampleComponent onUsersLoaded={onUsersLoaded} />);

    // Press a button in the component which triggers get-users API request.
    await exampleComponent
        .find(Button)
        .at(2)
        .props()
        .onClick();
    // Wait for component to rerender
    exampleComponent.update();

    const expectedUsers = [
        {
          id: 1,
          name: 'User 1'
        },
        {
          id: 2,
          name: 'User 2'
        }
     ];

    // Wrapping our assertion code inside a process.nextTick() ensures that the functions 
    // queued in the current event loop are completed, thus also ensuring that our Promises 
    // and other code inside ExampleComponent is done executing.
    process.nextTick(() => {
      expect(onUsersLoaded).toHaveBeenCalledWith(expectedUsers);
      // We invoke done to tell Jest that this test case is complete.
      done();
    });
  });
});

Reference
- https://medium.com/@rishabhsrao/mocking-and-testing-fetch-with-jest-c4d670e2e167
- https://jest-bot.github.io/jest/docs/asynchronous.html

(This is an article posted to my blog at overreacted.io. You can read it online by clicking here.)

React Native Notes

Mon, 02 Sep 2019 00:00:00 GMT

Basics

Q - Explain some of the fundamental trade offs between building with React Native and building a “true” native app.

React Native makes sense when a team is building a product that does not need extremely high performance. The limitations of the asynchronous bridge are a bottleneck for things like 3D games, and games with lots of particle updates. Apps that rely on deep interactions with low-level APIs, or need large amounts of native code, might be easier to build as native apps.
React Native makes sense when an existing team is already proficient in JavaScript and/or has an existing React application built on the web or another platform. The “learn once, write everywhere” ethos advocated for by Facebook is very useful when diversifying a product across platforms.

Q - What is the relationship between React Native and React?

React Native is built using React. React, at its core, is a library for “diffing” a virtual DOM and rendering this DOM to a screen with minimal operations. React, by default, does not have an opinion about which nodes are in its virtual DOM tree. Instead, it simply has algorithms that can determine changes in the tree and re-render. React Native implements a bridge that allows the JavaScript runtime to communicate asynchronously with the native runtime. React itself provides the tree diffing and rendering infrastructure that allows React Native to work.
React on the web provides its own node primitives (<div>, <span>, etc), which are the building blocks for web applications. But new node primitives can be defined, as React Native has done. React Native defines its own primitives (<View>, <Image>, etc) which do not render HTML elements but instead map to native views, like UIView and UIImageView.

Getting Started

Q - How to setup React Native for development?

You will need Node, Watchman, the React Native command line interface, and Xcode (in order to set up the necessary tooling to build your React Native app for iOS).

Install Node, Watchman, JDK

We recommend installing Node, Watchman, and JDK using Homebrew. Run the following commands in a Terminal after installing Homebrew:
```
brew install node
brew install watchman
brew tap AdoptOpenJDK/openjdk
brew cask install adoptopenjdk8
```
If you have already installed Node on your system, make sure it is Node 8.3 or newer.

Watchman is a tool by Facebook for watching changes in the filesystem. It is highly recommended you install it for better performance.

If you have already installed JDK on your system, make sure it is JDK 8 or newer.
Install React Native CLI

Node comes with npm, which lets you install the React Native command line interface.
```
npm install -g react-native-cli
```
Install XCode

The easiest way to install Xcode is via the Mac App Store. Installing Xcode will also install the iOS Simulator and all the necessary tools to build your iOS app.

If you have already installed Xcode on your system, make sure it is version 9.4 or newer.
Install XCode Command Line Tools

You will also need to install the Xcode Command Line Tools. Open Xcode, then choose “Preferences…” from the Xcode menu. Go to the Locations panel and install the tools by selecting the most recent version in the Command Line Tools dropdown.

Reference - https://facebook.github.io/react-native/docs/getting-started

Q - How to create a new application?

Use the React Native command line interface to generate a new React Native project called “AwesomeProject”

react-native init AwesomeProject

You can also use a third-party CLI to init your React Native app, such as Ignite CLI.

If you want to start a new project with a specific React Native version, you can use the —version argument

react-native init AwesomeProject --version X.XX.X

react-native init AwesomeProject --version react-native@next

Reference - https://facebook.github.io/react-native/docs/getting-started

Q - How to run your React Native application?

Run react-native run-ios inside your React Native project folder

cd AwesomeProject
react-native run-ios

react-native run-ios is just one way to run your app. You can also run it directly from within Xcode.

Reference - https://facebook.github.io/react-native/docs/getting-started

Style

Height and Width

Handling Text Input

Q - How to avoid keyboard covering text inputs in React Native?

https://codeburst.io/react-native-keyboard-covering-inputs-72a9d3072689

Handling Touches

Using a ScrollView

Using List Views

Networking

Animations

Accessibility

Timers

Upgrading

Q - How to upgrade your project to new React Native version?

Because typical React Native projects are essentially made up of an Android project, an iOS project, and a JavaScript project, upgrading can be rather tricky. Here’s what you need to do to upgrade from an older version of React Native.

Option 1

The React Native CLI comes with upgrade command that provides a one-step operation to upgrade the source files with a minimum of conflicts, thanks to the rn-diff-purge project.

Run the upgrade command

Run the following command to start the process of upgrading to the latest version:
```
react-native upgrade
```
You may specify a React Native version by passing an argument, e.g. to upgrade to 0.59.0-rc.0 run
```
react-native upgrade 0.59.0-rc.0
```
The project is upgraded using git apply with 3-way merge. That’s why it may happen you’ll need to resolve some conflicts.

Resolve the conflicts

Conflicted files include delimiters which make very clear where the changes come from. For example

 13B07F951A680F5B00A75B9A /* Release */ = {
   isa = XCBuildConfiguration;
   buildSettings = {
     ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
 <<<<<<< ours
     CODE_SIGN_IDENTITY = "iPhone Developer";
     FRAMEWORK_SEARCH_PATHS = (
       "$(inherited)",
       "$(PROJECT_DIR)/HockeySDK.embeddedframework",
       "$(PROJECT_DIR)/HockeySDK-iOS/HockeySDK.embeddedframework",
     );
 =======
     CURRENT_PROJECT_VERSION = 1;
 >>>>>>> theirs
     HEADER_SEARCH_PATHS = (
       "$(inherited)",
       /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include,
       "$(SRCROOT)/../node_modules/react-native/React/**",
       "$(SRCROOT)/../node_modules/react-native-code-push/ios/CodePush/**",
     );

You can think of “ours” as “your team” and “theirs” as “the React Native dev team”.

Alternative

Use this only in case the above didn’t work.

Upgrade the react-native dependency

Note the latest version of the react-native npm package from here (or use npm info react-native to check).

Now install that version of react-native in your project with npm install --save
```
$ npm install --save react-native@X.Y
// where X.Y is the semantic version you are upgrading to
npm WARN peerDependencies The peer dependency react@~R included from react-native...
```
If you saw a warning about the peerDependency, also upgrade react by running:
```
$ npm install --save react@R
// where R is the new version of react from the peerDependency warning you saw
```
Upgrade your project templates

The new npm package may contain updates to the files that are normally generated when you run react-native init, like the iOS and the Android sub-projects.

You may consult rn-diff-purge(https://github.com/pvinis/rn-diff-purge) to see if there were changes in the project template files. In case there weren’t any, simply rebuild the project and continue developing. In case of minor changes, you may update your project manually and rebuild.

If there were major changes, run this in a terminal to get these
```
$ react-native upgrade
```
This will check your files against the latest template and perform the following:
- If there is a new file in the template, it is simply created.
- If a file in the template is identical to your file, it is skipped.
- If a file is different in your project than the template, you will be prompted; you have options to keep your file or overwrite it with the template version.

Manual upgrade

If none of the above methods work, we could upgrade using manual steps.

Refer React Native upgrade guide for manually upgrading. https://react-native-community.github.io/upgrade-helper/

Reference - https://facebook.github.io/react-native/docs/upgrading

Q - What web application can be used to find the diff when upgrading?

React Native upgrade guide - https://react-native-community.github.io/upgrade-helper/

Reference - https://github.com/react-native-community/rn-diff-purge

Simulator

Q - How to fix the issue of iphone simulator animating very slowly?

Open iphone simulator
Click ‘Debug’ from the menu
Uncheck ‘Slow Animations’

Third Party Libraries/ Tools

MobileIron

Q - What is MobileIron?

MobileIron is software that companies use to secure and manage business apps, documents, and other business content on mobile phones and tablets.
MobileIron software includes an administration console for the IT department and an app that employees download onto their devices from the app store or Google Play.
IT uses the MobileIron console to set security and management rules.
The MobileIron app provides the IT department with information about the device and its security state.
This includes things like carrier, country, device make and model, operating system (OS) version, phone number, and corporate email.

Reference - https://www.mobileiron.com/en/what-mobileiron

(This is an article posted to my blog at overreacted.io. You can read it online by clicking here.)

Security Notes

Mon, 02 Sep 2019 00:00:00 GMT

Threat modeling

Q - What is STRIDE?

STRIDE is a model of threats, used to help reason and find threats to a system.
It provides a mnemonic for security threats in six categories.
It is used in conjunction with a model of the target system that can be constructed in parallel. This includes a full breakdown of processes, data stores, data flows and trust boundaries.

Q - What does STRIDE stands for?

S for Spoofing of user identity.
T for Tampering.
R for Repudiation.
I for Information disclosure (privacy breach or data leak).
D for Denial of service (DOS).
E for Elevation of privilege.

Q - What are the security property violated with each threat in STRIDE?

Spoofing violates Authenticity.
Tampering violates Integrity.
Repudiation violates Non-repudiability.
Information disclosure violates Confidentiality.
Denial of Service violates Availability.
Elevation of Privilege violates Authorization.

Anti-forgery

Q - Explain how Cross-Site Request Forgery (CSRF or XSRF) attacks happen.

In a cross-site request forgery (CSRF or XSRF), an attacker tricks the user into visiting a different web page (such as evil.com) with malignant code that secretly sends a malicious request to the application’s web server (such as example-bank.com).
Assume the user is logged into the application at example-bank.com. The user opens an email and clicks a link to evil.com, which opens in a new tab. The evil.com page immediately sends a malicious request to example-bank.com. Perhaps it’s a request to transfer money from the user’s account to the attacker’s account. The browser automatically sends the example-bank.com cookies (including the authentication cookie) with this request. If the example-bank.com server lacks XSRF protection, it can’t tell the difference between a legitimate request from the application and the forged request from evil.com.
To prevent this, the application must ensure that a user request originates from the real application, not from a different site. The server and client must cooperate to thwart this attack.
In a common anti-XSRF technique, the application server sends a randomly generated authentication token in a cookie. The client code reads the cookie and adds a custom request header with the token in all subsequent requests. The server compares the received cookie value to the request header value and rejects the request if the values are missing or don’t match. This technique is effective because all browsers implement the same origin policy. Only code from the website on which cookies are set can read the cookies from that site and set custom headers on requests to that site. That means only your application can read this cookie token and set the custom header. The malicious code on evil.com can’t.

OAuth

Q - What is OAuth?

OAuth is an open-standard authorization protocol or framework that provides applications the ability for “secure designated access.” For example, you can tell Facebook that it’s OK for ESPN.com to access your profile or post updates to your timeline without having to give ESPN your Facebook password. This minimizes risk in a major way: In the event ESPN suffers a breach, your Facebook password remains safe.

OAuth doesn’t share password data but instead uses authorization tokens to prove an identity between consumers and service providers. OAuth is an authentication protocol that allows you to approve one application interacting with another on your behalf without giving away your password.

Q - Give an example of OAuth?

The simplest example of OAuth in action is one website saying “hey, do you want to log into our website with other website’s login?” In this scenario, the only thing the first website – let’s refer to that website as the consumer – wants to know is that the user is the same user on both websites and has logged in successfully to the service provider – which is the site the user initially logged into, not the consumer.

Facebook apps are a good OAuth use case example. Say you’re using an app on Facebook, and it asks you to share your profile and pictures. Facebook is, in this case, the service provider: it has your login data and your pictures. The app is the consumer, and as the user, you want to use the app to do something with your pictures. You specifically gave this app access to your pictures, which OAuth is managing in the background.

Your smart home devices – toaster, thermostat, security system, etc. – probably use some kind of login data to sync with each other and allow you to administer them from a browser or client device. These devices use what OAuth calls confidential authorization. That means they hold onto the secret key information, so you don’t have to log in over and over again.

Q - Give an analogy for OAuth?

Many luxury cars today come with a valet key. It is a special key you give the parking attendant and unlike your regular key, will not allow the car to drive more than a mile or two. Some valet keys will not open the trunk, while others will block access to your onboard cell phone address book. Regardless of what restrictions the valet key imposes, the idea is very clever. You give someone limited access to your car with a special key, while using your regular key to unlock everything.

An OAuth token is like that valet key.

Q - What is the problem OAuth trying to solve?

Every day new websites launch offering services which tie together functionality from other sites. A photo lab printing your online photos, a social network using your address book to look for friends, and APIs to build your own desktop application version of a popular site. These are all great services – what is not so great about some of the implementations is their request for your username and password to the other site. When you agree to share your secret credentials, not only do you expose your password to someone else (yes, that same password you also use for online banking), you also give them full access to do as they wish. They can do anything they wanted – even change your password and lock you out.

This is the problem OAuth solves. It allows you, the User, to grant access to your private resources on one site (which is called the Service Provider), to another site (called Consumer, not to be confused with you, the User). While OpenID is all about using a single identity to sign into many sites, OAuth is about giving access to your stuff without sharing your identity at all (or its secret parts).

Q - What is the difference between OAuth and OpenID?

OAuth is not an OpenID extension and at the specification level, shares only few things with OpenID – some common authors and the fact both are open specification in the realm of authentication and access control. ‘Why OAuth is not an OpenID extension?’ is probably the most frequently asked question in the group. The answer is simple, OAuth attempts to provide a standard way for developers to offer their services via an API without forcing their users to expose their passwords (and other credentials). If OAuth depended on OpenID, only OpenID services would be able to use it, and while OpenID is great, there are many applications where it is not suitable or desired. Which doesn’t mean to say you cannot use the two together. OAuth talks about getting users to grant access while OpenID talks about making sure the users are really who they say they are. They should work great together.

Q - How OAuth works?

There are 3 main players in an OAuth transaction: the user, the consumer, and the service provider. This triumvirate has been affectionately deemed the OAuth Love Triangle.

In our example, Joe is the user, Bitly is the consumer, and Twitter is the service provided who controls Joe’s secure resource (his Twitter stream). Joe would like Bitly to be able to post shortened links to his stream. Here’s how it works:

Step 1 – The User Shows Intent

Joe the User: “Hey, Bitly, I would like you to be able to post links directly to my Twitter stream.”
Bitly the Consumer: “Great! Let me go ask for permission.”

Step 2 – The Consumer Gets Permission

Bitly: “I have a user that would like me to post to his stream. Can I have a request token?”
Twitter the Service Provider: “Sure. Here’s a token and a secret.”

The secret is used to prevent request forgery. The consumer uses the secret to sign each request so that the service provider can verify it is actually coming from the consumer application.

Step 3 – The User Is Redirected to the Service Provider

Bitly: “OK, Joe. I’m sending you over to Twitter so you can approve. Take this token with you.”
Joe: “OK!”

Bitly directs Joe to Twitter for authorization.

This is the scary part. If Bitly were super-shady Evil Co. it could pop up a window that looked like Twitter but was really phishing for your username and password. Always be sure to verify that the URL you’re directed to is actually the service provider (Twitter, in this case).

Step 4 – The User Gives Permission

Joe: “Twitter, I’d like to authorize this request token that Bitly gave me.”
Twitter: “OK, just to be sure, you want to authorize Bitly to do X, Y, and Z with your Twitter account?”
Joe: “Yes!”
Twitter: “OK, you can go back to Bitly and tell them they have permission to use their request token.”

Twitter marks the request token as “good-to-go,” so when the consumer requests access, it will be accepted (so long as it’s signed using their shared secret).

Step 5 – The Consumer Obtains an Access Token

Bitly: “Twitter, can I exchange this request token for an access token?”
Twitter: “Sure. Here’s your access token and secret.”

Step 6 – The Consumer Accesses the Protected Resource

Bitly: “I’d like to post this link to Joe’s stream. Here’s my access token!”
Twitter: “Done!”

In our scenario, Joe never had to share his Twitter credentials with Bitly. He simply delegated access using OAuth in a secure manner. At any time, Joe can login to Twitter and review the access he has granted and revoke tokens for specific applications without affecting others. OAuth also allows for granular permission levels. You can give Bitly the right to post to your Twitter account, but restrict LinkedIn to read-only access.

(This is an article posted to my blog at overreacted.io. You can read it online by clicking here.)

Dan Abramov's Overreacted Blog RSS Feed

Git

Configure your Git username/email

To set your global username/email configuration

To set repository-specific username/email configuration:

.gitignore file

Add global .gitignore file

Git command to show which specific files are ignored by .gitignore

Check which .gitignore file is responsible for ignoring the file.

Miscellaneous

Robocopy

Q - How to replicate a directory file structure with empty files?

Unix Commands

Q - How to use sed to find and replace text in files in Unix shell?

Q - How to stop running port in mac?

Mac OS Keyboard Shortcuts

Keyboard Shortcuts

Mac OS System

System

Change the default Mac app for specific file types

No title

නිවන් මග ප්‍රායෝගික පුහුණුව 01 Buddothpado (methmal arana)

No title

වචන අර්ථ

සිත හැදෙන හැටි

ආත්මීය දැනීම හැදෙන හැටි

තද ගතිය කියන හිත හැදෙන හැටි

ශබ්දයක් ඇසෙන කොට හිත හැදෙන හැටි

ලෝකය බොරුවක් වන්නේ කෙසේද?

කාලය

කාලය ගැන සංකල්ප හැදෙන හැටි

පොඩි දරුවෙකුට කාලය ගැන හැගීමක් නොමැති හැටි

පැය, දින, සති, මාස, අවුරුදු හැදෙන හැටි

විශ්වය, පෘථිවිය අවුරුදු බිලියන ගානකට කලින් හැදෙන හැටි

සංසාරේ අනන්ත බව හැදෙන හැටි

අතීතය, අනාගතය පනවන්න බැහැ

වර්තමානය කියල දේකුත් පනවන්න බැහැ

අවකාශය

අවබෝධය ලැබූ පුද්ගලයා සහ නොලැබූ පුද්ගලයාගේ අවසානය

ප්‍රායෝගික පුහුණුව

ප්‍රශ්නයේ මුල විමසන්න

සිතුවිලි පාලනය කරන්න එපා

ලෝකය දැනගෙන රගපාන්න

මතවාදයක් තියාගන්න එපා

අවබෝධය යනු මුලාවක් බව දැනගන්න

youtube-dl

youtube-dl

Q - How to download a youtube playlist with 360p video quality with custom name?

Minikube

Install Minikube with podman

Setup Podman

Setup minikube

Deploy application in minikube

Troubleshooting

standardinitlinux.go:228: exec user process caused: exec format error

Test

Concurrent Mode and Suspense

Concurrent Mode and Suspense

Q - What Is Concurrent Mode?

Q - What are the two rendering strategies?

Q - Explain Concurrent Mode by taking version control as a metaphor?

Q - Explain interruptible rendering which is used in Concurrent mode.

Q - how Concurrent mode solves the problem of having jarring loading experience when navigating between screens. (Intentional loading sequence)

Q - What are the two most problems Concurrent mode is solving?

Q - How Concurrency mode integrate the findings from Human-Computer Interaction research in to real UIs?

Pracical Interview Questions

Practical Interview Questions

Q - Write code using a ref hook to toggle the case of input text to uppercase and lower case upon clicking a button.

Q - Say if you have a child component which is having a deep tree itself. If we want to prevent unnecessary rerendering for that component, how could we achieve that?

Q - Say I need to derive a value for a variable by doing expensive computation, and I need to show this variable value in the component. Is there any way that I could only do this computation once and use it with next rerenders?

Q - Say if I want to load a particualr page component related JavaScript code on demand. Perhaps when user is navigating to that page itself. How would I do that?

Q - Say I want to show a counter value in the screen and this value should be incremented every second. And upon clicking a button, you want to stop this counter getting incremented automatically. How would you do this?

React Architecuture

React Architecture

Q - What is React?

Q - What are the features of React?

Q - What are the advantages of using React?

Q - What are the limitations of React?

Q - How does React work?

Q - What do you understand by Virtual DOM? Explain its working.

Q - How do I implement `shouldComponentUpdate`?

Q - How to read an often-changing value from `useCallback`?