ALGORITHM

COMPUTATION

CRYPTOGRAPHY

FRONTEND

GAME-THEORY

INVESTMENT

JS&TS

LINUX

MATHEMATICS

NODE

PROJECT-PRACTICE

REACT

THOUGHTS

古文整理

文史哲艺


先君子嘗言：鄉先輩左忠毅公視學京畿。一日，風雪嚴寒，從數騎出，微行，入古寺。廡下一生伏案臥，文方成草。公閱畢，即解貂覆生，為掩戶，叩之寺僧，則史公可法也。及試，吏呼名，至史公，公瞿然注視。呈卷，即面署第一；召入，使拜夫人，曰：「吾諸兒碌碌，他日繼吾志事，惟此生耳。」

及左公下廠獄，史朝夕窺獄門外。逆閹防伺甚嚴，雖家僕不得近。久之，聞左公被炮烙，旦夕且死，持五十金，涕泣謀於禁卒，卒感焉。一日使史公更敝衣草屨，背筐，手長鑱，為除不潔者，引入，微指左公處，則席地倚牆而坐，面額焦爛不可辨，左膝以下，筋骨盡脫矣。史前跪，抱公膝而嗚咽。公辨其聲，而目不可開，乃奮臂以指撥眥，目光如炬。怒曰：「庸奴！此何地也，而汝前來！國家之事，糜爛至此。老夫已矣，汝復輕身而昧大義，天下事誰可支拄者！不速去，無俟姦人構陷，吾今即撲殺汝！」因摸地上刑械，作投擲勢。史噤不敢發聲，趨而出。後常流涕述其事以語人曰：「吾師肺肝，皆鐵石所鑄造也！」

崇禎末，流賊張獻忠出沒蘄、黃、潛、桐間，史公以鳳廬道奉檄守禦，每有警，輒數月不就寢，使將士更休，而自坐幄幕外，擇健卒十人，令二人蹲踞，而背倚之，漏鼓移，則番代。每寒夜起立，振衣裳，甲上冰霜迸落，鏗然有聲。或勸以少休，公曰：「吾上恐負朝廷，下恐愧吾師也。」史公治兵，往來桐城，必躬造左公第，候太公、太母起居，拜夫人於堂上。

余宗老塗山，左公甥也，與先君子善，謂獄中語乃親得之於史公云。


左忠毅公軼事


沈煉，字純甫，會稽人。嘉靖十七年進士。除溧陽知縣。用伉倨，忤御史，調茬平。父憂去，補淸豐，入爲錦衣衞經歴。

煉爲人剛直，嫉惡如仇，然頗疎狂。毎飲酒輒箕踞笑傲，旁若無人。錦衣帥陸炳善遇之。炳與嚴嵩父子交至深，以故煉亦數從世蕃飲。世蕃以酒虐客，煉心不平，輒爲反之，世蕃憚不敢較。

會俺答犯京師，致書乞貢，多嫚語。下廷臣博議，司業趙貞吉請勿許。廷臣無敢是貞吉者，獨煉是之。吏部尚書夏邦謨曰：「若何官？」煉曰：「錦衣衞經歴沈煉也。大臣不言，故小吏言之。」遂罷議。煉憤國無人，致寇猖狂，疎請以萬騎護陵寢，萬騎護通州軍儲，而合勤王師十余萬人，撃其惰歸，可大得誌。帝弗省。

嵩貴幸用事，邊臣爭致賄遺。及失事懼罪，益輦金賄嵩，賄日以重。煉時時搤腕。一日從尚寶丞張遜業飲，酒半及嵩，因慷慨罵詈，流涕交頤。遂上疎言：「昨歳俺答犯順，陛下奮揚神武，欲乘時北伐，此文武群臣所願戮力者也。然制勝必先廟算，廟算必先爲天下除奸邪，然後外寇可平。今大學士嵩，貪婪之性疾入膏肓，愚鄙之心頑於鐵石。當主憂臣辱之時，不聞延訪賢豪，咨詢方略，惟與子世蕃規圖自便。忠謀則多方沮之，諛諂則曲意引之。要賄鬻官，沽恩結客。朝廷賞一人，曰：『由我賞之』；罰一人，曰：『由我罰之』。人皆伺嚴氏之愛惡，而不知朝廷之恩威，尚忍言哉！姑舉其罪之大者言之。納將帥之賄，以啓邊陲之釁，一也。受諸王餽遺，毎事陰爲之地，二也。攬吏部之權，雖州縣小吏亦皆貨取，致官方大壞，三也。索撫按之歳例，致有司遞相承奉，而閭閻之財日削，四也。陰制諫官，俾不敢直言，五也。妬賢嫉能，一忤其意，必致之死，六也。縱子受財，斂怨天下，七也。運財還家，月無虚日，致道途驛騷，八也。久居政府，擅寵害政，九也。不能協謀天討，上貽君父憂，十也。」因並論邦謨諂諛黷貨狀。請均罷斥，以謝天下。帝大怒，搒之數十，謫佃保安。

旣至，未有館舍。賈人某詢知其得罪故，徙家舍之。裏長老亦日致薪米，遣子弟就學。煉語以忠義大節，皆大喜。塞外人素戇直，又諗知嵩惡，爭詈嵩以快煉。煉亦大喜，日相與詈嵩父子爲常。且縛草爲人，象李林甫、秦檜及嵩，醉則聚子弟攢射之。或踔騎居庸關口，南向戟手詈嵩，復痛哭乃歸。語稍稍聞京師，嵩大恨，思有以報煉。

先是，許論總督宣、大，常殺良民冒功，煉貽書誚讓。後嵩黨楊順爲總督。會俺答入寇，破應州四十余堡，懼罪，欲上首功自解，縱吏士遮殺避兵人，逾於論。煉遺書責之加切。又作文祭死事者，詞多刺順。順大怒，走私人白世蕃，言煉結死士撃劍習射，意叵測。世蕃以屬巡按御史李鳳毛。鳳毛謬謝曰：「有之，已陰散其黨矣。」旣而代鳳毛者路楷，亦嵩黨也。世蕃屬與順合圖之，許厚報。兩人日夜謀所以中煉者。會蔚州妖人閻浩等素以白蓮教惑衆，出入漠北，泄邊情爲患。官軍捕獲之，詞所連及甚衆。順喜，謂楷曰：「是足以報嚴公子矣。」竄煉名其中，誣浩等師事煉，聽其指揮，具獄上。嵩父子大喜。前總督論適長兵部，竟覆如其奏。斬煉宣府市，戍子襄極邊。予順一子錦衣千戸，楷待銓五品卿寺。時三十六年九月也。順曰：「嚴公薄我賞，意豈未愜乎？」取煉子袞、褒杖殺之，更移檄逮襄。襄至，掠訊方急，會順、楷以他事逮，乃免。

後嵩敗，世蕃坐誅。臨刑時，煉所教保安子弟在太學者，以一帛署煉姓名官爵於其上，持入市。觀世蕃斷頭訖，大呼曰：「沈公可暝目矣。」因慟哭而去。

隆慶初，詔褒言事者。贈煉光祿少卿，任一子官。襄乃上書，言順、楷殺人媚奸狀。給事中魏時亮、陳瓚亦相繼論之。遂下順、楷吏，論死。天啓初，諡忠湣。

---

楊繼盛，字仲芳，容城人。七歳失母。庶母妬，使牧牛。繼盛經裏塾，睹里中兒讀書，心好之。因語兄，請得從塾師學。兄曰：「若幼，何學？」繼盛曰：「幼者任牧牛，乃不任學耶？」兄言於父，聽之學，然牧不廢也。年十三歳，始得從師學。家貧，益自刻厲。舉鄕試，卒業國子監，徐階丞賞之。嘉靖二十六年登進士。授南京吏部主事。從尚書韓邦奇遊，覃思律呂之學，手制十二律，吹之聲畢和。邦奇大喜，盡以所學授之，繼盛名益著。召改兵部員外郎。

俺答躪京師，鹹寧侯仇鸞以勤王故有寵。帝命鸞爲大將軍，倚以辦寇。鸞中情怯，畏寇甚。方請開互市市馬，冀與俺答媾，幸無戰鬥，固恩寵。繼盛以爲讎恥未雪，遽議和示弱，大辱國，乃奏言十不可、五謬。大略謂：

互市者，和親別名也。俺答蹂躪我陵寢，虔劉我赤子。天下大讎也，而先之和。不可一。往下詔北伐，天下曉然知聖意，日夜征繕助兵食。忽更之曰和，失信於天下。不可二。以堂堂中國，與之互市，冠履倒置。不可三。海内豪傑爭磨礪待試，一旦委置無用。異時欲號召，誰復興起？不可四。使邊鎭將帥以和議故，美衣兪食，馳懈兵事。不可五。往時邊卒私通境外，吏率裁禁，今乃導之使與通。不可六。盜賊伏莽，徒懾國威不敢肆耳，今知朝廷畏怯，睥睨之漸必開。不可七。俺答往歳深入，乘我無備故也。備之一歳，以互市終。彼謂國有人乎？不可八。或俺答負約不至；至矣，或陰謀伏兵突入；或今日市，明日復寇；或以下馬索上直。不可九。歳帛數十萬，得馬數萬匹。十年以後，帛將不繼。不可十。

議者曰：「吾外爲市以羈縻之，而内修我甲。」此一謬也。夫寇欲無厭，其以釁終明甚。茍内修武備，安事羈縻？曰：「吾陰市，以益我馬」。此二謬也。夫和則不戰，馬將焉用？且彼寧肯予我良馬哉？曰：「市不已，彼且入貢」。此三謬也。夫貢之賞不貲，是名美而實大損也。曰：「俺答利我市，必無失信」。此四謬也。吾之市，能盡給其衆乎？能信不給者之無入掠乎？曰：「佳兵不祥」。此五謬也。敵加己而應之，何佳也？人身四肢皆癰疽，毒日内攻，而憚用藥石可乎？

夫此十不可、五謬，明顯易見。蓋有爲陛下主其事者，故公卿大夫知而莫爲一言。陛下宜奮獨斷，悉按諸言互市者，發明詔選將練兵。不出十年，臣請爲陛下竿俺答之首於槁街，以示天下萬世。

疎入，帝頗心動，下鸞及成國公朱希忠，大學士嚴嵩、徐階、呂本，兵部尚書趙錦，侍郎聶豹、張時徹議。鸞攘臂詈曰：「豎子目不睹寇，宜其易之。」諸大臣遂言遣官已行，勢難中止。帝尚猶豫，鸞復進密疎。乃下繼盛詔獄，貶狄道典史。其地雜番，俗罕知詩書。繼盛簡子弟秀者百余人，聘三經師教之。鬻所乘馬，出婦服裝，市田資諸生。縣有煤山，爲番人所據，民仰薪二百里外。繼盛召番人諭之，鹹服曰：「楊公卽須我曹穹帳亦舍之，況煤山耶？」番民信愛之，呼曰「楊父」。

已而俺答數敗約入寇，鸞奸大露，疽發背死，戮其屍。帝乃思繼盛言，稍遷諸城知縣。月余調南京戸部主事，三日遷刑部員外郎。當是時，嚴嵩最用事。恨鸞淩己，心善繼盛首攻鸞，欲驟貴之，復改兵部武選司。而繼盛惡嵩甚於鸞。且念起謫籍，一歳四遷官，思所以報國。抵任甫一月，草奏劾嵩，齋三日乃上奏曰：

臣孤直罪臣，蒙天地恩，超擢不次。夙夜祗懼，思圖報稱，蓋未有急於請誅賊臣者也。方今外賊惟俺答，内賊惟嚴嵩，未有内賊不去，而可除外賊者。去年春雷久不聲，占曰：「大臣專政」。冬日下有赤色，占曰：「下有叛臣」。又四方地震，日月交食。臣以爲災皆嵩致，請以嵩十大罪爲陛下陳之。

髙皇帝罷丞相，設立殿閣之臣，備顧問視制草而已，嵩乃儼然以丞相自居。凡府部題覆，先面白而後草奏。百官請命，奔走直房如市。無丞相名，而有丞相權。天下知有嵩，不知有陛下。是壞祖宗之成法。大罪一也。

陛下用一人，嵩曰「我薦也」；斥一人，曰「此非我所親，故罷之」。陛下宥一人，嵩曰「我救也」；罰一人，曰「此得罪於我，故報之」。伺陛下喜怒以恣威福。群臣感嵩甚於感陛下，畏嵩甚於畏陛下。是竊君上之大權。大罪二也。

陛下有善政，嵩必令世蕃告人曰：「主上不及此，我議而成之」。又以所進掲帖刊刻行世，名曰《嘉靖疎議》，欲天下以陛下之善盡歸於嵩。是掩君上之治功。大罪三也。

陛下令嵩司票擬，蓋其職也。嵩何取而令子世蕃代擬？又何取而約諸義子趙文華輩群聚而代擬？題疎方上，天語已傳。如沈煉劾嵩疎，陛下以命呂本，本卽潛送世蕃所，令其擬上。是嵩以臣而竊君之權，世蕃復以子而盜父之柄，故京師有「大丞相、小丞相」之謠。是縱奸子之僭竊。大罪四也。

嚴效忠、嚴鵠，乳臭子耳，未嘗一渉行伍。嵩先令效忠冒兩廣功，授錦衣所鎭撫矣。效忠以病告，鵠襲兄職。又冒瓊州功，擢千戸。以故總督歐陽必進躐掌工部，總兵陳圭幾統後府，巡按黃如桂亦驟亞太仆。旣藉私黨以官其子孫，又因子孫以拔其私黨。是冒朝廷之軍功。大罪五也。

逆鸞先已下獄論罪，賄世蕃三千金，薦爲大將。鸞冒擒哈舟丹兒功，世蕃亦得增秩。嵩父子自誇能薦鸞矣，及知陛下有疑鸞心，復互相排詆，以泯前跡。鸞勾賊，而嵩、世蕃復勾鸞。是引背逆之奸臣。大罪六也。

前俺答深入，撃其惰歸，此一大機也。兵部尚書丁汝夔問計於嵩，嵩戒無戰。及汝夔逮治，嵩復以論救紿之。汝夔臨死大呼曰：嵩誤我。是誤國家之軍機。大罪七也。

郎中徐學詩劾嵩革任矣，復欲斥其兄中書舍人應豐。給事厲汝進劾嵩謫典史矣，復以考察令吏部削其籍。内外之臣，被中傷者何可勝計？是專黜陟之大柄。大罪八也。

凡文武遷擢，不論可否，但衡金之多寡而畀之。將弁惟賄嵩，不得不朘削士卒；有司惟賄嵩，不得不掊克百姓。士卒失所，百姓流離，毒遍海内。臣恐今日之患不在境外而在域中。是失天下之人心。大罪九也。

自嵩用事，風俗大變。賄賂者薦及盜跖，疎拙者黜逮夷、齊。守法度者爲迂疎，巧彌縫者爲才能。勵節介者爲矯激，善奔者爲練事。自古風俗之壞，未有甚於今日者。蓋嵩好利，天下皆尚貪。嵩好諛，天下皆尚諂。源之弗潔，流何以澄？是敝天下之風俗。大罪十也。

嵩有是十罪，而又濟之以五奸。知左右侍從之能察意旨也，厚賄結納。凡陛下言動舉措，莫不報嵩。是陛下之左右皆賊嵩之間諜也。以通政司之主出納也，用趙文華爲使。凡有疎至，先送嵩閲竟，然後入禦。王宗茂劾嵩之章停五日乃上，故嵩得展轉遮飾。是陛下之喉舌乃賊嵩之鷹犬也。畏廠衞之緝訪也，令子世蕃結爲婚姻。陛下試詰嵩諸孫之婦，皆誰氏乎？是陛下之爪牙皆賊嵩之瓜葛也。畏科道之多言也，進士非其私屬，不得預中書、行人選。推官、知縣非通賄，不得預給事、御史選。旣選之後，入則杯酒結歡，出則饋饣盡相屬。所有愛憎，授之論刺。歴俸五六年，無所建白，卽擢京卿。諸臣忍負國家，不敢忤權臣。是陛下之耳目皆賊嵩之奴隸也。科道雖入籠絡，而部寺中或有如徐學詩之輩亦可懼也，令子世蕃擇其有才望者，羅置門下。凡有事欲行者，先令報嵩，預爲布置，連絡蟠結，深根固蒂，各部堂司大半皆其羽翼。是陛下之臣工皆賊嵩之心膂也。陛下奈何愛一賊臣，而忍百萬蒼生陷於塗炭哉？

至如大學士徐階蒙陛下特擢，乃亦毎事依違，不敢持正，不可不謂之負國也。願陛下聽臣之言，察嵩之奸。或召問裕、景二王，或詢諸閣臣。重則置憲，輕則勒致仕。内賊旣去，外賊自除。雖俺答亦必畏陛下聖斷，不戰而喪膽矣。

疎入，帝已怒。嵩見召問二王語，喜謂可指此爲罪，密構於帝。帝益大怒，下繼盛詔獄，詰何故引二王。繼盛曰：「非二王誰不懾嵩者！」獄上，乃杖之百，令刑部定罪。侍郎王學益，嵩黨也。受嵩屬，欲坐詐傳親王令旨律絞，郎中史朝賓持之。嵩怒，謫之外。於是尚書何鰲不敢違，竟如嵩指成獄，然帝猶未欲殺之也。系三載，有爲營救於嵩者。其黨胡植、鄢懋卿怵之曰：「公不睹養虎者耶，將自貽患。」嵩頷之。會都御史張經、李天寵坐大辟。嵩揣帝意必殺二人，比秋審，因附繼盛名並奏，得報。其妻張氏伏闕上書，言：「臣夫繼盛誤聞市井之言，尚狃書生之見，遂發狂論。聖明不卽加戮，俾從吏議。兩經奏讞，倶荷寬恩。今忽闌入張經疎尾，奉旨處決。臣仰惟聖德，昆蟲草木皆欲得所，豈惜一回宸顧，下垂覆盆？倘以罪重，必不可赦，願卽斬臣妾首，以代夫誅。夫雖遠禦魑魅，必能爲疆塲效死，以報君父。」嵩屛不奏，遂以三十四年十月朔棄西市，年四十。臨刑賦詩曰：「浩氣還太虚，丹心照千古。生平未報恩，留作忠魂補。」天下相與涕泣傳頌之。

初，繼盛之將杖也，或遺之蚺蛇膽。卻之曰：「椒山自有膽，何蚺蛇爲！」椒山，繼盛別號也。及入獄，創甚。夜半而蘇，碎瓷碗，手割腐肉。肉盡，筋掛膜，復手截去。獄卒執燈顫欲墜，繼盛意氣自如。朝審時，觀者塞衢，皆嘆息，有泣下者。後七年，嵩敗。穆宗立，恤直諫諸臣，以繼盛爲首。贈太常少卿，諡忠湣，予祭葬，任一子官。已，又從御史郝傑言，建祠保定，名旌忠。

後繼盛論馬市得罪者，何光裕、龔愷。


沈煉 楊繼盛传


## Dynamic link library

### Compile

The gcc compiler can compile code into a DLL dynamic link library in Windows. However, it should be noted that in Windows, the naming convention of dynamic link libraries is different from systems such as Linux. In Windows, the naming convention of dynamic link libraries is usually `<name>.dll` or `lib<name>.dll`, where `<name>` is the name of the dynamic link library.

In addition, specific compilation options and link options need to be used when compiling dynamic link libraries, such as:

- Use the `-shared` option to specify compilation as a dynamic link library.
- Use the `-fPIC` option to generate position-independent code so that dynamic link libraries can be loaded correctly at runtime.

First write the code of the library. Suppose we define a Hello function in the library:

```c
// hello.c
#include <stdio.h>
void hello() {
    printf("Hello, world!\n");
}
```

Here is a simple command example that demonstrates how to use the gcc compiler to compile code into a DLL dynamic link library in Windows:

```bash
gcc -shared -fPIC -o hello.dll hello.c
```

This will generate a dynamic link library named `hello.dll`.

If you are on a Unix-like platform, the dynamic link library convention is different from Windows, and it uses the `so` suffix. So the compilation command can be written as follows:

```bash
gcc -shared -fPIC -o libhello.so hello.c
```

### Usage

To use a dynamic link library, you must first give the header file of this library: define the relevant declarations in the library. We write a header file for the Hello library:

```c
// hello.h
#ifndef HELLO_H_
#define HELLO_H_
int hello();
#endif // HELLO_H_
```

In Windows, introducing a dynamic link library requires the help of library functions defined in Windows.h provided by the Windows SDK

```c
// main.c
#include <windows.h>
#include <stdio.h>
#include "hello.h"
int main() {
    HINSTANCE hInstLibrary = LoadLibrary("hello.dll");
    if (hInstLibrary == NULL) {
        printf("Failed to load DLL.\n");
        return 1;
    }
    // Get the function address in DLL
    void (*pFnHello)() = (void (*)())GetProcAddress(hInstLibrary, "hello");
    if (pFnHello == NULL) {
        printf("Failed to get function hello.\n");
        FreeLibrary(hInstLibrary);
        return 1;
    }
    // Call the function in DLL
    pFnHello();
    // Release DLL
    FreeLibrary(hInstLibrary);
    return 0;
}
```

If it is a Unix-like platform, it can be referenced like this

```c
// main.c
#include <stdio.h>
#include <dlfcn.h>
#include "hello.h"
int main() {
    void* handle = dlopen("./libhello.so", RTLD_LAZY);
    if (!handle) {
        fprintf(stderr, "Error: %s\n", dlerror());
        return 1;
    }
    int (*hello)(int, int) = dlsym(handle, "hello");
    if (!hello) {
        fprintf(stderr, "Error: %s\n", dlerror());
        dlclose(handle);
        return 1;
    }
    hello();
    dlclose(handle);
    return 0;
}
```

Then compile the target program

```bash
gcc main.c
```

## Static link library

### Compile

First write the code of the library. Suppose we define a Hello function in the library:

```c
// hello.c
#include <stdio.h>
void hello() {
    printf("Hello, world!\n");
}
```

Here is a simple command example that demonstrates how to use the gcc compiler to compile code into a static link library:

First, compile the `hello.c` code into an object file

```bash
gcc -c hello.c -o hello.o
```

Then use the `ar` command to package the target file into a static library.

Executable on Windows systems

```bash
ar rcs hello.lib hello.o
```

Executable on Unix-like systems

```bash
ar rcs libhello.a hello.o
```

### Usage

Similarly, using a static link library also requires writing a header file for the library

```c
// hello.h
#ifndef HELLO_H_
#define HELLO_H_
int hello();
#endif // HELLO_H_
```

Reference library functions in the main program

```c
//main.c
#include <stdio.h>
#include "hello.h"
int main() {
    hello()
}
```

Then add the link option to the hello library when compiling the main program.

```bash
gcc main.c -L. -lhello -o main
```


Give an example: how to write dynamic and static link libraries and reference them in C programs. And how the link library works

References Dynamic-Link Libraries and Static-Link Libraries With GCC


## Spin lock

### Concept

**Spin Lock** is a lock mechanism based on busy waiting. Its implementation idea is to check in a loop whether the status of the lock is available when acquiring the lock. If the lock is occupied, it will wait in a loop. , until the lock is released. A spin lock is a non-blocking lock because it does not block the thread like a mutex lock, but waits in a loop until the lock is acquired.
Spin locks are mainly used to protect critical sections because they can achieve efficient thread synchronization on multi-core CPUs. Especially when competition in critical sections is not fierce, spin locks can reduce the cost of thread context switching, thereby improving the performance of the program. performance.
The implementation of a spin lock is very simple. An integer variable is usually used to represent the status of the lock. When the lock is occupied, the value of the variable is 1, and when the lock is available, the value of the variable is 0. During the process of acquiring the lock, the thread will continuously check the lock status in a loop until it finds that the lock is available, then sets the lock status to 1 and returns success. When the lock is released, the thread resets the lock's status to 0, allowing other threads to acquire the lock.
It should be noted that although spin locks can reduce the cost of thread context switching, when competition in the critical section is fierce, the efficiency of spin locks will become worse because it will cause threads to be busy waiting, wasting CPU resources.

The spin lock will keep busy waiting when the resource is occupied, and continuously loop to check whether the resource is available until the resource is obtained. On multi-core CPUs, spin locks can be implemented using atomic operation instructions such as CAS (Compare And Swap) provided by the hardware, thereby avoiding lock competition and the overhead of thread context switching. On a single-core CPU, the efficiency of the spin lock may be relatively low because it will always occupy CPU resources, causing other threads to be unable to execute. Therefore, in practical applications, it is necessary to select an appropriate lock mechanism according to the specific situation.

Therefore, in practical applications, it is necessary to select an appropriate lock mechanism according to the specific situation.

### Usage

Spin lock is a lock mechanism based on busy waiting. It continuously checks whether the shared resource is occupied while waiting for the shared resource to be released. If the shared resource is already occupied, wait until the shared resource is released; if the shared resource is not occupied, lock and access the shared resource. Spin lock is suitable for the following scenarios:

1. Occupation of shared resources in a short period of time: When shared resources are occupied for a short period of time and the waiting time is short, using spin locks can avoid the overhead of threads entering sleep state and thread context switching, thereby improving program performance. .
2. The number of threads accessing shared resources is small: Spin locks are suitable for situations where the number of threads accessing shared resources is small, because when the number of threads accessing shared resources is large, the busy waiting of spin locks will consume a lot of CPU resources. , resulting in reduced program performance.
3. Hardware support: Spin locks require hardware support to implement busy waiting, so they are suitable for systems using multi-processors or multi-core processors. It should be noted that spin locks are not suitable for scenarios with long waiting times, because long busy waiting will consume a large amount of CPU resources, resulting in system performance degradation. In the case of long waiting time, other lock mechanisms should be used, such as mutual exclusion locks, read-write locks, etc.

## Read-write lock

### Concept

**Read-Write Lock**, also known as shared-exclusive lock, is a special lock mechanism that allows multiple threads to read shared resources at the same time, but only allows one thread to write to shared resources . Read-write locks can effectively improve the concurrency performance of the program, especially when read operations are more frequent than write operations, it can reduce lock competition and improve the concurrency performance of the program.
The implementation of read-write lock is very simple, usually using a counter and a mutex lock to represent the lock status. When a thread wants to read a shared resource, it will first try to acquire a read lock. If no thread currently holds a write lock, the read operation can continue. If a thread holds a write lock, the read operation must wait for the write lock to be released. When a thread wants to write to a shared resource, it will first try to obtain a write lock. If no thread currently holds a read lock or write lock, the write operation can continue. If a thread holds a read or write lock, the write operation must wait for all read and write locks to be released.
It should be noted that although read-write locks can improve the concurrency performance of the program, the advantages of read-write locks may be weakened when write operations are frequent. Because each write operation must wait for both the read lock and the write lock to be released, the read operation will also be blocked, affecting the performance of the program. Therefore, in practical applications, it is necessary to select an appropriate lock mechanism according to the specific situation.

### Usage

Read-write lock is a special lock mechanism that allows multiple threads to read shared resources at the same time, but when writing to shared resources, they must be mutually exclusive. Read-write locks are suitable for the following scenarios:

1. There are far more read operations than write operations: When there are far more read operations than write operations, read-write locks can be used to improve the concurrency performance of the program. Read-write locks allow multiple threads to read shared resources at the same time, thereby reducing mutual exclusion competition between threads and improving the concurrency performance of the program.
2. The reading operation of shared resources is time-consuming: When the reading operation of shared resources is time-consuming, read-write locks can be used to improve the performance of the program. Read-write locks allow multiple threads to read shared resources at the same time, thereby reducing mutual exclusion competition between threads and the cost of thread context switching, and improving program performance.
3. There are fewer write operations on shared resources: When there are fewer write operations on shared resources, read-write locks can be used to improve the concurrency performance of the program. Read-write locks must be mutually exclusive when writing to shared resources, but multiple threads are allowed to do so at the same time when reading shared resources, thereby reducing mutual exclusion competition between threads and improving the concurrency performance of the program. It should be noted that read-write locks are suitable for scenarios where there is more reading and less writing. When the ratio of read-write operations is close, the performance of read-write locks may not be as good as that of mutex locks. In addition, when using read-write locks, you need to pay attention to the lock granularity to avoid the lock granularity being too fine or too coarse, which will affect the performance of the program.

## Mutex lock

### Concept

**Mutex (Mutex)** is the most basic lock mechanism, which can ensure that only one thread can access shared resources at the same time. When using a mutex lock, when one thread acquires the lock, other threads must wait for this thread to release the lock before they can acquire the lock. This can avoid data competition and inconsistency problems caused by multiple threads modifying shared resources at the same time.
Mutex locks are usually implemented using two operations: lock and unlock. When a thread wants to access a shared resource, it needs to first try to acquire the lock. If no other thread currently holds the lock, the thread can obtain the lock and access the shared resource. If another thread holds the lock, that thread must wait for the lock to be released. After the access is complete, the thread needs to release the lock so that other threads can obtain the lock and access the shared resource.
It should be noted that although using a mutex lock can ensure that only one thread can access shared resources at the same time, frequent locking and unlocking will cause program performance to decrease, because locking and unlocking operations require the overhead of system calls and kernel switching. . Therefore, in practical applications, mutex locks need to be used with caution to avoid excessive lock competition and lock waiting.

### Usage

Mutex lock is a common lock mechanism that ensures that only one thread can access shared resources at the same time, thereby avoiding mutual exclusion competition between threads. Mutex locks are suitable for the following scenarios:

1. Occupation of shared resources in a short period of time: When shared resources are occupied for a short period of time and the waiting time is short, using a mutex lock can avoid the overhead of threads entering sleep state and thread context switching, thereby improving program performance. .
2. The number of threads accessing shared resources is small: Mutex locks are suitable for situations where the number of threads accessing shared resources is small, because when the number of threads accessing shared resources is large, competition for mutex locks will become fierce, resulting in The performance of the program decreases.
3. There is less code in the critical section: Mutex lock is suitable for situations where there is less code in the critical section, because when there is more code in the critical section, the competition for the mutex lock will become fierce, resulting in a decrease in program performance.
4. Strong demand for synchronization: Mutex lock is suitable for situations where synchronization demand is strong, because it can ensure that only one thread can access shared resources at the same time, thereby avoiding mutual exclusion competition and data conflicts between threads. It should be noted that when mutex locks are used in a multi-threaded environment, deadlocks and other problems may occur. Therefore, issues such as lock granularity and locking order need to be considered to avoid deadlocks and other problems. In addition, when using mutex locks, you need to pay attention to lock performance issues to avoid excessive use of mutex locks, which may lead to program performance degradation.

## Optimistic locking and pessimistic locking

Optimistic locking and pessimistic locking are two different locking mechanisms used to solve data competition problems when accessing shared resources concurrently.
**Pessimistic locking is a pessimistic idea. It believes that in a concurrent environment, shared resources can easily be modified by other threads. Therefore, a lock must be locked every time a shared resource is accessed to ensure that only one thread can access the shared resource at the same time. .** The representative of pessimistic lock is a mutex lock, which can ensure that only one thread can access shared resources at the same time. However, locking and unlocking are expensive, **and can easily lead to a decrease in program performance.**

Optimistic locking is an optimistic idea. **It believes that in a concurrent environment, shared resources are rarely modified by other threads. Therefore, each time a shared resource is accessed, it is not locked. Instead, the shared resource is read first** and Check the version number and other information of the shared resource before modifying it. If it has not been modified, modify it and update the version number and other information. Otherwise, give up the modification and try again. Optimistic locks are represented by operations such as lock-free programming and CAS (Compare And Swap), which can reduce lock competition and thread context switching overhead, and improve the concurrency performance of the program.
It should be noted that although optimistic locking can improve the concurrency performance of the program, when shared resources are modified frequently concurrently, the number of retries of the optimistic lock may increase, resulting in a decrease in program performance. Therefore, in practical applications, it is necessary to select an appropriate lock mechanism according to the specific situation.


Analysis and usage scenarios of spin lock, optimistic lock, pessimistic lock, read-write lock, mutex lock and other concepts.

Resource Lock in Concurrency


## Proposition

Generally speaking, a proposition is typically composed of a declarative sentence expressing a judgment. Propositions are classified into true and false propositions. Propositions can often be assigned to a symbol for expression, such as $p, q, r$, where these symbols are called propositional variables. A simple proposition is the most basic form of a proposition that cannot be divided into sub-propositions.

For convenience in operations, the truth or falsity of a proposition is represented using binary values $p=0$ and $p=1$, where they respectively indicate false and true propositions.

### Connectives

These connectives are basic tools in formal logic, used to construct and analyze complex logical expressions that describe the combination of propositions.

- Negation (Not), denoted as $\neg$
- Conjunction (And), denoted as $\land$
- Disjunction (Or), denoted as $\lor$
- Conditional (Implies, ImpliedBy), denoted as $\implies$ and $\impliedby$
- Biconditional (If and only if), denoted as $\iff$

Multiple simple propositions are combined into compound propositions using these connectives. The precedence of these connectives decreases from top to bottom.

Their truth table is as follows:

$$
\begin{array}{|c|c|c|c|c|c|c|}
\hline
p & q & \neg p & p \land q & p \lor q & p \implies q & p \iff q \\
\hline
0 & 0 & 1 & 0 & 0 & 1 & 1 \\
\hline
0 & 1 & 1 & 0 & 1 & 1 & 0 \\
\hline
1 & 0 & 0 & 0 & 1 & 0 & 0 \\
\hline
1 & 1 & 0 & 1 & 1 & 1 & 1 \\
\hline
\end{array}
$$

### Well-formed Formulas (WFF)

1. A single propositional variable is a well-formed formula (WFF), also called an atomic proposition.
2. If $A$ is a WFF, then $(\neg A)$ is a WFF.
3. If $A$ and $B$ are WFFs, then $(A \land B)$, $(A \lor B)$, $(A \implies B)$, and $(A \iff B)$ are WFFs.
4. A string of symbols formed by applying (1)~(3) a finite number of times is a WFF.

WFFs are also called propositional formulas, or simply formulas. They are often represented as $f(p_{1}, p_{2}, ..., p_{n})$.

### Formula Levels

1. If the formula $A = f(p)$ is a single propositional variable, then $A$ is called a level-0 formula.
2. A formula $A$ is called a level-$(n+1)$ formula (for $n \geq 0$) if one of the following holds:

   - (a) $A = \neg B$, where $B$ is a level-$n$ formula;
   - (b) $A = B \land C$, where $B$ and $C$ are formulas of levels $i$ and $j$, and $n = \max(i,j)$;
   - (c) $A = B \lor C$, where the levels of $B$ and $C$ and $n$ are as in (b);
   - (d) $A = B \implies C$, where the levels of $B$ and $C$ and $n$ are as in (b);
   - (e) $A = B \iff C$, where the levels of $B$ and $C$ are as in (b).

3. If the level of formula $A$ is $k$, then $A$ is called a level-$k$ formula.
4. The formula $f(p_{1}, p_{2}, ..., p_{n})$ is used to express a formula of level $n$.

### Tautologies and Contradictions

If $\forall p_{i} \in \{0,1\}$, $A = f(p_{1}, p_{2}, ..., p_{n}) \equiv 1$, then $A$ is called a tautology, or a logically valid formula. Conversely, if $\forall p_{i} \in \{0,1\}$, $A = f(p_{1}, p_{2}, ..., p_{n}) \equiv 0$, then $A$ is called a contradiction.

If a formula is not a contradiction, it is also called a satisfiable formula.

### Dummy Variables

A dummy variable (also known as a neutral element) refers to a special element that, under a certain operation, does not change the value of other elements.

If the value of formula $A = f(p_{1}, p_{2}, ..., p_{n})$ depends only on certain variables $p_{i1}, p_{i2}, ..., p_{in}$, then the remaining variables $\{i \in Z^{*}, i \in [1,n] \setminus \{p_{i_1}, p_{i_2}, \dots, p_{in}\}\}$ are called dummy variables. Changing the dummy variables does not affect the value of the formula.

For example, in $p \land q \equiv 1$, where $q = 1$, the formula is always true regardless of the value of $p$, making $p$ a dummy variable.

### Formula Equivalence

If two formulas have the same number of variables and the same truth table (or logical behavior), then these two formulas are equivalent. In other words, if $\forall i \in \{0,1,2,...,n\}$, $p_{i} = q_{i}$, and $f(p_{1}, p_{2}, ..., p_{n}) = g(q_{1}, q_{2}, ..., q_{n})$, then $f \equiv g$, and we can say that $f$ and $g$ are logically equivalent.

## Logical Equivalence Calculus

Let formulas $A$ and $B$ share the same propositional variables, and $A$ or $B$ may contain dummy variables. If $A$ and $B$ have the same truth table, then $A \iff B$ is a tautology. This indicates that $A$ and $B$ are logically equivalent, denoted as $A \iff B$.

Below are some common identities, which can be used to perform more complex logical operations.

### Equivalence Identities

#### 1.1 Double Negation

$$
A \iff \neg \neg A
$$

#### 1.2 Idempotent Laws

$$
A \lor A \iff A, \quad A \land A \iff A
$$

#### 1.3 Commutative Laws

$$
A \lor B \iff B \lor A, \quad A \land B \iff B \land A
$$

#### 1.4 Associative Laws

$$
(A \lor B) \lor C \iff A \lor (B \lor C),\\ (A \land B) \land C \iff A \land (B \land C)
$$

#### 1.5 Distributive Laws

$$
A \lor (B \land C) \iff (A \lor B) \land (A \lor C)
$$

(Distributivity of $\lor$ over $\land$)

$$
A \land (B \lor C) \iff (A \land B) \lor (A \land C)
$$

(Distributivity of $\land$ over $\lor$)

#### 1.6 De Morgan's Laws

$$
\neg (A \lor B) \iff \neg A \land \neg B, \\ \neg (A \land B) \iff \neg A \lor \neg B
$$

#### 1.7 Absorption Laws

$$
A \lor (A \land B) \iff A, \\ A \land (A \lor B) \iff A
$$

#### 1.8 Zero Laws

$$
A \lor 1 \iff 1, \\ A \land 0 \iff 0
$$

#### 1.9 Identity Laws

$$
A \lor 0 \iff A, \\ A \land 1 \iff A
$$

#### 1.10 Law of the Excluded Middle

$$
A \lor \neg A \iff 1
$$

#### 1.11 Law of Non-Contradiction

$$
A \land \neg A \iff 0
$$

#### 1.12 Implication Identity

$$
A \rightarrow B \iff \neg A \lor B
$$

#### 1.13 Biconditional Identity

$$
A \leftrightarrow B \iff (A \rightarrow B) \land (B \rightarrow A)
$$

#### 1.14 Contrapositive

$$
A \rightarrow B \iff \neg B \rightarrow \neg A
$$

#### 1.15 Biconditional Negation

$$
A \leftrightarrow B \iff \neg A \leftrightarrow \neg B
$$

#### 1.16 Reductio ad Absurdum

$$
(A \rightarrow B) \land (A \rightarrow \neg B) \iff \neg A
$$

The 16 equivalence identities presented above contain 24 important equivalences. The variables $A$, $B$, and $C$ in the equivalence patterns can be replaced by any propositional formulas, resulting in infinitely many specific equivalences of the same type.

These are typical examples of equivalences derived from truth tables and form the foundational formulas of logical operations.


Here are some basic mathematical logic definitions, theorems, and other notes.

The Basic Formal Logic (1)


Wilson Score sorting algorithm, Wilson Score, is used for quality sorting. The data contains positive and negative reviews. Taking into account the **number of comments** and **praise rate**, the higher the score, the higher the quality.

$$
n = u + v \\
p = \frac{u}{v} \\
S = \frac{(p + \frac{z_{α}^{2}}{2n} - \frac{z_{α}^{2}}{2n}\sqrt{4n(1-p)p+z_{α}^{2}} )}{(1+\frac{z_{α}^{2}}{n})}
$$

$u$ represents the number of positive examples (good reviews), $v$ represents the number of negative examples (bad reviews), $n$ represents the total number of instances (total number of reviews), $p$ represents the positive rate, and $z$ is the score of the normal distribution. Number of bits (parameter), $S$ represents the final Wilson score. $z$ generally takes a value of 2, which is 95% confidence.

Here is the quantile table for the normal distribution:
![](https://upload-images.jianshu.io/upload_images/749674-35a2dc9beddd2083.png?imageMogr2/auto-orient/strip|imageView2/2/w/456/format/webp)

**Algorithm traits:**

1. Properties: The range of score $S$ is $[0,1)$, effect: normalized, suitable for sorting
2. Properties: When the number of positive examples $u$ is $0$, $p$ is $0$, and the score $S$ is $0$; effect: no positive comments, the score is the lowest;
3. Properties: When the number of negative examples $v$ is $0$, $p$ is $1$, degenerates to $1/(1 + z^2 / n)$, and the score $S$ is always less than $1$; effect: the score has permanent comparability;
4. Properties: When $p$ remains unchanged, the larger $n$ is, the reduction speed of the numerator is smaller than the reduction speed of the denominator, and the greater the score $S$, and vice versa; Effect: The positive rate $p$ is the same, the total number of instances is $n The more $, the more $S$ you score;
5. Properties: When $n$ tends to infinity, it degenerates to $p$, and the score $S$ is determined by $p$; Effect: When the total number of comments $n$ is more, the positive rate $p$ will bring the score $S The improvement of $ is more obvious;
6. Properties: When the quantile $z$ is larger, the total number of reviews $n$ is more important, and the praise rate $p$ is less important, and vice versa; Effect: The larger $z$ is, the total number of reviews $n$ is more important. The degree of discrimination is low; the smaller $z$ is, the more important the praise rate $p$ is;

[Click here to get source code](https://github.com/SpikeKing/MachineLearningTutorial/tree/master/wilson_score)

Python Implementation.

```python
def wilson_score(pos, total, p_z=2.):
    pos_rat = pos * 1. / total * 1.  # 正例比率
    score = (pos_rat + (np.square(p_z) / (2. * total))
             - ((p_z / (2. * total)) * np.sqrt(4. * total * (1. - pos_rat) * pos_rat + np.square(p_z)))) / \
            (1. + np.square(p_z) / total)
    return score
```

Distribution plot of Wilson score algorithm

![](https://upload-images.jianshu.io/upload_images/749674-3340e75c9438e31e.png?imageMogr2/auto-orient/strip|imageView2/2/w/1200/format/webp)

Let's try to put this theory into use with following example.

**Example:** Suppose Doctor A has 100 reviews, 1 negative review and 99 positive reviews. Doctor B has 2 reviews, both of which are good reviews. Which one should be ranked first?

When $z=2$, that is, 95% confidence level, doctor A's score is 0.9440, doctor B's score is 0.3333, and doctor A ranks in front.

---

PS: **Rating Level** Question: What should we do if we have a five-star evaluation system or a hundred percent evaluation system?

Just change the Wilson score formula from **Bernoulli distribution** to **normal distribution**.

$$
S = \frac{(μ + \frac{z_{α}^{2}}{2n} - \frac{z_{α}^{2}}{2n}\sqrt{4nσ^{2}+z_{α}^{2}} )}{(1+\frac{z_{α}^{2}}{n})} \\
μ ∈(0,1)
$$

**Note**: The mean and variance are both normalized values.

Python Implementation.

```python
def wilson_score_norm(mean, var, total, p_z=2.):
    # The mean variance needs to be normalized to fit the quantiles of the normal distribution
    score = (mean + (np.square(p_z) / (2. * total))
             - ((p_z / (2. * total)) * np.sqrt(4. * total * var + np.square(p_z)))) / \
            (1 + np.square(p_z) / total)
    return score
```

Example of normalization:

```python
def test_of_values():
    max = 5.  # Maximum evaluation value.
    min = 1.  # Minimum evaluation value.
    values = np.array([1., 2., 3., 4., 5.])  # Example

    norm_values = (values - min) / (max - min)  # Normalize
    total = norm_values.size
    mean = np.mean(norm_values)
    var = np.var(norm_values)
    return total, mean, var
```

---

PS: About the **z parameter**, that is, the normal quantile. The normal quantile affects the distribution of Wilson scores, and the value of the $z$ parameter is based on the magnitude of the number of samples. For example: the same 100 samples, 90 positive reviews, $z$ value is 2 or 6, the scores are very different, and the number of samples accommodated (or distinguished) by the system is also very different (the same is 0.82 points and 90% positive reviews, $z=2$ requires 100 samples, $z=6$ requires 1000 samples), **generally speaking, the larger the magnitude of the number of samples, the larger the value of z.**

```python
print 'score: %s' % wilson_score(90, 90 + 10, p_z=2.)
print 'score: %s' % wilson_score(90, 90 + 10, p_z=6.)
print 'score: %s' % wilson_score(900, 900 + 100, p_z=6.)

# take 2-100：score: 0.823802352689
# take 6-100：score: 0.606942322627
# take 6-1000：score: 0.828475631056
```

References:

- [Binomial proportion confidence interval](https://en.wikipedia.org/wiki/Binomial_proportion_confidence_interval)
- [Normal distribution](https://en.wikipedia.org/wiki/Normal_distribution)
- [How Not To Sort By Average Rating](http://www.evanmiller.org/how-not-to-sort-by-average-rating.html)
- [Relationship between Binomial and Normal Distributions](http://www.real-statistics.com/binomial-and-related-distributions/relationship-binomial-and-normal-distributions/)
- [Relevant Source Code](https://github.com/SpikeKing/MachineLearningTutorial/blob/master/wilson_score/wilson_score_model.py)


The Secret for Zhihu Rank

The Wilson Score - Ranking Algorithm


The idea I have is that those open-source developers generating electricity out of love might have taken the wrong path. **Open source is inherently a win-win situation**.

This reminds me of the Faker.js repository deletion incident and the well-received response from [@以撒 (Isaac)](https://www.zhihu.com/people/0a8c8a41d9b99d649639ce7b1c46fda4).

[Zhihu: How do you view the Faker.js open-source author deleting all the code?](https://www.zhihu.com/question/510180628)

Many dedicated open-source project authors contribute tirelessly, creating outstanding works and adding value to the open-source community. Their spirit is admirable, and I appreciate the contributions they have made.

However, what I find hard to understand is why authors, facing financial difficulties and struggling to maintain their own quality of life, would invest a significant amount of time and energy into projects, continuing to shine even at the cost of neglecting their own livelihoods.

In the end, it seems they are only moving themselves and, in the heat of the moment, neglecting their own well-being. They even have to endure criticism from freeloaders. Watching others benefit from forking their projects while they are left with empty hands, having to deal with a pile of issues on their own, is disheartening. Seeking donations is either futile or brings in barely enough, and they are told, "If you can't afford to play in the open-source arena, then don't play at all." The effort seems disproportionate to the lack of appreciation and returns.

The correct attitude is that **open source authors must first learn to be a sophisticated egoist. All open source is for their own sake, not others. Do not be a selfless contributor to generate electricity for love.**

**First of all, don't expect direct returns from open source projects. The open source model was inherently selfish when it first came out, and its goal was to reduce its own maintenance costs.** In the previous closed-source era, the larger the engineering project, the maintenance cost and demand analysis cost increased exponentially, and the software iteration and release cycle became longer. It was also difficult to directly feed back the software usage experience to the manufacturer. During the competition period, The harder it is to survive. In addition, there are still different users in the software audience who have different opinions, so what should we do?

Therefore, the source code is directly disclosed. If anyone has their own needs or finds any bugs, they can fork it themselves and the source code can be modified as you like. You are also welcome to submit your contribution. By the way, you can also gain some fame of the project, so that different software users can be taken care of. In addition, the open source model is open, and users' needs and problems can be responded to in a timely manner and pulled into the project. Users can help you solve them, and you can relax yourself. **Source code is not an asset, but a liability. The source code will change with the needs, exposing many potential problems, all of which require a lot of cost to maintain. Open source is a way to share liabilities and transfer costs to users, which is self-interested.** What if you want to make money with my project? No problem, MIT, Apache and other protocols have agreed: you are responsible for your own choices, you can make money, and the source code can be modified, but if you get in trouble, don't come to me.

So what about personal projects like faker.js and core.js? How do individuals make small projects big? Many open source works were originally written on a whim to solve and realize an idea in work or study. Linux is an example. The author originally wrote the project to learn about operating systems. If the idea is good, with promotion and fame gradually accumulated, more and more people will participate to help contribute Contribution, and the project will become bigger. Now that others have Contribution, it also incorporates ideas from many different users, **Then you actually have no natural obligation to protect yourself.** Because when you originally wrote it, it was for your own use, not to cater to users. **So since it is open source, users also have the obligation to maintain it after obtaining the rights to the source code, and the problems should be solved among them.**

In other words, I have tried my best on the project, and I have given you the source code and profit rights. If you have any ideas or requirements, you can fork and contribute, but if you encounter any problems, you can solve them yourself and do your best. Everyone can get what they need. **I just made my source code public. You can use it if you find it useful. If it doesn't, you can use it. If you like it, don't use it. Don't give me any trouble. After I open sourced it, it was you who begged me to use it, not me who begged you to use it.**

**Ok, this kind of "refined egoism" is the correct path for open source.** If you really want to use open source to gain fame and fortune, then it's not a big deal, and there's no shame in clearly stating the price.

**Remember that when doing open source, the important thing is for yourself, not for others, so don't wrong yourself.**


Remember: when doing open source, the important thing is for yourself, not for others, so don't wrong yourself.

Should I Do Open Source Selflessly?


[The introduction for functions compose is here](/post/functions-compose).

> **Definition : Functions Compose** \
> compose = (funa, funb) => (c) => funa(funb(c));

Now we are supposed to give the proof and derivation process of the following conclusions

> **Associate Law For Functions Compose** \
> compose((funa, funb), func)) = compose(funa, (funb, func))

It's simple to prove this proposition with the definition of functions compose.

according to

```javascript
compose(a, b) = (D) => a(b(D));
```

We assign the argument `b` with

```javascript
b = compose(x, y);
```

So we get

```javascript
compose(a, b) = compose(a, compose(x, y))
= (D) => a(compose(x, y))
= (D) => a(x(y(D)))
```

We find that

```javascript
(D) => a(x(y(D)))
= (D) => compose(compose(a,x),y)
```

So we have the conclusion

```javascript
compose(compose(a, x), y) = compose(a,compose(x, y));
```

QED.

We logically have the expanded conclusion: If there are n function combinations

$$
compose(...,a_{i},a_{i+1},...,compose(a_{j},a_{j+1},...),...,a_{n}) \\ = compose(...,a_{x},a_{x+1},...,compose(a_{y},a_{y+1},...),...,a_{n}); \\
i,j,x,y∈(0,n];

j-i = y-x
$$

The proof of this proposition is omitted.


The derivation process for functions compose

Associate Law For Functions Compose


Today, WeChat once again flooded my Moments with mini-programs, the previously rumored application-type.

However, this piece won't delve into the technical details of mini-programs, nor speculate (because we know very well...).

It also won't discuss what impact mini-programs will have on the Chinese Internet (product managers will discuss that...).

Let's talk about the Web, the Web.

When we commonly refer to the Web, we are actually abbreviating World Wide Web to "the Web."

Similar to H5, this term is an abbreviation of an abbreviation, so concise that in the end, nobody knows what it originally meant.

Don't say that the common people in China can't distinguish between the World Wide Web and the Internet; the same goes for ordinary Americans who can't differentiate between the Web and the Internet.

Many practitioners who don't seek in-depth understanding are not much better off. The term "Web" is consistently translated into Chinese technical articles in a way that leaves readers perplexed.

In the Chinese-speaking world, one of the clearest and most attentive explanations of this matter belongs to [@不鳥萬如一](https://www.zhihu.com/people/6bec872206d9884cd9535841b6a1f510).

For example, in his article [One Day World: WeChat does not "manage" external links, because in practice, WeChat Official Accounts do not allow any external links - 不鳥萬通讯 - Zhihu Column](https://zhuanlan.zhihu.com/p/20747514), he writes:

> The Chinese world has always confused [Internet](https://en.wikipedia.org/wiki/Internet)(internet) and [World Wide Web](https://en.wikipedia.org/wiki/World_Wide_Web)(web). The "open spirit of the Internet" that people remember so much is actually the open spirit of the World Wide Web. The openness of the World Wide Web is mainly reflected in one point: **Any article on the World Wide Web can be linked to each other at will through the URL** . If I want to introduce the website UbuWeb in the article, I can directly add its URL ubu.com to the six letters [UbuWeb](https://ubu.com/). You may think this is nonsense, but you can't do that in articles on WeChat public accounts; you can only add links within the WeChat ecosystem, such as [this](https://weixin.qq.com/cgi-bin/readtemplate%3Ft%3Dweixin_external_links_content_management_specification) (that is, the link to the above "Specification")

So Ruyi uninstalled WeChat ([Farewell to the world of WeChat for a day](https://blog.yitianshijie.net/2016/02/21/byebye-wechat/)) and wrote: [WeChat - the de facto local area network](https://blog.yitianshijie.net/2015/11/16/wechat-de-facto-lan/) , well, as someone who is increasingly hardcore about Open Web, I agree.

Ruyi may care most about articles, but what I care about more is applications, Web Apps.

The so-called Web App is an evolution of the Web: from providing text information (hypertext) to multimedia (hypermedia) to providing software application services. The translation of hard core is probably "World Wide Web-based applications", such as Youtube, Twitter, Medium, Github, etc. that you use in your web browser. **They can still be linked to each other at will through website addresses (URL), follow Web is an open standard, and you can use this service on almost any platform with a browser, so Web App is also open.**

If you've heard of Google's Progressive Web Apps, it actually stands for Progressive Open Web Apps, but that's just too long and wordy.

After all, the concept of the Web should include Open.

(The purpose of this article is not to advocate PWA, but if you are interested in PWA, you are welcome to read: [Next Generation Web Application Model — Progressive Web App](https://zhuanlan.zhihu.com/p/25167289))

If Hybrid architecture is just a concession to Web idealism, then the emergence of React Native has undoubtedly caused the collapse of some people's beliefs, followed by Weex, and then maybe WeChat as you guessed it.

Seeing that the method of "developing with the Web paradigm for Native platforms" is becoming more and more popular, although it seems that the people who benefit are Web front-end practitioners, I don't know whether I should be happy or not.

I'm not saying they are the “wrong technical direction”, from a pragmatic perspective they are great and solve problems.

**However, no matter how much they look like the Web, they are not part of the Open Web platform.**

RN/Weex doesn't have URLs at all (don't get me started on Universal Links or App Links, URLs and URIs are different)

Starting from the JS-SDK, WeChat has been a closed ecosystem.

Although this momentum originated from Facebook, it is more likely to spread wildly in China.

There are many people in the English world who are sensitive/hardcore about this kind of thing, such as Jeremy Keith, who wrote [Regressive Web Apps](https://adactio.com/journal/10708). Because PWA is not URL-friendly enough, it has nothing to do with Chrome development. The boss Alex had a quarrel, and Alex said anxiously:

> so, your choices are to think that I have a secret plan to kill URLs, or conclude I'm still Team Web.

You know, the reason Alex took Chrome to develop PWA was because he didn't like Hybrid destroying the Open Web.

If Twitter/FB is like WeChat and doesn't allow links to be linked casually, you may have to abandon Twitter, and then write a Byebye Twitter/FB article in anger like Ruyi.

However, what is being advocated every day in China is that XX helps the HTML5 ecosystem, but most of the time these so-called "HTML5 ecosystems" are contrary to the Web ecosystem, and there is no judgment.

I started to get a little incoherent.

In this Chinese world where HTML5 and the Web are extremely misused, I don't know how to cry out.

All I know is that when the Web can only survive as Native's "Markup Language", the Web will cease to exist.

When no one follows the Web standards and creates their own, the so-called cross-platform features of the Web disappear.

I've written about it before, and Chrome Product Leader Rahul also said it at I/O:

**The Web's Dicoverable, Linkable, Low Friction, Broad Reach, etc., are not the essence of the Web. The essence of the Web is Open and Decentralized. This is the original intention of the World Wide Web (WWW). This is the prerequisite for all these characteristics to be established.**

The belief in Open Web has brought browser manufacturers back together, and they are asking you:

**Hey, can we make the web great again?**

> Author : Xuan Huang \
> Origin Link: <https://huangxuan.me/2016/09/22/the-open-web/>


```ts
sss
```


The essence of the Web is Open and Decentralized. This is the original intention of the World Wide Web (WWW), and this is the prerequisite for all these features to be established.

The Open Web Is Leaving Us


The `function compose` borrowed thinking from pipeline in Unix-Shell Programming with taking out of a function's output as other function's input.

For example,

```bash
# The content of test.txt is 'Hello'
cat test.text | grep 'World'
# Output : Hello World
```

At above example the symbol `|` is treated as pipeline operator, it transfer the left output to right input.

So the compose in Functional Programming is simply defined as following implement in javascript

```javascript
const compose = (funa, funb) => (c) => funa(funb(c));
```

The compose function accepts two functions as arguments and returns new function that accepts an initial input and applys functions one by one.

In fact the above definition has same effects with

```javascript
const temp = funb(data);
const result = funa(temp);
```

Bear in mind that the order of function calls is inside out and appears in `compose` function is from right to left.

We also have expansion definition for multiple functions compose

```javascript
const composeN =
  (...funcs) =>
  (data) =>
    reduce(funcs.reverse(), (acc, fn) => fn(acc), value);
```


Definitions and examples for Functions Compose

原点日志

ALL POSTS

左忠毅公軼事

沈煉楊繼盛传

References Dynamic-Link Libraries and Static-Link Libraries With GCC

Resource Lock in Concurrency

The Basic Formal Logic (1)

The Wilson Score - Ranking Algorithm

Should I Do Open Source Selflessly?

Associate Law For Functions Compose

The Open Web Is Leaving Us

Functions Compose

原点日志

ALL POSTS

左忠毅公軼事

沈煉 楊繼盛传

References Dynamic-Link Libraries and Static-Link Libraries With GCC

Resource Lock in Concurrency

The Basic Formal Logic (1)

The Wilson Score - Ranking Algorithm

Should I Do Open Source Selflessly?

Associate Law For Functions Compose

The Open Web Is Leaving Us

Functions Compose

沈煉楊繼盛传