\u5927\u4e00\u5165\u5b66\u65f6\u6211\u662f\u4e00\u4e2a\u5bf9\u8ba1\u7b97\u673a\u4e00\u65e0\u6240\u77e5\u7684\u5c0f\u767d\uff0c\u88c5\u4e86\u51e0\u5341\u4e2a G \u7684 Visual Studio \u5929\u5929\u548c OJ \u4f60\u6b7b\u6211\u6d3b\u3002\u51ed\u7740\u9ad8\u4e2d\u7684\u6570\u5b66\u5e95\u5b50\u6211\u6570\u5b66\u8bfe\u5b66\u5f97\u8fd8\u4e0d\u9519\uff0c\u4f46\u5728\u4e13\u4e1a\u8bfe\u4e0a\u5bf9\u7ade\u8d5b\u5927\u4f6c\u53ea\u6709\u4ef0\u671b\u3002\u63d0\u5230\u7f16\u7a0b\u6211\u53ea\u4f1a\u6253\u5f00\u90a3\u7b28\u91cd\u7684 IDE\uff0c\u65b0\u5efa\u4e00\u4e2a\u6211\u4e5f\u4e0d\u77e5\u9053\u5177\u4f53\u662f\u5e72\u5565\u7684\u547d\u4ee4\u884c\u9879\u76ee\uff0c\u7136\u540e\u5c31\u662f cin, cout, for \u5faa\u73af\uff0c\u7136\u540e CE, RE, WA \u5faa\u73af\u3002\u5f53\u65f6\u7684\u6211\u5c31\u5904\u5728\u4e00\u79cd\u62fc\u547d\u60f3\u5b66\u597d\u4f46\u4e0d\u77e5\u9053\u600e\u4e48\u5b66\uff0c\u8bfe\u4e0a\u8ba4\u771f\u542c\u8bb2\u4f46\u9898\u8fd8\u4e0d\u4f1a\u505a\uff0c\u8bfe\u540e\u505a\u4f5c\u4e1a\u5b8c\u5168\u662f\u7528\u65f6\u95f4\u548c\u5b83\u786c\u8017\u7684\u75db\u82e6\u72b6\u6001\u3002\u6211\u81f3\u4eca\u7535\u8111\u91cc\u8fd8\u5b58\u7740\u81ea\u5df1\u5927\u4e00\u4e0a\u5b66\u671f\u8ba1\u7b97\u6982\u8bba\u5927\u4f5c\u4e1a\u7684\u6e90\u4ee3\u7801 \u2014\u2014 \u4e00\u4e2a 1200 \u884c\u7684 C++ \u6587\u4ef6\uff0c\u6ca1\u6709\u5934\u6587\u4ef6\u3001\u6ca1\u6709\u7c7b\u3001\u6ca1\u6709\u5c01\u88c5\u3001\u6ca1\u6709 unit test\u3001\u6ca1\u6709 Makefile\u3001\u6ca1\u6709 Git\uff0c\u552f\u4e00\u7684\u4f18\u70b9\u662f\u5b83\u786e\u5b9e\u80fd\u8dd1\uff0c\u7f3a\u70b9\u662f\u201c\u80fd\u8dd1\u201d\u7684\u8865\u96c6\u3002\u6211\u4e00\u5ea6\u6000\u7591\u6211\u662f\u4e0d\u662f\u4e0d\u9002\u5408\u5b66\u8ba1\u7b97\u673a\uff0c\u56e0\u4e3a\u7ae5\u5e74\u5bf9\u4e8e\u6781\u5ba2\u7684\u6240\u6709\u60f3\u8c61\uff0c\u5df2\u7ecf\u88ab\u6211\u7b2c\u4e00\u4e2a\u5b66\u671f\u7684\u4f53\u9a8c\u5f7b\u5e95\u7c89\u788e\u4e86\u3002
\u8bfe\u7a0b\u6559\u6388\u4eb2\u81ea\u7f16\u5199\u7684\u6559\u6750\uff1aCS61A \u8fd9\u95e8\u8bfe\u7684\u5f00\u8bfe\u8001\u5e08\u5c06 MIT \u7684\u7ecf\u5178\u6559\u6750 Structure and Interpretation of Computer Programs (SICP) \u7528Python\u8fd9\u95e8\u8bed\u8a00\u8fdb\u884c\u6539\u7f16\uff08\u539f\u6559\u6750\u57fa\u4e8e Scheme \u8bed\u8a00\uff09\uff0c\u4fdd\u8bc1\u4e86\u8bfe\u5802\u5185\u5bb9\u4e0e\u6559\u6750\u5185\u5bb9\u7684\u4e00\u81f4\u6027\uff0c\u540c\u65f6\u8865\u5145\u4e86\u66f4\u591a\u7ec6\u8282\uff0c\u53ef\u4ee5\u8bf4\u8bda\u610f\u6ee1\u6ee1\u3002\u800c\u4e14\u5168\u4e66\u5f00\u6e90\uff0c\u53ef\u4ee5\u76f4\u63a5\u7ebf\u4e0a\u9605\u8bfb\u3002
\u7b2c\u4e00\u5c31\u662f\u4ea4\u6d41\u6c9f\u901a\u7684\u4e0d\u4fbf\u3002\u6211\u5176\u5b9e\u662f\u4e00\u4e2a\u5f88\u70ed\u8877\u4e8e\u63d0\u95ee\u7684\u4eba\uff0c\u5bf9\u4e8e\u6240\u6709\u6ca1\u6709\u5f04\u660e\u767d\u7684\u70b9\uff0c\u6211\u90fd\u559c\u6b22\u7a77\u8ffd\u5230\u5e95\u3002\u4f46\u5f53\u4f60\u9762\u5bf9\u7740\u5c4f\u5e55\u542c\u5230\u8001\u5e08\u8bb2\u4e86\u4e00\u4e2a\u4f60\u6ca1\u660e\u767d\u7684\u77e5\u8bc6\u70b9\u7684\u65f6\u5019\uff0c\u4f60\u65e0\u6cd5\u987a\u7740\u7f51\u7ebf\u5230\u53e6\u4e00\u7aef\u5411\u8001\u5e08\u95ee\u4e2a\u660e\u767d\u3002\u6211\u52aa\u529b\u901a\u8fc7\u72ec\u7acb\u601d\u8003\u548c\u5584\u7528 Google \u6765\u7f13\u89e3\u8fd9\u4e00\u70b9\uff0c\u4f46\u662f\uff0c\u5982\u679c\u80fd\u6709\u51e0\u4e2a\u5fd7\u540c\u9053\u5408\u7684\u4f19\u4f34\u7ed3\u4f34\u81ea\u5b66\uff0c\u90a3\u5c06\u662f\u6781\u597d\u7684\u3002\u5173\u4e8e\u4ea4\u6d41\u7fa4\u7684\u5efa\u7acb\uff0c\u5927\u5bb6\u53ef\u4ee5\u53c2\u8003\u4ed3\u5e93 README \u4e2d\u7684\u6559\u7a0b\u3002
\u672c\u4e66\u7684\u5185\u5bb9\u662f\u5b8c\u5168\u5f00\u6e90\u514d\u8d39\u7684\uff0c\u5982\u679c\u4f60\u89c9\u5f97\u8be5\u9879\u76ee\u5bf9\u4f60\u771f\u7684\u6709\u5e2e\u52a9\uff0c\u53ef\u4ee5\u7ed9\u4ed3\u5e93\u70b9\u4e2a star \u6216\u8005\u8bf7\u4f5c\u8005\u559d\u4e00\u676f\u4e0b\u5348\u8336\u3002
IDE (Integrated Development Environment)\uff1a\u96c6\u6210\u5f00\u53d1\u73af\u5883\uff0c\u8bf4\u767d\u4e86\u5c31\u662f\u4f60\u5199\u4ee3\u7801\u7684\u5730\u65b9\u3002\u4f5c\u4e3a\u4e00\u4e2a\u7801\u519c\uff0cIDE \u7684\u91cd\u8981\u6027\u4e0d\u8a00\u800c\u55bb\uff0c\u4f46\u7531\u4e8e\u5f88\u591a IDE \u662f\u4e3a\u5927\u578b\u5de5\u7a0b\u9879\u76ee\u8bbe\u8ba1\u7684\uff0c\u4f53\u91cf\u8f83\u5927\uff0c\u529f\u80fd\u4e5f\u8fc7\u4e8e\u4e30\u5bcc\u3002\u5176\u5b9e\u5982\u4eca\u4e00\u4e9b\u8f7b\u4fbf\u7684\u6587\u672c\u7f16\u8f91\u5668\u914d\u5408\u4e30\u5bcc\u7684\u63d2\u4ef6\u751f\u6001\u57fa\u672c\u53ef\u4ee5\u6ee1\u8db3\u65e5\u5e38\u7684\u8f7b\u91cf\u7f16\u7a0b\u9700\u6c42\u3002\u4e2a\u4eba\u5e38\u7528\u7684\u7f16\u8f91\u5668\u662f VS Code \u548c Sublime\uff08\u524d\u8005\u7684\u63d2\u4ef6\u914d\u7f6e\u975e\u5e38\u7b80\u5355\uff0c\u540e\u8005\u7565\u663e\u590d\u6742\u4f46\u989c\u503c\u5f88\u9ad8\uff09\u3002\u5f53\u7136\u5bf9\u4e8e\u5927\u578b\u9879\u76ee\u6211\u8fd8\u662f\u4f1a\u91c7\u7528\u7565\u91cd\u578b\u7684 IDE\uff0c\u4f8b\u5982 Pycharm (Python)\uff0cIDEA (Java) \u7b49\u7b49\uff08\u514d\u8d23\u7533\u660e\uff1a\u6240\u6709\u7684 IDE \u90fd\u662f\u4e16\u754c\u4e0a\u6700\u597d\u7684 IDE\uff09\u3002
Vim\uff1a\u4e00\u6b3e\u547d\u4ee4\u884c\u7f16\u8f91\u5de5\u5177\u3002\u8fd9\u662f\u4e00\u4e2a\u5b66\u4e60\u66f2\u7ebf\u6709\u4e9b\u9661\u5ced\u7684\u7f16\u8f91\u5668\uff0c\u4e0d\u8fc7\u5b66\u4f1a\u5b83\u6211\u89c9\u5f97\u662f\u975e\u5e38\u6709\u5fc5\u8981\u7684\uff0c\u56e0\u4e3a\u5b83\u5c06\u6781\u5927\u5730\u63d0\u9ad8\u4f60\u7684\u5f00\u53d1\u6548\u7387\u3002\u73b0\u5728\u7edd\u5927\u591a\u6570 IDE \u4e5f\u90fd\u652f\u6301 Vim \u63d2\u4ef6\uff0c\u8ba9\u4f60\u5728\u4eab\u53d7\u73b0\u4ee3\u5f00\u53d1\u73af\u5883\u7684\u540c\u65f6\u4fdd\u7559\u6781\u5ba2\u7684\u70ab\u9177\uff08yue\uff09\u3002
Emacs\uff1a\u4e0e Vim \u9f50\u540d\u7684\u7ecf\u5178\u7f16\u8f91\u5668\uff0c\u540c\u6837\u5177\u6709\u6781\u9ad8\u7684\u5f00\u53d1\u6548\u7387\uff0c\u540c\u65f6\u5177\u6709\u66f4\u4e3a\u5f3a\u5927\u7684\u6269\u5c55\u6027\uff0c\u5b83\u65e2\u53ef\u4ee5\u914d\u7f6e\u4e3a\u4e00\u4e2a\u8f7b\u91cf\u7f16\u8f91\u5668\uff0c\u4e5f\u53ef\u4ee5\u6269\u5c55\u6210\u4e00\u4e2a\u4e2a\u4eba\u5b9a\u5236\u7684 IDE\uff0c\u751a\u81f3\u53ef\u4ee5\u6709\u66f4\u591a\u5947\u6280\u6deb\u5de7\u3002
Git\uff1a\u4e00\u6b3e\u4ee3\u7801\u7248\u672c\u63a7\u5236\u5de5\u5177\u3002Git\u7684\u5b66\u4e60\u66f2\u7ebf\u53ef\u80fd\u66f4\u4e3a\u9661\u5ced\uff0c\u4f46\u51fa\u81ea Linux \u4e4b\u7236 Linus \u4e4b\u624b\u7684 Git \u7edd\u5bf9\u662f\u6bcf\u4e2a\u5b66 CS \u7684\u7ae5\u978b\u5fc5\u987b\u638c\u63e1\u7684\u795e\u5668\u4e4b\u4e00\u3002
GNU Make\uff1a\u4e00\u6b3e\u5de5\u7a0b\u6784\u5efa\u5de5\u5177\u3002\u5584\u7528 GNU Make \u4f1a\u8ba9\u4f60\u517b\u6210\u4ee3\u7801\u6a21\u5757\u5316\u7684\u4e60\u60ef\uff0c\u540c\u65f6\u4e5f\u80fd\u8ba9\u4f60\u719f\u6089\u4e00\u4e9b\u5927\u578b\u5de5\u7a0b\u7684\u7f16\u8bd1\u94fe\u63a5\u6d41\u7a0b\u3002
CMake\uff1a\u4e00\u6b3e\u529f\u80fd\u6bd4 GNU Make \u66f4\u4e3a\u5f3a\u5927\u7684\u6784\u5efa\u5de5\u5177\uff0c\u5efa\u8bae\u638c\u63e1 GNU Make \u4e4b\u540e\u518d\u52a0\u4ee5\u5b66\u4e60\u3002
\u5982\u679c\u4f60\u662f Mac \u7528\u6237\uff0c\u90a3\u4e48\u4f60\u5f88\u5e78\u8fd0\uff0c\u8fd9\u4efd\u6307\u5357 \u5c06\u4f1a\u624b\u628a\u624b\u5730\u5e26\u4f60\u642d\u5efa\u8d77\u6574\u5957\u5f00\u53d1\u73af\u5883\u3002\u5982\u679c\u4f60\u662f Windows \u7528\u6237\uff0c\u5728\u5f00\u6e90\u793e\u533a\u7684\u52aa\u529b\u4e0b\uff0c\u4f60\u540c\u6837\u53ef\u4ee5\u83b7\u5f97\u4e0e\u5176\u4ed6\u5e73\u53f0\u7c7b\u4f3c\u7684\u4f53\u9a8c\uff1aScoop\u3002
\u670d\u52a1\u5668\u7aef\u7684\u8fd0\u7ef4\u9700\u8981\u638c\u63e1 Linux\uff08\u6216\u8005\u5176\u4ed6\u7c7b Unix \u7cfb\u7edf\uff09\u7684\u57fa\u672c\u4f7f\u7528\u4ee5\u53ca\u8fdb\u7a0b\u3001\u8bbe\u5907\u3001\u7f51\u7edc\u7b49\u7cfb\u7edf\u76f8\u5173\u7684\u57fa\u672c\u6982\u5ff5\uff0c\u5c0f\u767d\u53ef\u4ee5\u53c2\u8003\u4e2d\u56fd\u79d1\u5b66\u6280\u672f\u5927\u5b66 Linux \u7528\u6237\u534f\u4f1a\u7f16\u5199\u7684\u300aLinux 101\u300b\u5728\u7ebf\u8bb2\u4e49\u3002\u5982\u679c\u60f3\u6df1\u5165\u5b66\u4e60\u7cfb\u7edf\u8fd0\u7ef4\u76f8\u5173\u7684\u77e5\u8bc6\uff0c\u53ef\u4ee5\u53c2\u8003 Aspects of System Administration \u8fd9\u95e8\u8bfe\u7a0b\u3002
\u4f5c\u4e3a\u8ba1\u7b97\u673a\u7cfb\u7684\u5b66\u751f\uff0c\u53ca\u65e9\u4e86\u89e3\u4e00\u4e9b\u4fe1\u606f\u8bba\u7684\u57fa\u7840\u77e5\u8bc6\uff0c\u6211\u89c9\u5f97\u662f\u5927\u6709\u88e8\u76ca\u7684\u3002\u4f46\u5927\u591a\u4fe1\u606f\u8bba\u8bfe\u7a0b\u90fd\u9762\u5411\u9ad8\u5e74\u7ea7\u672c\u79d1\u751f\u751a\u81f3\u7814\u7a76\u751f\uff0c\u5bf9\u65b0\u624b\u6781\u4e0d\u53cb\u597d\u3002\u800c MIT \u7684 6.050J: Information theory and Entropy \u8fd9\u95e8\u8bfe\u6b63\u662f\u4e3a\u5927\u4e00\u65b0\u751f\u91cf\u8eab\u5b9a\u5236\u7684\uff0c\u51e0\u4e4e\u6ca1\u6709\u5148\u4fee\u8981\u6c42\uff0c\u6db5\u76d6\u4e86\u7f16\u7801\u3001\u538b\u7f29\u3001\u901a\u4fe1\u3001\u4fe1\u606f\u71b5\u7b49\u7b49\u5185\u5bb9\uff0c\u975e\u5e38\u6709\u8da3\u3002
UCB CS70 : discrete Math and probability theory \u548c UCB CS126 : Probability theory \u662f UC Berkeley \u7684\u6982\u7387\u8bba\u8bfe\u7a0b\uff0c\u524d\u8005\u8986\u76d6\u4e86\u79bb\u6563\u6570\u5b66\u548c\u6982\u7387\u8bba\u57fa\u7840\uff0c\u540e\u8005\u5219\u6d89\u53ca\u968f\u673a\u8fc7\u7a0b\u4ee5\u53ca\u6df1\u5165\u7684\u7406\u8bba\u5185\u5bb9\u3002\u4e24\u8005\u90fd\u975e\u5e38\u6ce8\u91cd\u7406\u8bba\u548c\u5b9e\u8df5\u7684\u7ed3\u5408\uff0c\u6709\u4e30\u5bcc\u7684\u7b97\u6cd5\u5b9e\u9645\u8fd0\u7528\u5b9e\u4f8b\uff0c\u540e\u8005\u8fd8\u6709\u5927\u91cf\u7684 Python \u7f16\u7a0b\u4f5c\u4e1a\u6765\u8ba9\u5b66\u751f\u8fd0\u7528\u6982\u7387\u8bba\u7684\u77e5\u8bc6\u89e3\u51b3\u5b9e\u9645\u95ee\u9898\u3002
\u4f5c\u4e3a\u8ba1\u7b97\u673a\u7cfb\u7684\u5b66\u751f\uff0c\u57f9\u517b\u8ba1\u7b97\u601d\u7ef4\u662f\u5f88\u91cd\u8981\u7684\uff0c\u5b9e\u9645\u95ee\u9898\u7684\u5efa\u6a21\u3001\u79bb\u6563\u5316\uff0c\u8ba1\u7b97\u673a\u7684\u6a21\u62df\u3001\u5206\u6790\uff0c\u662f\u4e00\u9879\u5f88\u91cd\u8981\u7684\u80fd\u529b\u3002\u800c\u8fd9\u4e24\u5e74\u5f00\u59cb\u98ce\u9761\u7684\uff0c\u7531 MIT \u6253\u9020\u7684 Julia \u7f16\u7a0b\u8bed\u8a00\u4ee5\u5176 C \u4e00\u6837\u7684\u901f\u5ea6\u548c Python \u4e00\u6837\u53cb\u597d\u7684\u8bed\u6cd5\u5728\u6570\u503c\u8ba1\u7b97\u9886\u57df\u6709\u4e00\u7edf\u5929\u4e0b\u4e4b\u52bf\uff0cMIT \u7684\u8bb8\u591a\u6570\u5b66\u8bfe\u7a0b\u4e5f\u5f00\u59cb\u7528 Julia \u4f5c\u4e3a\u6559\u5b66\u5de5\u5177\uff0c\u628a\u8270\u6df1\u7684\u6570\u5b66\u7406\u8bba\u7528\u76f4\u89c2\u6e05\u6670\u7684\u4ee3\u7801\u5c55\u793a\u51fa\u6765\u3002
ComputationalThinking \u662f MIT \u5f00\u8bbe\u7684\u4e00\u95e8\u8ba1\u7b97\u601d\u7ef4\u5165\u95e8\u8bfe\uff0c\u6240\u6709\u8bfe\u7a0b\u5185\u5bb9\u5168\u90e8\u5f00\u6e90\uff0c\u53ef\u4ee5\u5728\u8bfe\u7a0b\u7f51\u7ad9\u76f4\u63a5\u8bbf\u95ee\u3002\u8fd9\u95e8\u8bfe\u5229\u7528 Julia \u7f16\u7a0b\u8bed\u8a00\uff0c\u5728\u56fe\u50cf\u5904\u7406\u3001\u793e\u4f1a\u79d1\u5b66\u4e0e\u6570\u636e\u79d1\u5b66\u3001\u6c14\u5019\u5b66\u5efa\u6a21\u4e09\u4e2a topic \u4e0b\u5e26\u9886\u5b66\u751f\u7406\u89e3\u7b97\u6cd5\u3001\u6570\u5b66\u5efa\u6a21\u3001\u6570\u636e\u5206\u6790\u3001\u4ea4\u4e92\u8bbe\u8ba1\u3001\u56fe\u4f8b\u5c55\u793a\uff0c\u8ba9\u5b66\u751f\u4f53\u9a8c\u8ba1\u7b97\u4e0e\u79d1\u5b66\u7684\u7f8e\u5999\u7ed3\u5408\u3002\u5185\u5bb9\u867d\u7136\u4e0d\u96be\uff0c\u4f46\u7ed9\u6211\u6700\u6df1\u523b\u7684\u611f\u53d7\u5c31\u662f\uff0c\u79d1\u5b66\u7684\u9b45\u529b\u5e76\u4e0d\u662f\u6545\u5f04\u7384\u865a\u7684\u8270\u6df1\u7406\u8bba\uff0c\u4e0d\u662f\u8bd8\u5c48\u8071\u7259\u7684\u672f\u8bed\u884c\u8bdd\uff0c\u800c\u662f\u7528\u76f4\u89c2\u751f\u52a8\u7684\u6848\u4f8b\uff0c\u7528\u7b80\u7ec3\u6df1\u523b\u7684\u8bed\u8a00\uff0c\u8ba9\u6bcf\u4e2a\u666e\u901a\u4eba\u90fd\u80fd\u7406\u89e3\u3002
\u4e0a\u5b8c\u4e0a\u9762\u7684\u4f53\u9a8c\u8bfe\u4e4b\u540e\uff0c\u5982\u679c\u610f\u72b9\u672a\u5c3d\u7684\u8bdd\uff0c\u4e0d\u59a8\u8bd5\u8bd5 MIT \u7684 18.330 : Introduction to numerical analysis\uff0c\u8fd9\u95e8\u8bfe\u7684\u7f16\u7a0b\u4f5c\u4e1a\u540c\u6837\u4f1a\u7528 Julia \u7f16\u7a0b\u8bed\u8a00\uff0c\u4e0d\u8fc7\u96be\u5ea6\u548c\u6df1\u5ea6\u4e0a\u90fd\u4e0a\u4e86\u4e00\u4e2a\u53f0\u9636\u3002\u5185\u5bb9\u6d89\u53ca\u4e86\u6d6e\u70b9\u7f16\u7801\u3001Root finding\u3001\u7ebf\u6027\u7cfb\u7edf\u3001\u5fae\u5206\u65b9\u7a0b\u7b49\u7b49\u65b9\u9762\uff0c\u6574\u95e8\u8bfe\u7684\u4e3b\u65e8\u5c31\u662f\u8ba9\u4f60\u5229\u7528\u79bb\u6563\u5316\u7684\u8ba1\u7b97\u673a\u8868\u793a\u53bb\u4f30\u8ba1\u548c\u903c\u8fd1\u4e00\u4e2a\u6570\u5b66\u4e0a\u8fde\u7eed\u7684\u6982\u5ff5\u3002\u8fd9\u95e8\u8bfe\u7684\u6559\u6388\u8fd8\u4e13\u95e8\u64b0\u5199\u4e86\u4e00\u672c\u914d\u5957\u7684\u5f00\u6e90\u6559\u6750 Fundamentals of Numerical Computation\uff0c\u91cc\u9762\u9644\u6709\u4e30\u5bcc\u7684 Julia \u4ee3\u7801\u5b9e\u4f8b\u548c\u4e25\u8c28\u7684\u516c\u5f0f\u63a8\u5bfc\u3002
\u5982\u679c\u4f60\u8fd8\u610f\u72b9\u672a\u5c3d\u7684\u8bdd\uff0c\u8fd8\u6709 MIT \u7684\u6570\u503c\u5206\u6790\u7814\u7a76\u751f\u8bfe\u7a0b 18.335: Introduction to numerical method \u4f9b\u4f60\u53c2\u8003\u3002
Languages are tools, you choose the right tool to do the right thing. Since there's no universally perfect tool, there's no universally perfect language.
\u4f5c\u4e3a\u8ba1\u7b97\u673a\u7cfb\u7684\u5b66\u751f\uff0c\u4e86\u89e3\u4e00\u4e9b\u57fa\u7840\u7684\u7535\u8def\u77e5\u8bc6\uff0c\u611f\u53d7\u4ece\u4f20\u611f\u5668\u6536\u96c6\u6570\u636e\u5230\u6570\u636e\u5206\u6790\u518d\u5230\u7b97\u6cd5\u9884\u6d4b\u6574\u6761\u6d41\u6c34\u7ebf\uff0c\u5bf9\u4e8e\u540e\u7eed\u77e5\u8bc6\u7684\u5b66\u4e60\u4ee5\u53ca\u8ba1\u7b97\u601d\u7ef4\u7684\u57f9\u517b\u8fd8\u662f\u5f88\u6709\u5e2e\u52a9\u7684\u3002EE16A&B: Designing Information Devices and Systems I&II \u662f\u4f2f\u514b\u5229 EE \u5b66\u751f\u7684\u5927\u4e00\u5165\u95e8\u8bfe\uff0c\u5176\u4e2d EE16A \u6ce8\u91cd\u901a\u8fc7\u7535\u8def\u4ece\u5b9e\u9645\u73af\u5883\u4e2d\u6536\u96c6\u548c\u5206\u6790\u6570\u636e\uff0c\u800c EE16B \u5219\u4fa7\u91cd\u4ece\u8fd9\u4e9b\u6536\u96c6\u5230\u7684\u6570\u636e\u8fdb\u884c\u5206\u6790\u5e76\u505a\u51fa\u9884\u6d4b\u884c\u4e3a\u3002
MIT 6.003: signal and systems \u63d0\u4f9b\u4e86\u5168\u90e8\u7684\u8bfe\u7a0b\u5f55\u5f71\u3001\u4e66\u9762\u4f5c\u4e1a\u4ee5\u53ca\u7b54\u6848\u3002\u4e5f\u53ef\u4ee5\u53bb\u770b\u8fd9\u95e8\u8bfe\u7684\u8fdc\u53e4\u7248\u672c
\u800c UCB EE120: Signal and Systems \u5173\u4e8e\u5085\u7acb\u53f6\u53d8\u6362\u7684 notes \u5199\u5f97\u975e\u5e38\u597d\uff0c\u5e76\u4e14\u63d0\u4f9b\u4e866 \u4e2a\u975e\u5e38\u6709\u8da3\u7684 Python \u7f16\u7a0b\u4f5c\u4e1a\uff0c\u8ba9\u4f60\u5b9e\u8df5\u4e2d\u8fd0\u7528\u4fe1\u53f7\u4e0e\u7cfb\u7edf\u7684\u7406\u8bba\u4e0e\u7b97\u6cd5\u3002
\u7b97\u6cd5\u662f\u8ba1\u7b97\u673a\u79d1\u5b66\u7684\u6838\u5fc3\uff0c\u4e5f\u662f\u51e0\u4e4e\u4e00\u5207\u4e13\u4e1a\u8bfe\u7a0b\u7684\u57fa\u7840\u3002\u5982\u4f55\u5c06\u5b9e\u9645\u95ee\u9898\u901a\u8fc7\u6570\u5b66\u62bd\u8c61\u8f6c\u5316\u4e3a\u7b97\u6cd5\u95ee\u9898\uff0c\u5e76\u9009\u7528\u5408\u9002\u7684\u6570\u636e\u7ed3\u6784\u5728\u65f6\u95f4\u548c\u5185\u5b58\u5927\u5c0f\u7684\u9650\u5236\u4e0b\u5c06\u5176\u89e3\u51b3\u662f\u7b97\u6cd5\u8bfe\u7684\u6c38\u6052\u4e3b\u9898\u3002\u5982\u679c\u4f60\u53d7\u591f\u4e86\u8001\u5e08\u7684\u7167\u672c\u5ba3\u79d1\uff0c\u90a3\u4e48\u6211\u5f3a\u70c8\u63a8\u8350\u4f2f\u514b\u5229\u7684 UCB CS61B: Data Structures and Algorithms \u548c\u666e\u6797\u65af\u987f\u7684 Coursera: Algorithms I & II\uff0c\u8fd9\u4e24\u95e8\u8bfe\u7684\u90fd\u8bb2\u5f97\u6df1\u5165\u6d45\u51fa\u5e76\u4e14\u4f1a\u6709\u4e30\u5bcc\u4e14\u6709\u8da3\u7684\u7f16\u7a0b\u5b9e\u9a8c\u5c06\u7406\u8bba\u4e0e\u77e5\u8bc6\u7ed3\u5408\u8d77\u6765\u3002
\u4ee5\u4e0a\u4e24\u95e8\u8bfe\u7a0b\u90fd\u662f\u57fa\u4e8e Java \u8bed\u8a00\uff0c\u5982\u679c\u4f60\u60f3\u5b66\u4e60 C/C++ \u63cf\u8ff0\u7684\u7248\u672c\uff0c\u53ef\u4ee5\u53c2\u8003\u65af\u5766\u798f\u7684\u6570\u636e\u7ed3\u6784\u4e0e\u57fa\u7840\u7b97\u6cd5\u8bfe\u7a0b Stanford CS106B/X: Programming Abstractions\u3002\u504f\u597d Python \u7684\u540c\u5b66\u53ef\u4ee5\u5b66\u4e60 MIT \u7684\u7b97\u6cd5\u5165\u95e8\u8bfe MIT 6.006: Introduction to Algorithms
\u5bf9\u4e00\u4e9b\u66f4\u9ad8\u7ea7\u7684\u7b97\u6cd5\u4ee5\u53ca NP \u95ee\u9898\u611f\u5174\u8da3\u7684\u540c\u5b66\u53ef\u4ee5\u5b66\u4e60\u4f2f\u514b\u5229\u7684\u7b97\u6cd5\u8bbe\u8ba1\u4e0e\u5206\u6790\u8bfe\u7a0b UCB CS170: Efficient Algorithms and Intractable Problems \u6216\u8005 MIT \u7684\u9ad8\u9636\u7b97\u6cd5 MIT 6.046: Design and Analysis of Algorithms\u3002
\u4e00\u4efd\u201c\u80fd\u8dd1\u201d\u7684\u4ee3\u7801\uff0c\u548c\u4e00\u4efd\u9ad8\u8d28\u91cf\u7684\u5de5\u4e1a\u7ea7\u4ee3\u7801\u662f\u6709\u672c\u8d28\u533a\u522b\u7684\u3002\u56e0\u6b64\u6211\u975e\u5e38\u63a8\u8350\u4f4e\u5e74\u7ea7\u7684\u540c\u5b66\u5b66\u4e60\u4e00\u4e0b MIT 6.031: Software Construction \u8fd9\u95e8\u8bfe\uff0c\u5b83\u4f1a\u4ee5 Java \u8bed\u8a00\u4e3a\u57fa\u7840\uff0c\u4ee5\u4e30\u5bcc\u7ec6\u81f4\u7684\u9605\u8bfb\u6750\u6599\u548c\u7cbe\u5fc3\u8bbe\u8ba1\u7684\u7f16\u7a0b\u7ec3\u4e60\u4f20\u6388\u5982\u4f55\u7f16\u5199\u4e0d\u6613\u51fa bug\u3001\u7b80\u660e\u6613\u61c2\u3001\u6613\u4e8e\u7ef4\u62a4\u4fee\u6539\u7684\u9ad8\u8d28\u91cf\u4ee3\u7801\u3002\u5927\u5230\u5b8f\u89c2\u6570\u636e\u7ed3\u6784\u8bbe\u8ba1\uff0c\u5c0f\u5230\u5982\u4f55\u5199\u6ce8\u91ca\uff0c\u9075\u5faa\u8fd9\u4e9b\u524d\u4eba\u603b\u7ed3\u7684\u7ec6\u8282\u548c\u7ecf\u9a8c\uff0c\u5bf9\u4e8e\u4f60\u6b64\u540e\u7684\u7f16\u7a0b\u751f\u6daf\u5927\u6709\u88e8\u76ca\u3002
\u5f53\u7136\uff0c\u5982\u679c\u4f60\u60f3\u7cfb\u7edf\u6027\u5730\u4e0a\u4e00\u95e8\u8f6f\u4ef6\u5de5\u7a0b\u7684\u8bfe\u7a0b\uff0c\u90a3\u6211\u63a8\u8350\u7684\u662f\u4f2f\u514b\u5229\u7684 UCB CS169: software engineering\u3002\u4f46\u9700\u8981\u63d0\u9192\u7684\u662f\uff0c\u548c\u5927\u591a\u5b66\u6821\uff08\u5305\u62ec\u8d35\u6821\uff09\u7684\u8f6f\u4ef6\u5de5\u7a0b\u8bfe\u7a0b\u4e0d\u540c\uff0c\u8fd9\u95e8\u8bfe\u4e0d\u4f1a\u6d89\u53ca\u4f20\u7edf\u7684 design and document \u6a21\u5f0f\uff0c\u5373\u5f3a\u8c03\u5404\u79cd\u7c7b\u56fe\u3001\u6d41\u7a0b\u56fe\u53ca\u6587\u6863\u8bbe\u8ba1\uff0c\u800c\u662f\u91c7\u7528\u8fd1\u4e9b\u5e74\u6d41\u884c\u8d77\u6765\u7684\u5c0f\u56e2\u961f\u5feb\u901f\u8fed\u4ee3 Agile Develepment \u5f00\u53d1\u6a21\u5f0f\u4ee5\u53ca\u5229\u7528\u4e91\u5e73\u53f0\u7684 Software as a service \u670d\u52a1\u6a21\u5f0f\u3002
MIT6.033: System Engineering \u662f MIT \u7684\u7cfb\u7edf\u5165\u95e8\u8bfe\uff0c\u4e3b\u9898\u6d89\u53ca\u4e86\u64cd\u4f5c\u7cfb\u7edf\u3001\u7f51\u7edc\u3001\u5206\u5e03\u5f0f\u548c\u7cfb\u7edf\u5b89\u5168\uff0c\u9664\u4e86\u77e5\u8bc6\u70b9\u7684\u4f20\u6388\u5916\uff0c\u8fd9\u95e8\u8bfe\u8fd8\u4f1a\u8bb2\u6388\u4e00\u4e9b\u5199\u4f5c\u548c\u8868\u8fbe\u4e0a\u7684\u6280\u5de7\uff0c\u8ba9\u4f60\u5b66\u4f1a\u5982\u4f55\u8bbe\u8ba1\u5e76\u5411\u522b\u4eba\u4ecb\u7ecd\u548c\u5206\u6790\u81ea\u5df1\u7684\u7cfb\u7edf\u3002\u8fd9\u672c\u4e66\u914d\u5957\u7684\u6559\u6750 Principles of Computer System Design: An Introduction \u4e5f\u5199\u5f97\u975e\u5e38\u597d\uff0c\u63a8\u8350\u5927\u5bb6\u9605\u8bfb\u3002
CMU 15-213: Introduction to Computer System \u662f CMU \u7684\u7cfb\u7edf\u5165\u95e8\u8bfe\uff0c\u5185\u5bb9\u8986\u76d6\u4e86\u4f53\u7cfb\u7ed3\u6784\u3001\u64cd\u4f5c\u7cfb\u7edf\u3001\u94fe\u63a5\u3001\u5e76\u884c\u3001\u7f51\u7edc\u7b49\u7b49\uff0c\u517c\u5177\u5e7f\u5ea6\u548c\u6df1\u5ea6\uff0c\u914d\u5957\u7684\u6559\u6750 Computer Systems: A Programmer's Perspective \u4e5f\u662f\u8d28\u91cf\u6781\u9ad8\uff0c\u5f3a\u70c8\u5efa\u8bae\u9605\u8bfb\u3002
NJU: Operating System Design and Implementation\uff0c\u5357\u4eac\u5927\u5b66\u7684\u848b\u708e\u5ca9\u8001\u5e08\u5f00\u8bbe\u7684\u64cd\u4f5c\u7cfb\u7edf\u8bfe\u7a0b\u3002\u848b\u8001\u5e08\u4ee5\u5176\u72ec\u5230\u7684\u7cfb\u7edf\u89c6\u89d2\u7ed3\u5408\u4e30\u5bcc\u7684\u4ee3\u7801\u793a\u4f8b\u5c06\u4f17\u591a\u64cd\u4f5c\u7cfb\u7edf\u7684\u6982\u5ff5\u8bb2\u5f97\u6df1\u5165\u6d45\u51fa\uff0c\u6b64\u5916\u8fd9\u95e8\u8bfe\u7684\u5168\u90e8\u8bfe\u7a0b\u5185\u5bb9\u90fd\u662f\u4e2d\u6587\u7684\uff0c\u975e\u5e38\u65b9\u4fbf\u5927\u5bb6\u5b66\u4e60\u3002
HIT OS: Operating System\uff0c\u54c8\u5c14\u6ee8\u5de5\u4e1a\u5927\u5b66\u7684\u674e\u6cbb\u519b\u8001\u5e08\u5f00\u8bbe\u7684\u4e2d\u6587\u64cd\u4f5c\u7cfb\u7edf\u8bfe\u7a0b\u3002\u674e\u8001\u5e08\u7684\u8bfe\u7a0b\u57fa\u4e8e Linux 0.11 \u6e90\u7801\uff0c\u5341\u5206\u6ce8\u91cd\u4ee3\u7801\u5b9e\u8df5\uff0c\u5e76\u7ad9\u5728\u5b66\u751f\u89c6\u89d2\u5c06\u64cd\u4f5c\u7cfb\u7edf\u7684\u6765\u9f99\u53bb\u8109\u5a13\u5a13\u9053\u6765\u3002
ASU CSE365: Introduction to Cybersecurity \u4e9a\u5229\u6851\u90a3\u5dde\u7acb\u5927\u5b66\u7684 Web \u5b89\u5168\u8bfe\u7a0b\uff0c\u4e3b\u8981\u6d89\u53ca\u6ce8\u5165\u3001\u6c47\u7f16\u4e0e\u5bc6\u7801\u5b66\u7684\u5185\u5bb9\u3002
ASU CSE466: Computer Systems Security \u4e9a\u5229\u6851\u90a3\u5dde\u7acb\u5927\u5b66\u7684\u7cfb\u7edf\u5b89\u5168\u8bfe\u7a0b\uff0c\u6d89\u53ca\u5185\u5bb9\u5168\u9762\u3002\u95e8\u69db\u8f83\u9ad8\uff0c\u9700\u8981\u5bf9 Linux, C \u4e0e Python \u5145\u5206\u719f\u6089\u3002
\u5176\u5b9e\u6570\u636e\u79d1\u5b66\u548c\u673a\u5668\u5b66\u4e60\u4e0e\u6df1\u5ea6\u5b66\u4e60\u6709\u7740\u5f88\u7d27\u5bc6\u7684\u8054\u7cfb\uff0c\u4f46\u53ef\u80fd\u66f4\u4fa7\u91cd\u4e8e\u5b9e\u8df5\u3002Berkeley \u7684 UCB Data100: Principles and Techniques of Data Science \u901a\u8fc7\u4e30\u5bcc\u7684\u7f16\u7a0b\u7ec3\u4e60\u8ba9\u4f60\u5728\u5b9e\u8df5\u4e2d\u638c\u63e1\u5404\u7c7b\u6570\u636e\u5206\u6790\u5de5\u5177\u548c\u7b97\u6cd5\uff0c\u5e76\u5e26\u9886\u4f60\u4f53\u9a8c\u4ece\u6d77\u91cf\u7684\u6570\u636e\u96c6\u4e2d\u63d0\u53d6\u51fa\u60f3\u8981\u7684\u7ed3\u679c\uff0c\u5e76\u5bf9\u672a\u6765\u7684\u6570\u636e\u6216\u7528\u6237\u7684\u884c\u4e3a\u505a\u51fa\u76f8\u5e94\u7684\u9884\u6d4b\u3002\u4f46\u8fd9\u53ea\u662f\u4e00\u95e8\u57fa\u7840\u8bfe\uff0c\u5982\u679c\u60f3\u5b66\u4e60\u5de5\u4e1a\u7ea7\u522b\u7684\u6570\u636e\u6316\u6398\u4e0e\u5206\u6790\u6280\u672f\uff0c\u53ef\u4ee5\u5c1d\u8bd5 Stanford \u7684\u5927\u6570\u636e\u6316\u6398\u8bfe\u7a0b CS246: Mining Massive Data Sets\u3002
\u673a\u5668\u5b66\u4e60\u9886\u57df\u8fd1\u4e9b\u5e74\u6700\u91cd\u8981\u7684\u8fdb\u5c55\u5c31\u662f\u53d1\u5c55\u51fa\u4e86\u57fa\u4e8e\u795e\u7ecf\u7f51\u7edc\u7684\u6df1\u5ea6\u5b66\u4e60\u5206\u652f\uff0c\u4f46\u5176\u5b9e\u5f88\u591a\u57fa\u4e8e\u7edf\u8ba1\u5b66\u4e60\u7684\u7b97\u6cd5\u4f9d\u7136\u5728\u6570\u636e\u5206\u6790\u9886\u57df\u6709\u7740\u5e7f\u6cdb\u7684\u5e94\u7528\u3002\u5982\u679c\u4f60\u4e4b\u524d\u4ece\u672a\u63a5\u89e6\u8fc7\u673a\u5668\u5b66\u4e60\u7684\u76f8\u5173\u77e5\u8bc6\uff0c\u800c\u4e14\u4e0d\u60f3\u4e00\u5f00\u59cb\u5c31\u9677\u5165\u8270\u6df1\u6666\u6da9\u7684\u6570\u5b66\u8bc1\u660e\uff0c\u90a3\u4e48\u4e0d\u59a8\u5148\u4ece Andrew Ng \uff08\u5434\u6069\u8fbe\uff09\u7684 Coursera: Machine Learning \u5b66\u8d77\u3002\u8fd9\u95e8\u8bfe\u5728\u673a\u5668\u5b66\u4e60\u9886\u57df\u57fa\u672c\u65e0\u4eba\u4e0d\u6653\uff0c\u5434\u6069\u8fbe\u4ee5\u5176\u6df1\u539a\u7684\u7406\u8bba\u529f\u5e95\u548c\u51fa\u8272\u7684\u8868\u8fbe\u80fd\u529b\u628a\u5f88\u591a\u8270\u6df1\u7684\u7b97\u6cd5\u8bb2\u5f97\u6df1\u5165\u6d45\u51fa\uff0c\u5e76\u4e14\u975e\u5e38\u5b9e\u7528\u3002\u5176\u914d\u5957\u7684\u4f5c\u4e1a\u4e5f\u662f\u8d28\u91cf\u76f8\u5f53\u4e0a\u4e58\uff0c\u53ef\u4ee5\u5e2e\u52a9\u4f60\u5feb\u901f\u5165\u95e8\u3002
\u524d\u51e0\u5e74 AlphaGo \u7684\u5927\u70ed\u8ba9\u6df1\u5ea6\u5b66\u4e60\u8fdb\u5165\u4e86\u5927\u4f17\u7684\u89c6\u91ce\uff0c\u4e0d\u5c11\u5927\u5b66\u751a\u81f3\u4e13\u95e8\u6210\u7acb\u4e86\u76f8\u5173\u4e13\u4e1a\u3002\u5f88\u591a\u8ba1\u7b97\u673a\u7684\u5176\u4ed6\u9886\u57df\u4e5f\u4f1a\u501f\u52a9\u6df1\u5ea6\u5b66\u4e60\u7684\u6280\u672f\u6765\u505a\u7814\u7a76\uff0c\u56e0\u6b64\u57fa\u672c\u4e0d\u7ba1\u4f60\u5e72\u5565\u591a\u5c11\u90fd\u4f1a\u63a5\u89e6\u5230\u4e00\u4e9b\u795e\u7ecf\u7f51\u7edc\u3001\u6df1\u5ea6\u5b66\u4e60\u76f8\u5173\u7684\u6280\u672f\u9700\u6c42\u3002\u5982\u679c\u60f3\u5feb\u901f\u5165\u95e8\uff0c\u540c\u6837\u63a8\u8350 Andrew Ng \uff08\u5434\u6069\u8fbe\uff09\u7684 Coursera: Deep Learning\uff0c\u8d28\u91cf\u65e0\u9700\u591a\u8a00\uff0cCoursera \u4e0a\u7f55\u89c1\u7684\u6ee1\u5206\u8bfe\u7a0b\u3002\u6b64\u5916\u5982\u679c\u4f60\u89c9\u5f97\u82f1\u6587\u8bfe\u7a0b\u5b66\u4e60\u8d77\u6765\u6709\u96be\u5ea6\uff0c\u63a8\u8350\u674e\u5b8f\u6bc5\u8001\u5e08\u7684 \u56fd\u7acb\u53f0\u6e7e\u5927\u5b66\uff1a\u673a\u5668\u5b66\u4e60 \u8bfe\u7a0b\u3002\u8fd9\u95e8\u8bfe\u6253\u7740\u673a\u5668\u5b66\u4e60\u7684\u540d\u53f7\uff0c\u5374\u56ca\u62ec\u4e86\u6df1\u5ea6\u5b66\u4e60\u9886\u57df\u7684\u51e0\u4e4e\u6240\u6709\u65b9\u5411\uff0c\u975e\u5e38\u5168\u9762\uff0c\u5f88\u9002\u5408\u4f60\u4ece\u5b8f\u89c2\u4e0a\u5bf9\u8fd9\u4e2a\u9886\u57df\u6709\u4e00\u4e2a\u5927\u81f4\u7684\u4e86\u89e3\u3002\u800c\u4e14\u8001\u5e08\u672c\u4eba\u4e5f\u975e\u5e38\u5e7d\u9ed8\uff0c\u8bfe\u5802\u91d1\u53e5\u9891\u51fa\u3002
MIT OpenCourseWare: \u9ebb\u7701\u7406\u5de5\u5b66\u9662\u7684\u8bfe\u7a0b\u8d44\u6e90\u5f00\u653e\u5171\u4eab\u9879\u76ee\uff0c\u6536\u5f55\u4e86\u6570\u4ee5\u5343\u8ba1\u7684\u5404\u79d1\u8bfe\u7a0b\u8d44\u6e90\uff0c\u5176\u4e2d\u8ba1\u7b97\u673a\u7c7b\u7684\u8bfe\u53f7\u662f 6.xxx\u3002
MIT CS Course List: \u9ebb\u7701\u7406\u5de5\u5b66\u9662\u7684 CS \u8bfe\u7a0b\u5217\u8868\u3002
\u5176\u4e00\u5c31\u662f\u4e86\u89e3\u5982\u4f55\u5199\u201c\u4f18\u96c5\u201d\u7684\u4ee3\u7801\u3002\u56fd\u5185\u7684\u5f88\u591a\u5927\u4e00\u7f16\u7a0b\u5165\u95e8\u8bfe\u90fd\u4f1a\u8bb2\u6210\u6781\u5176\u65e0\u804a\u7684\u8bed\u6cd5\u8bfe\uff0c\u5176\u6548\u679c\u8fd8\u4e0d\u5982\u76f4\u63a5\u8ba9\u5b66\u751f\u770b\u5b98\u65b9\u6587\u6863\u3002\u4e8b\u5b9e\u4e0a\uff0c\u5728\u521a\u5f00\u59cb\u63a5\u89e6\u7f16\u7a0b\u7684\u65f6\u5019\uff0c\u8ba9\u5b66\u751f\u8bd5\u7740\u53bb\u4e86\u89e3\u4ec0\u4e48\u6837\u7684\u4ee3\u7801\u662f\u4f18\u96c5\u7684\uff0c\u4ec0\u4e48\u6837\u7684\u4ee3\u7801 \"have bad taste\" \u662f\u5927\u6709\u88e8\u76ca\u7684\u3002\u4e00\u822c\u6765\u8bf4\uff0c\u7f16\u7a0b\u5165\u95e8\u8bfe\u4f1a\u5148\u4ecb\u7ecd\u8fc7\u7a0b\u5f0f\u7f16\u7a0b\uff08\u4f8b\u5982 C \u8bed\u8a00\uff09\u3002\u4f46\u5373\u4fbf\u662f\u9762\u5411\u8fc7\u7a0b\u7f16\u7a0b\uff0c\u6a21\u5757\u5316 \u548c \u5c01\u88c5 \u7684\u601d\u60f3\u4e5f\u6781\u5176\u91cd\u8981\u3002\u5982\u679c\u4f60\u53ea\u60f3\u7740\u4ee3\u7801\u80fd\u5728 OpenJudge \u4e0a\u901a\u8fc7\uff0c\u5199\u7684\u65f6\u5019\u56fe\u7701\u4e8b\uff0c\u7528\u5927\u6bb5\u7684\u590d\u5236\u7c98\u8d34\u548c\u81c3\u80bf\u7684 main \u51fd\u6570\uff0c\u957f\u6b64\u4ee5\u5f80\uff0c\u4f60\u7684\u4ee3\u7801\u8d28\u91cf\u5c06\u4e00\u76f4\u5982\u6b64\u3002\u4e00\u65e6\u63a5\u89e6\u7a0d\u5fae\u5927\u4e00\u70b9\u7684\u9879\u76ee\uff0c\u65e0\u5c3d\u7684 debug \u548c\u6c9f\u901a\u7ef4\u62a4\u6210\u672c\u5c06\u628a\u4f60\u541e\u6ca1\u3002\u56e0\u6b64\uff0c\u5199\u4ee3\u7801\u65f6\u4e0d\u65ad\u95ee\u81ea\u5df1\uff0c\u662f\u5426\u6709\u5927\u91cf\u91cd\u590d\u7684\u4ee3\u7801\uff1f\u5f53\u524d\u51fd\u6570\u662f\u5426\u8fc7\u4e8e\u590d\u6742\uff08Linux \u63d0\u5021\u6bcf\u4e2a\u51fd\u6570\u53ea\u9700\u8981\u505a\u597d\u4e00\u4ef6\u4e8b\uff09\uff1f\u8fd9\u6bb5\u4ee3\u7801\u80fd\u62bd\u8c61\u6210\u4e00\u4e2a\u51fd\u6570\u5417\uff1f\u4e00\u5f00\u59cb\u4f60\u53ef\u80fd\u89c9\u5f97\u5f88\u4e0d\u4e60\u60ef\uff0c\u751a\u81f3\u89c9\u5f97\u8fd9\u4e48\u7b80\u5355\u7684\u9898\u9700\u8981\u5982\u6b64\u5927\u8d39\u5468\u7ae0\u5417\uff1f\u4f46\u8bb0\u4f4f\u597d\u7684\u4e60\u60ef\u662f\u65e0\u4ef7\u7684\uff0cC \u8bed\u8a00\u521d\u4e2d\u751f\u90fd\u80fd\u5b66\u4f1a\uff0c\u51ed\u4ec0\u4e48\u516c\u53f8\u8981\u62db\u4f60\u53bb\u5f53\u7a0b\u5e8f\u5458\u5462\uff1f
\u5b66\u8fc7\u9762\u5411\u8fc7\u7a0b\u7f16\u7a0b\u540e\uff0c\u5927\u4e00\u4e0b\u5b66\u671f\u4e00\u822c\u4f1a\u8bb2\u9762\u5411\u5bf9\u8c61\u7f16\u7a0b\uff08\u4f8b\u5982 C++ \u6216 Java\uff09\u3002\u8fd9\u91cc\u975e\u5e38\u63a8\u8350\u5927\u5bb6\u770b MIT 6.031: Software Construction \u8fd9\u95e8\u8bfe\u7684 Notes\uff0c\u4f1a\u4ee5 Java \u8bed\u8a00\uff0822\u5e74\u6539\u7528\u4e86 TypeScript \u8bed\u8a00\uff09\u4e3a\u4f8b\u975e\u5e38\u8be6\u7ec6\u5730\u8bb2\u89e3\u5982\u4f55\u5199\u51fa\u201c\u4f18\u96c5\u201d\u7684\u4ee3\u7801\u3002\u4f8b\u5982 Test-Driven \u7684\u5f00\u53d1\u3001\u51fd\u6570 Specification \u7684\u8bbe\u8ba1\u3001\u5f02\u5e38\u7684\u5904\u7406\u7b49\u7b49\u7b49\u7b49\u3002\u9664\u6b64\u4e4b\u5916\uff0c\u65e2\u7136\u63a5\u89e6\u4e86\u9762\u5411\u5bf9\u8c61\uff0c\u90a3\u4e48\u4e86\u89e3\u4e00\u4e9b\u5e38\u89c1\u7684\u8bbe\u8ba1\u6a21\u5f0f\u4e5f\u662f\u5f88\u6709\u5fc5\u8981\u7684\u3002\u56e0\u4e3a\u56fd\u5185\u7684\u9762\u5411\u5bf9\u8c61\u8bfe\u7a0b\u540c\u6837\u5f88\u5bb9\u6613\u53d8\u6210\u6781\u5176\u65e0\u804a\u7684\u8bed\u6cd5\u8bfe\uff0c\u8ba9\u5b66\u751f\u7ea0\u7ed3\u4e8e\u5404\u79cd\u7ee7\u627f\u7684\u8bed\u6cd5\uff0c\u751a\u81f3\u51fa\u4e00\u4e9b\u65e0\u804a\u7684\u8111\u7b4b\u6025\u8f6c\u5f2f\u4e00\u6837\u7684\u9898\u76ee\uff0c\u6b8a\u4e0d\u77e5\u8fd9\u4e9b\u4e1c\u897f\u5728\u5730\u7403\u4eba\u7684\u5f00\u53d1\u4e2d\u57fa\u672c\u4e0d\u4f1a\u7528\u5230\u3002\u9762\u5411\u5bf9\u8c61\u7684\u7cbe\u9ad3\u662f\u8ba9\u5b66\u751f\u5b66\u4f1a\u81ea\u5df1\u5c06\u5b9e\u9645\u7684\u95ee\u9898\u62bd\u8c61\u6210\u82e5\u5e72\u7c7b\u548c\u5b83\u4eec\u4e4b\u95f4\u7684\u5173\u7cfb\uff0c\u800c\u8bbe\u8ba1\u6a21\u5f0f\u5219\u662f\u524d\u4eba\u603b\u7ed3\u51fa\u6765\u7684\u4e00\u4e9b\u7cbe\u9ad3\u7684\u62bd\u8c61\u65b9\u6cd5\u3002\u8fd9\u91cc\u63a8\u8350\u5927\u8bdd\u8bbe\u8ba1\u6a21\u5f0f \u8fd9\u672c\u4e66\uff0c\u5199\u5f97\u975e\u5e38\u6d45\u663e\u6613\u61c2\u3002
\u5176\u4e8c\u5c31\u662f\u5c1d\u8bd5\u5b66\u4e60\u4e00\u4e9b\u80fd\u63d0\u9ad8\u751f\u4ea7\u529b\u7684\u5de5\u5177\u548c\u6280\u80fd\uff0c\u4f8b\u5982 Git\u3001Shell\u3001Vim\u3002\u8fd9\u91cc\u5f3a\u70c8\u63a8\u8350\u5b66\u4e60 MIT missing semester \u8fd9\u95e8\u8bfe\uff0c\u4e5f\u8bb8\u4e00\u5f00\u59cb\u63a5\u89e6\u8fd9\u4e9b\u5de5\u5177\u7528\u8d77\u6765\u4f1a\u5f88\u4e0d\u4e60\u60ef\uff0c\u4f46\u5f3a\u8feb\u81ea\u5df1\u7528\uff0c\u719f\u7ec3\u4e4b\u540e\u5f00\u53d1\u6548\u7387\u4f1a\u76f4\u7ebf\u63d0\u9ad8\u3002\u6b64\u5916\uff0c\u8fd8\u6709\u5f88\u591a\u5e94\u7528\u4e5f\u80fd\u6781\u5927\u63d0\u9ad8\u7684\u4f60\u751f\u4ea7\u529b\u3002\u4e00\u6761\u5b9a\u5f8b\u662f\uff1a\u4e00\u5207\u9700\u8981\u8ba9\u624b\u79bb\u5f00\u952e\u76d8\u7684\u64cd\u4f5c\uff0c\u90fd\u5e94\u8be5\u60f3\u529e\u6cd5\u53bb\u9664\u3002\u4f8b\u5982\u5207\u6362\u5e94\u7528\u3001\u6253\u5f00\u6587\u4ef6\u3001\u6d4f\u89c8\u7f51\u9875\u8fd9\u4e9b\u90fd\u6709\u76f8\u5173\u63d2\u4ef6\u53ef\u4ee5\u5b9e\u73b0\u5feb\u6377\u64cd\u4f5c\uff08\u4f8b\u5982 Mac \u4e0a\u7684 Alfred\uff09\u3002\u5982\u679c\u4f60\u53d1\u73b0\u67d0\u4e2a\u64cd\u4f5c\u6bcf\u5929\u90fd\u4f1a\u7528\u5230\uff0c\u5e76\u4e14\u7528\u65f6\u8d85\u8fc71\u79d2\uff0c\u90a3\u5c31\u5e94\u8be5\u60f3\u529e\u6cd5\u628a\u5b83\u7f29\u51cf\u52300.1\u79d2\u3002\u6bd5\u7adf\u4ee5\u540e\u6570\u5341\u5e74\u4f60\u90fd\u8981\u548c\u7535\u8111\u6253\u4ea4\u9053\uff0c\u5f62\u6210\u4e00\u5957\u987a\u6ed1\u7684\u5de5\u4f5c\u6d41\u662f\u4e8b\u534a\u529f\u500d\u7684\u3002\u6700\u540e\uff0c\u5b66\u4f1a\u76f2\u6253\uff01\u5982\u679c\u4f60\u8fd8\u9700\u8981\u770b\u7740\u952e\u76d8\u6253\u5b57\uff0c\u90a3\u4e48\u8d76\u7d27\u4e0a\u7f51\u627e\u4e2a\u6559\u7a0b\u5b66\u4f1a\u76f2\u6253\uff0c\u8fd9\u5c06\u6781\u5927\u63d0\u9ad8\u4f60\u7684\u5f00\u53d1\u6548\u7387\u3002
\u5176\u4e09\u5c31\u662f\u5e73\u8861\u597d\u8bfe\u5185\u548c\u81ea\u5b66\u3002\u6211\u4eec\u8d28\u7591\u73b0\u72b6\uff0c\u4f46\u4e5f\u5f97\u9075\u5b88\u89c4\u5219\uff0c\u6bd5\u7adf\u7ee9\u70b9\u5728\u4fdd\u7814\u4e2d\u8fd8\u662f\u76f8\u5f53\u91cd\u8981\u7684\u3002\u56e0\u6b64\u5728\u5927\u4e00\uff0c\u6211\u8fd8\u662f\u5efa\u8bae\u5927\u5bb6\u5c3d\u91cf\u6309\u7167\u81ea\u5df1\u7684\u8bfe\u8868\u5b66\u4e60\uff0c\u4f46\u8f85\u4ee5\u4e00\u4e9b\u4f18\u8d28\u7684\u8bfe\u5916\u8d44\u6e90\u3002\u4f8b\u5982\u5fae\u79ef\u5206\u7ebf\u4ee3\u53ef\u4ee5\u53c2\u8003 MIT 18.01/18.02 \u548c MIT 18.06 \u7684\u8bfe\u7a0b Notes\u3002\u5047\u671f\u53ef\u4ee5\u901a\u8fc7 UCB CS61A \u6765\u5b66\u4e60 Python\u3002\u540c\u65f6\u505a\u5230\u4e0a\u9762\u7b2c\u4e00\u3001\u7b2c\u4e8c\u70b9\u8bf4\u7684\uff0c\u6ce8\u91cd\u597d\u7684\u7f16\u7a0b\u4e60\u60ef\u548c\u5b9e\u8df5\u80fd\u529b\u7684\u57f9\u517b\u3002\u5c31\u4e2a\u4eba\u7ecf\u9a8c\uff0c\u5927\u4e00\u7684\u6570\u5b66\u8bfe\u5b66\u5206\u5360\u6bd4\u76f8\u5f53\u5927\uff0c\u800c\u4e14\u6570\u5b66\u8003\u8bd5\u7684\u5185\u5bb9\u65b9\u5dee\u662f\u5f88\u5927\u7684\uff0c\u4e0d\u540c\u5b66\u6821\u4e0d\u540c\u8001\u5e08\u98ce\u683c\u8fe5\u5f02\uff0c\u81ea\u5b66\u4e5f\u8bb8\u80fd\u8ba9\u4f60\u9886\u609f\u6570\u5b66\u7684\u672c\u8d28\uff0c\u4f46\u672a\u5fc5\u80fd\u7ed9\u4f60\u4e00\u4e2a\u597d\u6210\u7ee9\u3002\u56e0\u6b64\u8003\u524d\u6700\u597d\u6709\u9488\u5bf9\u6027\u5730\u5237\u5f80\u5e74\u9898\uff0c\u5145\u5206\u5e94\u8bd5\u3002
\u8bfe\u7a0b\u65b9\u5411 \u8bfe\u7a0b\u540d \u79bb\u6563\u6570\u5b66\u548c\u6982\u7387\u8bba UCB CS70 : discrete Math and probability theory \u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5 Coursera: Algorithms I & II \u8f6f\u4ef6\u5de5\u7a0b MIT 6.031: Software Construction \u5168\u6808\u5f00\u53d1 MIT web development course \u8ba1\u7b97\u673a\u7cfb\u7edf\u5bfc\u8bba CMU CS15213: CSAPP \u4f53\u7cfb\u7ed3\u6784\u5165\u95e8 Coursera: Nand2Tetris \u4f53\u7cfb\u7ed3\u6784\u8fdb\u9636 CS61C: Great Ideas in Computer Architecture \u6570\u636e\u5e93\u539f\u7406 CMU 15-445: Introduction to Database System \u8ba1\u7b97\u673a\u7f51\u7edc Computer Networking: A Top-Down Approach \u4eba\u5de5\u667a\u80fd Harvard CS50: Introduction to AI with Python \u6df1\u5ea6\u5b66\u4e60 Coursera: Deep Learning"},{"location":"%E4%BD%BF%E7%94%A8%E6%8C%87%E5%8D%97/#_4","title":"\u5fc3\u6709\u6240\u5c5e","text":"
"},{"location":"Web%E5%BC%80%E5%8F%91/CS142/","title":"Stanford CS142: Web Applications","text":""},{"location":"Web%E5%BC%80%E5%8F%91/CS142/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
"},{"location":"Web%E5%BC%80%E5%8F%91/fullstackopen/","title":"University of Helsinki: Full Stack open 2022","text":""},{"location":"Web%E5%BC%80%E5%8F%91/fullstackopen/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u6240\u5c5e\u5927\u5b66\uff1aUniversity of Helsinki
"},{"location":"Web%E5%BC%80%E5%8F%91/mitweb/","title":"MIT Web Development Crash Course","text":""},{"location":"Web%E5%BC%80%E5%8F%91/mitweb/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
MIT \u5728\u6bcf\u5e74 1 \u6708\u4efd\u4f1a\u6709\u4e00\u4e2a\u4e3a\u671f 4 \u5468\u7684 Independent Activities Period (IAP)\uff0c\u5728\u8fd9\u4e2a\u6708\u91cc\uff0cMIT \u7684\u5b66\u751f\u548c\u8001\u5e08\u53ef\u4ee5\u81ea\u7531\u5730\u5f00\u8bbe\u5f88\u591a\u6709\u8da3\u7684\u8bfe\u7a0b\uff0c\u800c\u8fd9\u95e8\u7f51\u7ad9\u5f00\u53d1\u8bfe\u7a0b\u5c31\u662f\u5176\u4e2d\u4e4b\u4e00\u3002
\u5728\u4e00\u4e2a\u6708\u7684\u65f6\u95f4\u91cc\uff0c\u4f60\u4f1a\u4ece\u96f6\u5f00\u59cb\u638c\u63e1\u4e00\u4e2a\u7f51\u7ad9\u7684\u8bbe\u8ba1\u3001\u642d\u5efa\u3001\u7f8e\u5316\u3001\u4ea4\u4e92\u7b49\u7b49\u6838\u5fc3\u5185\u5bb9\uff0c\u57fa\u672c\u8986\u76d6\u4e86 Web \u5f00\u53d1\u7684\u524d\u540e\u7aef\u5927\u90e8\u5206\u6280\u672f\u6808\u3002\u5982\u679c\u4f60\u4e0d\u9700\u8981\u7cfb\u7edf\u5730\u5b66\u4e60\u7f51\u7edc\u5f00\u53d1\uff0c\u800c\u53ea\u662f\u51fa\u4e8e\u5174\u8da3\u60f3\u628a\u5b83\u52a0\u5165\u81ea\u5df1\u7684\u6280\u80fd\u5305\u91cc\uff0c\u90a3\u4e48\u8fd9\u95e8\u8bfe\u5c06\u975e\u5e38\u9002\u5408\u4f60\u3002
"},{"location":"%E4%BA%BA%E5%B7%A5%E6%99%BA%E8%83%BD/CS188/","title":"CS188: Introduction to Artificial Intelligence","text":""},{"location":"%E4%BA%BA%E5%B7%A5%E6%99%BA%E8%83%BD/CS188/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u4f2f\u514b\u5229\u7684\u4eba\u5de5\u667a\u80fd\u5165\u95e8\u8bfe\uff0c\u8bfe\u7a0b notes \u5199\u5f97\u975e\u5e38\u6df1\u5165\u6d45\u51fa\uff0c\u57fa\u672c\u4e0d\u9700\u8981\u89c2\u770b\u8bfe\u7a0b\u89c6\u9891\u3002\u8bfe\u7a0b\u5185\u5bb9\u7684\u5b89\u6392\u57fa\u672c\u6309\u7167\u4eba\u5de5\u667a\u80fd\u7684\u7ecf\u5178\u6559\u6750 Artificial intelligence: A Modern Approach \u7684\u7ae0\u8282\u987a\u5e8f\uff0c\u8986\u76d6\u4e86\u641c\u7d22\u526a\u679d\u3001\u7ea6\u675f\u6ee1\u8db3\u95ee\u9898\u3001\u9a6c\u5c14\u53ef\u592b\u51b3\u7b56\u8fc7\u7a0b\u3001\u5f3a\u5316\u5b66\u4e60\u3001\u8d1d\u53f6\u65af\u7f51\u7edc\u3001\u9690\u9a6c\u5c14\u53ef\u592b\u6a21\u578b\u4ee5\u53ca\u57fa\u7840\u7684\u673a\u5668\u5b66\u4e60\u548c\u795e\u7ecf\u7f51\u7edc\u7684\u76f8\u5173\u5185\u5bb9\u3002
2018\u5e74\u79cb\u5b63\u5b66\u671f\u7684\u7248\u672c\u514d\u8d39\u5f00\u653e\u4e86 gradescope\uff0c\u5927\u5bb6\u53ef\u4ee5\u5728\u7ebf\u5b8c\u6210\u4e66\u9762\u4f5c\u4e1a\u5e76\u5b9e\u65f6\u5f97\u5230\u6d4b\u8bc4\u7ed3\u679c\u3002\u540c\u65f6\u8bfe\u7a0b\u7684 6 \u4e2a Project \u4e5f\u662f\u8d28\u91cf\u7206\u70b8\uff0c\u590d\u73b0\u4e86\u7ecf\u5178\u7684 Packman\uff08\u5403\u8c46\u4eba\uff09\u5c0f\u6e38\u620f\uff0c\u4f1a\u8ba9\u4f60\u5229\u7528\u5b66\u5230\u7684 AI \u77e5\u8bc6\uff0c\u53bb\u5b9e\u73b0\u76f8\u5173\u7b97\u6cd5\uff0c\u8ba9\u4f60\u7684\u5403\u8c46\u4eba\u5728\u8ff7\u5bab\u91cc\u81ea\u7531\u7a7f\u68ad\uff0c\u8eb2\u907f\u9b3c\u602a\uff0c\u6536\u96c6\u8c46\u5b50\u3002
"},{"location":"%E4%BA%BA%E5%B7%A5%E6%99%BA%E8%83%BD/CS50/","title":"CS50\u2019s Introduction to AI with Python","text":""},{"location":"%E4%BA%BA%E5%B7%A5%E6%99%BA%E8%83%BD/CS50/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u4e00\u95e8\u975e\u5e38\u57fa\u7840\u7684 AI \u5165\u95e8\u8bfe\uff0c\u8ba9\u4eba\u773c\u524d\u4e00\u4eae\u7684\u662f 12 \u4e2a\u8bbe\u8ba1\u7cbe\u5de7\u7684\u7f16\u7a0b\u4f5c\u4e1a\uff0c\u90fd\u4f1a\u7528\u5b66\u5230\u7684 AI \u77e5\u8bc6\u53bb\u5b9e\u73b0\u4e00\u4e2a\u7b80\u6613\u7684\u6e38\u620f AI\uff0c\u6bd4\u5982\u7528\u5f3a\u5316\u5b66\u4e60\u8bad\u7ec3\u4e00\u4e2a Nim \u6e38\u620f\u7684 AI\uff0c\u7528 alpha-beta \u526a\u679d\u53bb\u626b\u96f7\u7b49\u7b49\uff0c\u975e\u5e38\u9002\u5408\u65b0\u624b\u5165\u95e8\u6216\u8005\u5927\u4f6c\u4f11\u95f2\u3002
We will learn the fundamental concepts of the different parts of modern computing systems, as well as the latest major research topics in Industry and Academia. We will extensively cover memory systems (including DRAM and new Non-Volatile Memory technologies, memory controllers, flash memory), new paradigms like processing-in-memory, parallel computing systems (including multicore processors, coherence and consistency, GPUs), heterogeneous computing, interconnection networks, specialized systems for major data-intensive workloads (e.g. graph analytics, bioinformatics, machine learning), etc. We will focus on fundamentals as well as cutting-edge research. Significant attention will be given to real-life examples and tradeoffs, as well as critical analysis of modern computing systems.
\u7f16\u7a0b\u5b9e\u8df5\u91c7\u53d6 Verilog \u8bbe\u8ba1\u548c\u6a21\u62df\u7c7b MIPS \u6d41\u6c34\u7ebf\u5904\u7406\u5668\u7684\u5bc4\u5b58\u5668\u4f20\u8f93\uff08RT\uff09\u5b9e\u73b0\uff0c\u4ee5\u6b64\u52a0\u5f3a\u5bf9\u7406\u8bba\u8bfe\u7a0b\u7684\u7406\u89e3\u3002\u56e0\u6b64\u524d\u51e0\u4e2a\u5b9e\u9a8c\u4f1a\u6709 verilog \u7684 CPU \u6d41\u6c34\u7ebf\u7f16\u7a0b\u3002\u540c\u65f6\u8fd8\u5c06\u4f7f\u7528C\u8bed\u8a00\u5f00\u53d1\u4e00\u4e2a\u5468\u671f\u7cbe\u786e\u7684\u5904\u7406\u5668\u6a21\u62df\u5668\uff0c\u5e76\u4f7f\u7528\u8be5\u6a21\u62df\u5668\u63a2\u7d22\u5904\u7406\u5668\u8bbe\u8ba1\u9009\u9879\u3002
"},{"location":"%E4%BD%93%E7%B3%BB%E7%BB%93%E6%9E%84/CS61C/","title":"CS61C: Great Ideas in Computer Architecture","text":""},{"location":"%E4%BD%93%E7%B3%BB%E7%BB%93%E6%9E%84/CS61C/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u8bfe\u7a0b\u6559\u67501\uff1aPatt and Patel, Introduction to Computing Systems
\u8bfe\u7a0b\u6559\u67502\uff1aHarris and Harris, Digital Design and Computer Architecture (MIPS Edition) \u4e2d\u6587\u8bd1\u672c\u4e3a\u300a\u6570\u5b57\u8bbe\u8ba1\u548c\u8ba1\u7b97\u673a\u4f53\u7cfb\u7ed3\u6784(\u539f\u4e66\u7b2c2\u7248)\u300b
\u542c\u8d77\u6765\u5c31\u5f88\u9177\u5bf9\u4e0d\u5bf9\uff1f\u5b9e\u73b0\u8d77\u6765\u66f4\u9177\uff01\u8fd9\u95e8\u8bfe\u5206\u4e3a\u786c\u4ef6\u548c\u8f6f\u4ef6\u4e24\u4e2a\u90e8\u5206\u3002\u5728\u786c\u4ef6\u90e8\u5206\uff0c\u4f60\u5c06\u8fdb\u5165 01 \u7684\u4e16\u754c\uff0c\u7528\u4e0e\u975e\u95e8\u6784\u9020\u51fa\u903b\u8f91\u7535\u8def\uff0c\u5e76\u9010\u6b65\u642d\u5efa\u51fa\u4e00\u4e2a CPU \u6765\u8fd0\u884c\u4e00\u5957\u8bfe\u7a0b\u4f5c\u8005\u5b9a\u4e49\u7684\u7b80\u6613\u6c47\u7f16\u4ee3\u7801\u3002\u5728\u8f6f\u4ef6\u90e8\u5206\uff0c\u4f60\u5c06\u7f16\u5199\u4e00\u4e2a\u7f16\u8bd1\u5668\uff0c\u5c06\u4f5c\u8005\u5f00\u53d1\u7684\u4e00\u4e2a\u540d\u4e3aJack\u7684\u9ad8\u7ea7\u8bed\u8a00\u7f16\u8bd1\u4e3a\u53ef\u4ee5\u8fd0\u884c\u5728\u865a\u62df\u673a\u4e0a\u7684\u5b57\u8282\u7801\uff0c\u7136\u540e\u8fdb\u4e00\u6b65\u7ffb\u8bd1\u4e3a\u6c47\u7f16\u4ee3\u7801\u3002\u4f60\u8fd8\u5c06\u5f00\u53d1\u4e00\u4e2a\u7b80\u6613\u7684 OS\uff0c\u8ba9\u4f60\u7684\u8ba1\u7b97\u673a\u652f\u6301\u8f93\u5165\u8f93\u51fa\u56fe\u5f62\u754c\u9762\u3002\u81f3\u6b64\uff0c\u4f60\u53ef\u4ee5\u7528 Jack \u5f00\u53d1\u4e00\u4e2a\u4fc4\u7f57\u65af\u65b9\u5757\u7684\u5c0f\u6e38\u620f\uff0c\u5c06\u5b83\u7f16\u8bd1\u4e3a\u6c47\u7f16\u4ee3\u7801\uff0c\u8fd0\u884c\u5728\u4f60\u7528\u4e0e\u975e\u95e8\u642d\u5efa\u51fa\u7684 CPU \u4e0a\uff0c\u901a\u8fc7\u4f60\u5f00\u53d1\u7684 OS \u8fdb\u884c\u4ea4\u4e92\u3002\u5b66\u5b8c\u8fd9\u95e8\u8bfe\u7a0b\uff0c\u4f60\u5c06\u5bf9\u6574\u4e2a\u8ba1\u7b97\u673a\u7684\u4f53\u7cfb\u7ed3\u6784\u6709\u4e00\u4e2a\u5168\u5c40\u4e14\u6df1\u523b\u7684\u7406\u89e3\uff0c\u5bf9\u4e8e\u4f60\u540e\u7eed\u8bfe\u7a0b\u7684\u5b66\u4e60\u6709\u7740\u83ab\u5927\u7684\u5e2e\u52a9\u3002
\u8fd9\u95e8\u8bfe\u548c MIT 6.S081 \u4e00\u6837\uff0c\u51fa\u54c1\u81ea MIT \u5927\u540d\u9f0e\u9f0e\u7684 PDOS \u5b9e\u9a8c\u5ba4\uff0c\u6388\u8bfe\u8001\u5e08 Robert Morris \u6559\u6388\u66fe\u662f\u4e00\u4f4d\u9876\u5c16\u9ed1\u5ba2\uff0c\u4e16\u754c\u4e0a\u7b2c\u4e00\u4e2a\u8815\u866b\u75c5\u6bd2 Morris \u75c5\u6bd2\u5c31\u662f\u51fa\u81ea\u4ed6\u4e4b\u624b\u3002
CMake \u662f\u7c7b\u4f3c\u4e8e GNU make \u7684\u8de8\u5e73\u53f0\u81ea\u52a8\u8f6f\u4ef6\u6784\u5efa\u5de5\u5177\uff0c\u4f7f\u7528 CMakeLists.txt \u5b9a\u4e49\u6784\u5efa\u89c4\u5219\uff0c\u76f8\u6bd4\u4e8e make \u5b83\u63d0\u4f9b\u4e86\u66f4\u591a\u7684\u529f\u80fd\uff0c\u5728\u5404\u79cd\u8f6f\u4ef6\u6784\u5efa\u4e0a\u5e7f\u6cdb\u4f7f\u7528\u3002\u5f3a\u70c8\u5efa\u8bae\u5b66\u4e60\u4f7f\u7528 GNU Make \u548c\u719f\u6089 Makefile \u540e\u518d\u5b66\u4e60 CMake\u3002
Emacs \u662f\u4e00\u4e2a\u4e0e Vim \u9f50\u540d\u7684\u5f3a\u5927\u7f16\u8f91\u5668\uff0c\u4e8b\u5b9e\u4e0a Emacs \u51e0\u4e4e\u5177\u6709 Vim \u7684\u6240\u6709\u597d\u5904\uff0c\u4f8b\u5982\uff1a
Emacs \u5bf9 Vim \u7528\u6237\u4e5f\u5341\u5206\u53cb\u597d\uff0c\u6709\u4e00\u4e2a\u53eb evil \u7684\u63d2\u4ef6\u53ef\u4ee5\u8ba9\u7528\u6237\u5728 Emacs \u4e2d\u4f7f\u7528 Vim \u7684\u57fa\u672c\u64cd\u4f5c\uff0c\u53ea\u9700\u8981\u5f88\u4f4e\u7684\u8fc1\u79fb\u6210\u672c\u5373\u53ef\u4ece Vim \u8f6c\u5230 Emacs\u3002\u66fe\u7ecf\u6709\u7edf\u8ba1\u663e\u793a\u6709\u76f8\u5f53\u4e00\u90e8\u5206\u7528\u6237\u4f1a\u4ece Vim \u8f6c\u5230 Emacs\uff0c\u4f46\u51e0\u4e4e\u6ca1\u6709\u7528\u6237\u4ece Emacs \u8f6c\u5230 Vim\u3002\u4e8b\u5b9e\u4e0a\uff0cEmacs \u76f8\u5bf9 Vim \u6700\u5927\u7684\u4e0d\u8db3\u662f\u7eaf\u6587\u672c\u7f16\u8f91\u65b9\u9762\u4e0d\u5982 Vim \u7684\u591a\u6a21\u6001\u7f16\u8f91\u6548\u7387\u9ad8\uff0c\u4f46\u51ed\u501f\u5176\u5f3a\u5927\u7684\u6269\u5c55\u6027\uff0cEmacs \u53ef\u4ee5\u626c\u957f\u907f\u77ed\uff0c\u628a Vim \u5438\u6536\u8fdb\u6765\uff0c\u7ed3\u5408\u4e86\u4e8c\u8005\u7684\u957f\u5904\u3002
Emacs \u7684\u552f\u4e00\u7f3a\u70b9\u4fbf\u662f\u5bf9 Ctrl \u952e\u7684\u4f7f\u7528\u8fc7\u591a\uff0c\u5bf9\u5c0f\u624b\u6307\u4e0d\u662f\u5f88\u53cb\u597d\uff0c\u5f3a\u70c8\u5efa\u8bae\u66f4\u6539 Ctrl \u952e\u7684\u952e\u76d8\u6620\u5c04\u3002\u66f4\u6539\u6620\u5c04\u7684\u65b9\u5f0f\u4e0e Vim \u6559\u7a0b\u4e2d\u7684\u65b9\u6cd5\u76f8\u540c\uff0c\u8fd9\u91cc\u4e0d\u505a\u8d58\u8ff0\u3002
"},{"location":"%E5%BF%85%E5%AD%A6%E5%B7%A5%E5%85%B7/GNU_Make/","title":"GNU Make","text":""},{"location":"%E5%BF%85%E5%AD%A6%E5%B7%A5%E5%85%B7/GNU_Make/#gnu-make_1","title":"\u4e3a\u4ec0\u4e48\u5b66 GNU Make","text":"
\u5927\u5bb6\u7b2c\u4e00\u6b21\u5199 hello world \u7a0b\u5e8f\u7684\u65f6\u5019\u4e00\u5b9a\u90fd\u8bb0\u5f97\uff0c\u5728\u7f16\u8f91\u5b8c helloworld.c \u4e4b\u540e\uff0c\u9700\u8981\u7528 gcc \u7f16\u8bd1\u751f\u6210\u53ef\u6267\u884c\u6587\u4ef6\uff0c\u7136\u540e\u518d\u6267\u884c\uff08\u5982\u679c\u4f60\u4e0d\u7406\u89e3\u524d\u9762\u8fd9\u6bb5\u8bdd\uff0c\u8bf7\u5148\u81ea\u884c\u8c37\u6b4c gcc \u7f16\u8bd1 \u5e76\u7406\u89e3\u76f8\u5173\u5185\u5bb9\uff09\u3002\u4f46\u5982\u679c\u4f60\u7684\u9879\u76ee\u7531\u6210\u767e\u4e0a\u5343\u4e2a C \u6e90\u6587\u4ef6\u7ec4\u6210\uff0c\u5e76\u4e14\u661f\u7f57\u68cb\u5e03\u5728\u5404\u4e2a\u5b50\u76ee\u5f55\u4e0b\uff0c\u4f60\u8be5\u5982\u4f55\u5c06\u5b83\u4eec\u7f16\u8bd1\u94fe\u63a5\u5230\u4e00\u8d77\u5462\uff1f\u5047\u5982\u4f60\u7684\u9879\u76ee\u7f16\u8bd1\u4e00\u6b21\u9700\u8981\u534a\u4e2a\u5c0f\u65f6\uff08\u5927\u578b\u9879\u76ee\u76f8\u5f53\u5e38\u89c1\uff09\uff0c\u800c\u4f60\u53ea\u4fee\u6539\u4e86\u4e00\u4e2a\u5206\u53f7\uff0c\u662f\u4e0d\u662f\u8fd8\u9700\u8981\u518d\u7b49\u534a\u4e2a\u5c0f\u65f6\u5462\uff1f
\u8fd9\u65f6\u5019 GNU Make \u5c31\u95ea\u4eae\u767b\u573a\u4e86\uff0c\u5b83\u80fd\u8ba9\u4f60\u5728\u4e00\u4e2a\u811a\u672c\u91cc\uff08\u5373\u6240\u8c13\u7684 Makefile\uff09\u5b9a\u4e49\u6574\u4e2a\u7f16\u8bd1\u6d41\u7a0b\u4ee5\u53ca\u5404\u4e2a\u76ee\u6807\u6587\u4ef6\u4e0e\u6e90\u6587\u4ef6\u4e4b\u95f4\u7684\u4f9d\u8d56\u5173\u7cfb\uff0c\u5e76\u4e14\u53ea\u91cd\u65b0\u7f16\u8bd1\u4f60\u7684\u4fee\u6539\u4f1a\u5f71\u54cd\u5230\u7684\u90e8\u5206\uff0c\u4ece\u800c\u964d\u4f4e\u7f16\u8bd1\u7684\u65f6\u95f4\u3002
"},{"location":"%E5%BF%85%E5%AD%A6%E5%B7%A5%E5%85%B7/GNU_Make/#gnu-make_2","title":"\u5982\u4f55\u5b66\u4e60 GNU Make","text":"
GNU Make \u638c\u63e1\u8d77\u6765\u76f8\u5bf9\u5bb9\u6613\uff0c\u4f46\u7528\u597d\u5b83\u9700\u8981\u4e0d\u65ad\u7684\u7ec3\u4e60\u3002\u5c06\u5b83\u878d\u5165\u5230\u81ea\u5df1\u7684\u65e5\u5e38\u5f00\u53d1\u4e2d\uff0c\u52e4\u4e8e\u5b66\u4e60\u548c\u6a21\u4eff\u5176\u4ed6\u4f18\u79c0\u5f00\u6e90\u9879\u76ee\u91cc\u7684 Makefile \u7684\u5199\u6cd5\uff0c\u603b\u7ed3\u51fa\u9002\u5408\u81ea\u5df1\u7684 template\uff0c\u4e45\u800c\u4e45\u4e4b\uff0c\u4f60\u5bf9 GNU Make \u7684\u4f7f\u7528\u4f1a\u6108\u52a0\u7eaf\u719f\u3002
\u4f46\u76f8\u4fe1\u6211\uff0c\u548c Vim \u4e00\u6837\uff0cGit \u662f\u4e00\u6b3e\u4f60\u6700\u7ec8\u638c\u63e1\u4e4b\u540e\u4f1a\u611f\u53f9\u201c\u5b83\u503c\u5f97\uff01\u201d\u7684\u795e\u5668\u3002
\u548c Vim \u4e0d\u540c\uff0c\u6211\u4e0d\u5efa\u8bae\u521d\u5b66\u8005\u5728\u4e00\u77e5\u534a\u89e3\u7684\u60c5\u51b5\u4e0b\u8d38\u7136\u4f7f\u7528 Git\uff0c\u56e0\u4e3a\u5b83\u7684\u5185\u90e8\u903b\u8f91\u5e76\u4e0d\u80fd\u719f\u80fd\u751f\u5de7\uff0c\u800c\u662f\u9700\u8981\u82b1\u65f6\u95f4\u53bb\u7406\u89e3\u3002\u6211\u63a8\u8350\u7684\u5b66\u4e60\u8def\u7ebf\u5982\u4e0b\uff1a
GitHub \u4e4b\u6240\u4ee5\u6210\u529f\uff0c\u6211\u60f3\u662f\u5f97\u76ca\u4e8e\u201c\u6211\u4e3a\u4eba\u4eba\uff0c\u4eba\u4eba\u4e3a\u6211\u201d\u7684\u5f00\u6e90\u7cbe\u795e\uff0c\u5f97\u76ca\u4e8e\u77e5\u8bc6\u5206\u4eab\u7684\u5feb\u4e50\u3002\u5982\u679c\u4f60\u4e5f\u60f3\u6210\u4e3a\u4e0b\u4e00\u4e2a\u4e07\u4eba\u656c\u4ef0\u7684\u5f00\u6e90\u5927\u4f6c\uff0c\u6216\u8005\u4e0b\u4e00\u4e2a star \u7834\u4e07\u7684\u9879\u76ee\u4f5c\u8005\u3002\u90a3\u5c31\u628a\u4f60\u5728\u5f00\u53d1\u8fc7\u7a0b\u4e2d\u7075\u611f\u4e00\u73b0\u7684 idea \u5316\u4f5c\u4ee3\u7801\uff0c\u5c55\u793a\u5728 GitHub \u4e0a\u5427\uff5e
\u5728 Windows \u4e0b\uff0c\u642d\u5efa\u5f00\u53d1\u73af\u5883\u4e00\u76f4\u662f\u4e00\u4e2a\u590d\u6742\u4e14\u56f0\u96be\u7684\u95ee\u9898\u3002\u7531\u4e8e\u6ca1\u6709\u4e00\u4e2a\u7edf\u4e00\u7684\u6807\u51c6\uff0c\u5bfc\u81f4\u5404\u79cd\u5f00\u53d1\u73af\u5883\u7684\u5b89\u88c5\u65b9\u5f0f\u5dee\u5f02\u5de8\u5927\uff0c\u9700\u8981\u4ed8\u51fa\u5f88\u591a\u4e0d\u5fc5\u8981\u7684\u65f6\u95f4\u6210\u672c\u3002\u800c Scoop \u53ef\u4ee5\u5e2e\u52a9\u4f60\u7edf\u4e00\u5b89\u88c5\u5e76\u7ba1\u7406\u5e38\u89c1\u7684\u5f00\u53d1\u8f6f\u4ef6\uff0c\u7701\u53bb\u4e86\u624b\u52a8\u4e0b\u8f7d\u5b89\u88c5\uff0c\u914d\u7f6e\u73af\u5883\u53d8\u91cf\u7b49\u7e41\u7410\u6b65\u9aa4\u3002
Scoop \u9700\u8981 Windows PowerShell 5.1 \u6216\u8005 PowerShell \u4f5c\u4e3a\u8fd0\u884c\u73af\u5883\uff0c\u5982\u679c\u4f60\u4f7f\u7528\u7684\u662f Windows 10 \u53ca\u4ee5\u4e0a\u7248\u672c\uff0cWindows PowerShell \u662f\u5185\u7f6e\u5728\u7cfb\u7edf\u4e2d\u7684\u3002\u800c Windows 7 \u5185\u7f6e\u7684 Windows PowerShell \u7248\u672c\u8fc7\u4e8e\u9648\u65e7\uff0c\u4f60\u9700\u8981\u624b\u52a8\u5b89\u88c5\u65b0\u7248\u672c\u7684 PowerShell\u3002
\u7531\u4e8e\u53d1\u73b0\u5f88\u591a\u540c\u5b66\u5728\u8bbe\u7f6e Windows \u7528\u6237\u65f6\u4f7f\u7528\u4e86\u4e2d\u6587\u7528\u6237\u540d\uff0c\u5bfc\u81f4\u4e86\u7528\u6237\u76ee\u5f55\u4e5f\u53d8\u6210\u4e86\u4e2d\u6587\u540d\u3002\u5982\u679c\u6309\u7167 Scoop \u7684\u9ed8\u8ba4\u65b9\u5f0f\u5c06\u8f6f\u4ef6\u5b89\u88c5\u5230\u7528\u6237\u76ee\u5f55\u4e0b\uff0c\u53ef\u80fd\u4f1a\u9020\u6210\u90e8\u5206\u8f6f\u4ef6\u6267\u884c\u9519\u8bef\u3002\u6240\u4ee5\u8fd9\u91cc\u63a8\u8350\u5b89\u88c5\u5230\u81ea\u5b9a\u4e49\u76ee\u5f55\uff0c\u5982\u679c\u9700\u8981\u5176\u4ed6\u5b89\u88c5\u65b9\u5f0f\u8bf7\u53c2\u8003\uff1a ScoopInstaller/Install
Vim \u7684\u5b8f\u64cd\u4f5c\u53ef\u4ee5\u6279\u91cf\u5316\u5904\u7406\u91cd\u590d\u64cd\u4f5c\uff08\u4f8b\u5982\u591a\u884c tab\uff0c\u6279\u91cf\u52a0\u53cc\u5f15\u53f7\u7b49\u7b49\uff09
Vim \u662f\u5f88\u591a\u670d\u52a1\u5668\u81ea\u5e26\u7684\u547d\u4ee4\u884c\u7f16\u8f91\u5668\uff0c\u5f53\u4f60\u901a\u8fc7 ssh \u8fde\u63a5\u8fdc\u7a0b\u670d\u52a1\u5668\u4e4b\u540e\uff0c\u7531\u4e8e\u6ca1\u6709\u56fe\u5f62\u754c\u9762\uff0c\u53ea\u80fd\u5728\u547d\u4ee4\u884c\u91cc\u8fdb\u884c\u5f00\u53d1\uff08\u5f53\u7136\u73b0\u5728\u5f88\u591a IDE \u5982 PyCharm \u63d0\u4f9b\u4e86 ssh \u63d2\u4ef6\u53ef\u4ee5\u89e3\u51b3\u8fd9\u4e2a\u95ee\u9898\uff09\u3002
\u4e0d\u5e78\u7684\u662f Vim \u7684\u5b66\u4e60\u66f2\u7ebf\u786e\u5b9e\u76f8\u5f53\u9661\u5ced\uff0c\u6211\u82b1\u4e86\u597d\u51e0\u4e2a\u661f\u671f\u624d\u6162\u6162\u9002\u5e94\u4e86\u7528 Vim \u8fdb\u884c\u5f00\u53d1\u7684\u8fc7\u7a0b\u3002\u6700\u5f00\u59cb\u4f60\u4f1a\u89c9\u5f97\u975e\u5e38\u4e0d\u9002\u5e94\uff0c\u4f46\u4e00\u65e6\u71ac\u8fc7\u4e86\u521d\u59cb\u9636\u6bb5\uff0c\u76f8\u4fe1\u6211\uff0c\u4f60\u4f1a\u7231\u4e0a Vim\u3002
Vim \u7684\u5b66\u4e60\u8d44\u6599\u6d69\u5982\u70df\u6d77\uff0c\u4f46\u638c\u63e1\u5b83\u6700\u597d\u7684\u65b9\u5f0f\u8fd8\u662f\u5c06\u5b83\u7528\u5728\u65e5\u5e38\u7684\u5f00\u53d1\u8fc7\u7a0b\u4e2d\uff0c\u800c\u4e0d\u662f\u4e00\u4e0a\u6765\u5c31\u53bb\u5b66\u5404\u79cd\u82b1\u91cc\u80e1\u54e8\u7684\u9ad8\u7ea7 Vim \u6280\u5de7\u3002\u4e2a\u4eba\u63a8\u8350\u7684\u5b66\u4e60\u8def\u7ebf\u5982\u4e0b\uff1a
\u5148\u9605\u8bfb\u8fd9\u7bc7 tutorial\uff0c\u638c\u63e1\u57fa\u672c\u7684 Vim \u6982\u5ff5\u548c\u4f7f\u7528\u65b9\u5f0f\uff0c\u4e0d\u60f3\u770b\u82f1\u6587\u7684\u53ef\u4ee5\u9605\u8bfb\u8fd9\u7bc7\u6559\u7a0b\u3002
\u7528 Vim \u81ea\u5e26\u7684 vimtutor \u8fdb\u884c\u7ec3\u4e60\uff0c\u5b89\u88c5\u5b8c Vim \u4e4b\u540e\u76f4\u63a5\u5728\u547d\u4ee4\u884c\u91cc\u8f93\u5165 vimtutor \u5373\u53ef\u8fdb\u5165\u7ec3\u4e60\u7a0b\u5e8f\u3002
\u6700\u540e\u5c31\u662f\u5f3a\u8feb\u81ea\u5df1\u4f7f\u7528 Vim \u8fdb\u884c\u5f00\u53d1\uff0cIDE \u91cc\u53ef\u4ee5\u5b89\u88c5 Vim \u63d2\u4ef6\u3002
\u7b49\u4f60\u5b8c\u5168\u9002\u5e94 Vim \u4e4b\u540e\u65b0\u7684\u4e16\u754c\u4fbf\u5411\u4f60\u655e\u5f00\u4e86\u5927\u95e8\uff0c\u4f60\u53ef\u4ee5\u6309\u9700\u914d\u7f6e\u81ea\u5df1\u7684 Vim\uff08\u4fee\u6539 .vimrc \u6587\u4ef6\uff09\uff0c\u7f51\u4e0a\u6709\u6570\u4e0d\u80dc\u6570\u7684\u8d44\u6e90\u53ef\u4ee5\u501f\u9274\u3002
\u5982\u679c\u4f60\u60f3\u5bf9\u914d\u7f6e Vim \u6709\u66f4\u52a0\u6df1\u5165\u7684\u4e86\u89e3\uff0cLearn Vim Script the Hard Way \u662f\u4e00\u4e2a\u5f88\u597d\u7684\u8d44\u6e90\u3002
2022\u5e74\uff0c\u6211\u672c\u79d1\u6bd5\u4e1a\u4e86\u3002\u5728\u5f00\u59cb\u52a8\u624b\u5199\u6bd5\u4e1a\u8bba\u6587\u7684\u65f6\u5019\uff0c\u6211\u5c34\u5c2c\u5730\u53d1\u73b0\uff0c\u6211\u5bf9 Word \u7684\u638c\u63e1\u7a0b\u5ea6\u4ec5\u9650\u4e8e\u8c03\u8282\u5b57\u4f53\u3001\u4fdd\u5b58\u5bfc\u51fa\u8fd9\u4e9b\u50bb\u74dc\u529f\u80fd\u3002\u66fe\u60f3\u8f6c\u6218 Latex\uff0c\u4f46\u8bba\u6587\u7684\u6bb5\u843d\u683c\u5f0f\u8981\u6c42\u8c03\u6574\u8d77\u6765\u8fd8\u662f\u7528 Word \u66f4\u4e3a\u65b9\u4fbf\uff0c\u7ecf\u8fc7\u4e00\u756a\u75db\u82e6\u7f20\u6597\u4e4b\u540e\uff0c\u603b\u7b97\u662f\u6709\u60ca\u65e0\u9669\u5730\u5b8c\u6210\u4e86\u8bba\u6587\u7684\u5199\u4f5c\u548c\u7b54\u8fa9\u3002\u4e3a\u4e86\u4e0d\u8ba9\u540e\u6765\u8005\u91cd\u8e48\u8986\u8f99\uff0c\u9042\u628a\u76f8\u5173\u8d44\u6e90\u6574\u7406\u6210\u4e00\u4efd\u5f00\u7bb1\u5373\u7528\u7684\u6587\u6863\uff0c\u4f9b\u5927\u5bb6\u53c2\u8003\u3002
"},{"location":"%E5%BF%85%E5%AD%A6%E5%B7%A5%E5%85%B7/thesis/#word","title":"\u5982\u4f55\u7528 Word \u5199\u6bd5\u4e1a\u8bba\u6587","text":"
\u6b63\u5982\u5c06\u5927\u8c61\u88c5\u8fdb\u51b0\u7bb1\u9700\u8981\u4e09\u6b65\uff0c\u7528 Word \u5199\u6bd5\u4e1a\u8bba\u6587\u4e5f\u53ea\u9700\u8981\u7b80\u5355\u4e09\u6b65\uff1a
\u5b66\u4e60 Word \u6392\u7248\uff1a\u5230\u8fbe\u8fd9\u4e00\u6b65\u7684\u7ae5\u978b\u5206\u4e3a\u4e24\u7c7b\uff0c\u4e00\u662f\u5df2\u7ecf\u62e5\u6709\u4e86\u5b66\u9662\u63d0\u4f9b\u7684\u6807\u51c6\u6a21\u7248\uff0c\u4e8c\u662f\u53ea\u6709\u4e00\u4efd\u865a\u65e0\u7f25\u7f08\u7684\u683c\u5f0f\u8981\u6c42\u3002\u90a3\u73b0\u5728\u5f53\u52a1\u4e4b\u6025\u5c31\u662f\u5b66\u4e60\u57fa\u7840\u7684 Word \u6392\u7248\u6280\u672f\uff0c\u5bf9\u4e8e\u524d\u8005\u53ef\u4ee5\u5b66\u4f1a\u4f7f\u7528\u6a21\u7248\uff0c\u5bf9\u4e8e\u540e\u8005\u5219\u53ef\u4ee5\u5b66\u4f1a\u5236\u4f5c\u6a21\u7248\u3002\u6b64\u65f6\u5207\u8bb0\u4e0d\u8981\u96c4\u5fc3\u52c3\u52c3\u5730\u9009\u62e9\u4e00\u4e2a\u5341\u51e0\u4e2a\u5c0f\u65f6\u7684 Word \u6559\u5b66\u89c6\u9891\u5f00\u59cb\u5934\u60ac\u6881\u9525\u523a\u80a1\uff0c\u56e0\u4e3a\u751f\u4ea7\u4e00\u4efd\u5e94\u4ed8\u6bd5\u4e1a\u7684\u5b66\u672f\u5783\u573e\u53ea\u8981\u5b66\u534a\u5c0f\u65f6\u80fd\u4e0a\u624b\u5c31\u591f\u4e86\u3002\u6211\u5f53\u65f6\u770b\u7684\u4e00\u4e2a B \u7ad9\u7684\u6559\u5b66\u89c6\u9891\uff0c\u77ed\u5c0f\u7cbe\u608d\u975e\u5e38\u5b9e\u7528\uff0c\u5168\u957f\u534a\u5c0f\u65f6\u6781\u901f\u5165\u95e8\u3002
MSDN,\u6211\u544a\u8bc9\u4f60: Windows \u64cd\u4f5c\u7cfb\u7edf\u955c\u50cf\u4e0b\u8f7d\u7ad9\uff0c\u4e5f\u6709\u8bb8\u591a\u5176\u4ed6\u8f6f\u4ef6\u7684\u4e0b\u8f7d\u3002
OI Wiki: \u7f16\u7a0b\u7ade\u8d5b\u77e5\u8bc6\u6574\u5408\u7ad9\u70b9\u3002
Microsoft Learn: \u5fae\u8f6f\u5b98\u65b9\u7684\u5b66\u4e60\u5e73\u53f0\uff0c\u5305\u542b\u4e86\u7edd\u5927\u591a\u6570\u5fae\u8f6f\u4ea7\u54c1\u7684\u6587\u6863\u3002
Arch Wiki: \u4e13\u4e3a Arch Linux \u800c\u5199\u7684 Wiki\uff0c\u5305\u542b\u4e86\u5927\u91cf Linux \u76f8\u5173\u7684\u77e5\u8bc6\u3002
\u867d\u7136\u4e00\u624b\u4fe1\u606f\u5f88\u91cd\u8981\uff0c\u4f46\u540e\u9762\u7684 N \u624b\u4fe1\u606f\u5e76\u975e\u4e00\u65e0\u662f\u5904\uff0c\u56e0\u4e3a\u8fd9 N \u624b\u8d44\u6599\u91cc\u5305\u542b\u4e86\u4f5c\u8005\u5bf9\u6e90\u77e5\u8bc6\u7684\u8f6c\u5316\u2014\u2014\u4f8b\u5982\u57fa\u4e8e\u67d0\u79cd\u903b\u8f91\u7684\u68b3\u7406\uff08\u6d41\u7a0b\u56fe\u3001\u601d\u7ef4\u5bfc\u56fe\u7b49\uff09\u6216\u662f\u4e00\u4e9b\u81ea\u5df1\u7684\u7406\u89e3\uff08\u5bf9\u6e90\u77e5\u8bc6\u7684\u62bd\u8c61\u3001\u7c7b\u6bd4\u3001\u5ef6\u4f38\u5230\u5176\u4ed6\u77e5\u8bc6\u70b9\uff09\uff0c\u8fd9\u4e9b\u8f6c\u5316\u53ef\u4ee5\u5e2e\u52a9\u6211\u4eec\u66f4\u5feb\u5730\u638c\u63e1\u548c\u5de9\u56fa\u77e5\u8bc6\u7684\u6838\u5fc3\u5185\u5bb9\uff0c\u5c31\u5982\u540c\u521d\u9ad8\u4e2d\u5b66\u4e60\u65f6\u4f7f\u7528\u7684\u8f85\u5bfc\u4e66\u3002 \u6b64\u5916\uff0c\u5b66\u4e60\u7684\u8fc7\u7a0b\u4e2d\u548c\u522b\u4eba\u7684\u4ea4\u6d41\u5341\u5206\u91cd\u8981\uff0c\u8fd9\u4e9b N \u624b\u4fe1\u606f\u540c\u65f6\u8d77\u4e86\u548c\u5176\u4ed6\u4f5c\u8005\u4ea4\u6d41\u7684\u4f5c\u7528\uff0c\u8ba9\u6211\u4eec\u80fd\u91c7\u767e\u5bb6\u4e4b\u957f\u3002\u6240\u4ee5\u8fd9\u63d0\u793a\u6211\u4eec\u5b66\u4e60\u4e00\u4e2a\u77e5\u8bc6\u70b9\u65f6\u5148\u5c3d\u91cf\u9009\u62e9\u8d28\u91cf\u66f4\u9ad8\u7684\uff0c\u4fe1\u606f\u635f\u5931\u8f83\u5c11\u7684\u4fe1\u606f\u6e90\uff0c\u540c\u65f6\u4e0d\u59a8\u53c2\u8003\u591a\u4e2a\u4fe1\u606f\u6e90\uff0c\u8ba9\u81ea\u5df1\u7684\u7406\u89e3\u66f4\u52a0\u5168\u9762\u51c6\u786e\u3002
Obsidian \u6709\u4e30\u5bcc\u7684\u63d2\u4ef6\u751f\u6001\uff0c\u5e76\u4e14\u8fd9\u4e2a\u751f\u6001\u65e2\u5927\u53c8\u6d3b\u8dc3\uff0c\u5373\u63d2\u4ef6\u6570\u91cf\u591a\uff0c\u4e14\u70ed\u95e8\u63d2\u4ef6\u7684 star \u591a\uff0c\u5f00\u53d1\u8005\u4f1a\u53cd\u9988\u7528\u6237 issue\uff0c\u7248\u672c\u4f1a\u6301\u7eed\u8fed\u4ee3\u3002\u501f\u52a9\u8fd9\u4e9b\u63d2\u4ef6\uff0c\u53ef\u4ee5\u4f7f Obsidian \u8fbe\u5230 all in one \u7684\u6548\u679c\uff0c\u5373\u5404\u7c7b\u77e5\u8bc6\u6765\u6e90\u53ef\u4ee5\u7edf\u4e00\u6574\u5408\u4e8e\u4e00\u5904
Obsidian \u7684\u63d2\u4ef6\u4f7f\u5176\u53ef\u4ee5\u652f\u6301 pdf \u683c\u5f0f\uff0c\u800c\u5176\u672c\u8eab\u53c8\u652f\u6301 Markdown \u683c\u5f0f\u3002\u5982\u679c\u60f3\u8981 all in one\uff0c\u90a3\u4e48\u53ef\u4ee5\u57fa\u4e8e\u8fd9\u4e24\u4e2a\u683c\u5f0f\uff0c\u5c06\u5176\u4ed6\u683c\u5f0f\u6587\u4ef6\u8f6c\u6362\u4e3a pdf \u6216\u8005 Markdown\u3002 \u90a3\u4e48\u73b0\u5728\u5c31\u9762\u4e34\u7740\u4e24\u4e2a\u95ee\u9898\uff1a
\u6709\u4ec0\u4e48\u683c\u5f0f
\u600e\u4e48\u8f6c\u6362\u4e3a pdf \u6216 Markdown
\u5bf9\u4e8e\u8bba\u6587\u548c\u7535\u5b50\u4e66\u800c\u8a00\u5982\u679c\u683c\u5f0f\u672c\u8eab\u5c31\u662f pdf \u5219\u4e07\u4e8b\u5927\u5409\uff0c\u4f46\u5982\u679c\u662f\u5176\u4ed6\u683c\u5f0f\u5219\u53ef\u4ee5\u4f7f\u7528 calibre \u8fdb\u884c\u8f6c\u6362\uff1a
\u73b0\u5728\u5229\u7528 Obsidian \u7684 pdf \u63d2\u4ef6\u548c\u5176\u539f\u751f\u7684 markdown \u652f\u6301\u5c31\u53ef\u4ee5\u7545\u5feb\u65e0\u6bd4\u5730\u505a\u7b14\u8bb0\u5e76\u4e14\u5728\u8fd9\u4e9b\u6587\u7ae0\u7684\u5bf9\u5e94\u7ae0\u8282\u8fdb\u884c\u65e0\u7f1d\u8854\u63a5\u5730\u5f15\u7528\u8df3\u8f6c\u5566\uff08\u5177\u4f53\u64cd\u4f5c\u53c2\u8003\u4e0b\u6587\u7684\u201c\u4fe1\u606f\u7684\u5904\u7406\u201d\u6a21\u5757\uff09\u3002
\u5904\u7406\u5b8c\u6587\u672c\u7c7b\u7684\u4fe1\u606f\u540e\uff0c\u6211\u4eec\u8fd8\u5f97\u601d\u8003\u4e00\u4e0b\u600e\u4e48\u5904\u7406\u591a\u5a92\u4f53\u7c7b\u7684\u4fe1\u606f\u3002\u6b64\u5904\u7684\u591a\u5a92\u4f53\u6211\u7279\u6307\u82f1\u6587\u89c6\u9891\uff0c\u56e0\u4e3a\u6211\u6ca1\u6709\u7528\u64ad\u5ba2\u6216\u5f55\u97f3\u5b66\u4e60\u7684\u4e60\u60ef\uff0c\u800c\u4e14\u6211\u5df2\u7ecf\u57fa\u672c\u4e0d\u770b\u4e2d\u6587\u6559\u7a0b\u4e86\u3002\u73b0\u5728\u5f88\u591a\u56fd\u5916\u540d\u6821\u516c\u5f00\u8bfe\u90fd\u662f\u4ee5\u89c6\u9891\u7684\u5f62\u5f0f\uff0c\u5982\u679c\u80fd\u5bf9\u89c6\u9891\u8fdb\u884c\u505a\u7b14\u8bb0\u4f1a\u4e0d\u4f1a\u6709\u5e2e\u52a9\u5462\uff1f\u4e0d\u77e5\u9053\u5927\u5bb6\u6709\u6ca1\u8fd9\u6837\u7684\u60f3\u6cd5\uff0c\u5c31\u662f\u5982\u679c\u80fd\u628a\u8001\u5e08\u4e0a\u8bfe\u8bb2\u7684\u5185\u5bb9\u8f6c\u6362\u6210\u6587\u672c\u5c31\u597d\u4e86\uff0c\u56e0\u4e3a\u5e73\u65f6\u5b66\u4e60\u65f6\u6211\u4eec\u770b\u4e66\u7684\u901f\u5ea6\u5f80\u5f80\u4f1a\u6bd4\u8001\u5e08\u8bb2\u8bfe\u7684\u901f\u5ea6\u5feb\u3002\u521a\u597d Language Reactor \u8fd9\u4e2a\u8f6f\u4ef6\u53ef\u4ee5\u5c06\u6cb9\u7ba1\u548c\u7f51\u98de\u5185\u89c6\u9891\u7684\u5b57\u5e55\u5bfc\u51fa\u6765\uff0c\u540c\u65f6\u9644\u4e0a\u4e2d\u6587\u7ffb\u8bd1\u3002
\u6211\u4eec\u53ef\u4ee5\u628a Language Reactor \u5bfc\u51fa\u7684\u5b57\u5e55\u590d\u5236\u5230 Obsidian \u91cc\u9762\u4f5c\u4e3a\u6587\u7ae0\u6765\u8bfb\u3002\u9664\u4e86\u51fa\u4e8e\u5b66\u4e60\u7684\u9700\u6c42\uff0c\u4e5f\u53ef\u4ee5\u5728\u5e73\u65f6\u770b\u6cb9\u7ba1\u7684\u89c6\u9891\u65f6\u6253\u5f00\u8fd9\u4e2a\u63d2\u4ef6\uff0c\u8fd9\u4e2a\u63d2\u4ef6\u53ef\u4ee5\u540c\u65f6\u663e\u793a\u4e2d\u82f1\u6587\u5b57\u5e55\uff0c\u5e76\u4e14\u53ef\u4ee5\u5355\u51fb\u9009\u4e2d\u82f1\u6587\u5b57\u5e55\u4e2d\u4f60\u8ba4\u4e3a\u751f\u50fb\u7684\u5355\u8bcd\u540e\u663e\u793a\u5355\u8bcd\u91ca\u4e49\u3002
\u4f46\u9605\u8bfb\u6587\u672c\u5bf9\u4e8e\u4e00\u4e9b\u62bd\u8c61\u7684\u77e5\u8bc6\u70b9\u6765\u8bf4\u5e76\u4e0d\u662f\u6548\u7387\u6700\u9ad8\u7684\u5b66\u4e60\u65b9\u5f0f\u3002\u4fd7\u8bdd\u8bf4\uff0c\u4e00\u56fe\u80dc\u5343\u8a00\uff0c\u80fd\u4e0d\u80fd\u5c06\u67d0\u4e00\u6bb5\u77e5\u8bc6\u70b9\u7684\u6587\u672c\u548c\u5bf9\u5e94\u7684\u56fe\u7247\u751a\u81f3\u89c6\u9891\u753b\u9762\u64cd\u4f5c\u8054\u7cfb\u8d77\u6765\u5462\uff1f\u6211\u5728\u6d4f\u89c8 Obsidian \u7684\u63d2\u4ef6\u5e02\u573a\u65f6\uff0c\u53d1\u73b0\u4e86\u4e00\u4e2a\u53eb Media Extended \u7684\u63d2\u4ef6\uff0c\u8fd9\u4e2a\u63d2\u4ef6\u53ef\u4ee5\u5728\u4f60\u7684\u7b14\u8bb0\u91cc\u6dfb\u52a0\u8df3\u8f6c\u5230\u89c6\u9891\u6307\u5b9a\u65f6\u95f4\u8fdb\u5ea6\u7684\u94fe\u63a5\uff0c\u76f8\u5f53\u4e8e\u628a\u4f60\u7684\u7b14\u8bb0\u548c\u89c6\u9891\u8fde\u63a5\u8d77\u6765\u4e86\uff01\u8fd9\u521a\u597d\u53ef\u4ee5\u548c\u6211\u4e0a\u6587\u63d0\u5230\u7684\u751f\u6210\u89c6\u9891\u4e2d\u82f1\u6587\u5b57\u5e55\u642d\u914d\u8d77\u6765\uff0c\u5373\u6bcf\u4e00\u53e5\u5b57\u5e55\u5bf9\u5e94\u4e00\u4e2a\u65f6\u95f4\uff0c\u5e76\u4e14\u80fd\u6839\u636e\u65f6\u95f4\u70b9\u8df3\u8f6c\u5230\u89c6\u9891\u7684\u6307\u5b9a\u8fdb\u5ea6\uff0c\u5982\u6b64\u4e00\u6765\u5982\u679c\u9700\u8981\u5728\u6587\u7ae0\u4e2d\u5c55\u793a\u8bb0\u5f55\u4e86\u64cd\u4f5c\u8fc7\u7a0b\u7684\u89c6\u9891\u7684\u8bdd\uff0c\u5c31\u4e0d\u9700\u8981\u81ea\u5df1\u53bb\u622a\u53d6\u5bf9\u5e94\u7684\u89c6\u9891\u7247\u6bb5\uff0c\u800c\u662f\u76f4\u63a5\u5728\u6587\u7ae0\u5185\u5c31\u80fd\u8df3\u8f6c\uff01
Obsidian \u91cc\u8fd8\u6709\u4e00\u4e2a\u5f88\u5f3a\u5927\u7684\u63d2\u4ef6\uff0c\u53eb Annotator\uff0c\u5b83\u53ef\u4ee5\u5b9e\u73b0\u7b14\u8bb0\u5185\u8df3\u8f6c\u5230 pdf \u539f\u6587
Obsidian \u5185\u5df2\u7ecf\u6709\u4e00\u4e2a\u8fde\u63a5 Anki \u7684\u63d2\u4ef6\uff0cAnki \u5c31\u662f\u5927\u540d\u9f0e\u9f0e\u7684\u3001\u57fa\u4e8e\u95f4\u9694\u91cd\u590d\u7684\u8bb0\u5fc6\u8f6f\u4ef6\u3002\u4f7f\u7528\u8be5\u63d2\u4ef6\u53ef\u4ee5\u622a\u53d6\u7b14\u8bb0\u7684\u7247\u6bb5\u5bfc\u51fa\u5230 Anki \u5e76\u53d8\u6210\u4e00\u5f20\u5361\u7247\uff0c\u5361\u7247\u5185\u4e5f\u6709\u8df3\u8f6c\u56de\u7b14\u8bb0\u539f\u6587\u7684\u94fe\u63a5
\u722c\u884c\u548c\u6293\u53d6\uff1a\u641c\u7d22\u5f15\u64ce\u8718\u86db\u901a\u8fc7\u8ddf\u8e2a\u94fe\u63a5\u8bbf\u95ee\u7f51\u9875\uff0c\u83b7\u53d6\u7f51\u9875 HTML \u4ee3\u7801\u5b58\u5165\u6570\u636e\u5e93\u3002
\u7b2c\u4e09\u6b65\u8ddf\u6211\u4eec\u606f\u606f\u76f8\u5173\uff0c\u4e0d\u7ba1\u662f\u4ec0\u4e48\u641c\u7d22\u7f51\u7ad9\uff0c google \u3001\u767e\u5ea6\u3001 Bing \uff0c\u90fd\u4e00\u6837\uff0c\u8f93\u5165\u5173\u952e\u5b57\u6216\u8005\u9700\u8981\u67e5\u8be2\u7684\u5185\u5bb9\uff0c\u641c\u7d22\u5f15\u64ce\u4f1a\u7ed9\u4f60\u8fd4\u56de\u7ed3\u679c\u3002\u672c\u6587\u5c31\u662f\u6559\u4f60\u5982\u4f55\u83b7\u53d6\u66f4\u597d\u7684\u7ed3\u679c\u3002
\u4e2d\u6587\u641c\u7d22\u4e2d\uff0c\u5206\u8bcd\u7cfb\u7edf\u4e0d\u51c6\u4f1a\u5bfc\u81f4\u6b67\u4e49\uff0c\u6bd4\u5982 Google \u641c\u4e2d\u6587\u53ef\u80fd\u4f1a\u641c\u4e0d\u51fa\u51e0\u6761\u6709\u7528\u7ed3\u679c
\u6b64\u94fe\u63a5\u51fa\u73b0\u5728\u8fd9\u91cc\u7eaf\u5c5e\u4e8c\u8fdb\u5236 bit \u7684\u968f\u610f\u7ec4\u5408\uff0c\u4e0e\u672c\u4eba\u6beb\u65e0\u5173\u7cfb\u3002
\u8fd9\u95e8\u8bfe\u5584\u4e8e\u7ad9\u5728\u5b66\u751f\u89d2\u5ea6\u5faa\u5faa\u5584\u8bf1\u3002\u4f8b\u5982\uff0c\u8bfe\u7a0b\u4ece\u201c\u5f31\u5f31\u5730\u95ee\uff0c\u4ec0\u4e48\u662f\u64cd\u4f5c\u7cfb\u7edf\u201d\u6765\u201c\u63ed\u5f00\u64cd\u4f5c\u7cfb\u7edf\u94a2\u7434\u7684\u76d6\u5b50\u201d\uff0c\u4ece CPU \u7684\u76f4\u89c2\u7ba1\u7406\u5f15\u51fa\u8fdb\u7a0b\u6982\u5ff5\uff0c\u4ece\u201c\u90a3\u5c31\u9996\u5148\u8ba9\u7a0b\u5e8f\u8fdb\u5165\u5185\u5b58\u201d\u5f15\u51fa\u5185\u5b58\u7ba1\u7406\u3002
\u8fd9\u95e8\u8bfe\u6ce8\u91cd\u7406\u8bba\u548c\u5b9e\u8df5\u76f8\u7ed3\u5408\u3002\u64cd\u4f5c\u7cfb\u7edf\u662f\u770b\u5f97\u89c1\u6478\u5f97\u7740\u7684\u4e1c\u897f\uff0c\u674e\u8001\u5e08\u53cd\u590d\u5f3a\u8c03\u4e00\u5b9a\u8981\u505a\u5b9e\u9a8c\uff0c\u5982\u679c\u53ea\u770b\u89c6\u9891\u7eb8\u4e0a\u8c08\u5175\uff0c\u662f\u5b66\u4e0d\u597d\u64cd\u4f5c\u7cfb\u7edf\u7684\u3002\u8bfe\u7a0b\u57fa\u4e8e\u5b9e\u9645\u7684 Linux 0.11 \u6e90\u7801\uff08\u603b\u4ee3\u7801\u91cf\u7ea6\u4e24\u4e07\u884c\uff09\u8fdb\u884c\u8bb2\u89e3\u548c\u5b9e\u9a8c\uff0c\u5171\u6709\u516b\u4e2a\u5c0f\u5b9e\u9a8c\uff0c\u56db\u4e2a\u5927\u5b9e\u9a8c\u3002
"},{"location":"%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F/MIT6.S081/","title":"MIT 6.S081: Operating System Engineering","text":""},{"location":"%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F/MIT6.S081/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
"},{"location":"%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F/NJUOS/","title":"NJU OS: Operating System Design and Implementation","text":""},{"location":"%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F/NJUOS/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u4e4b\u524d\u4e00\u76f4\u542c\u8bf4\u5357\u5927\u7684\u848b\u708e\u5ca9\u8001\u5e08\u5f00\u8bbe\u7684\u64cd\u4f5c\u7cfb\u7edf\u8bfe\u7a0b\u8bb2\u5f97\u5f88\u597d\uff0c\u4e45\u95fb\u4e0d\u5982\u4e00\u89c1\uff0c\u8fd9\u5b66\u671f\u6709\u5e78\u5728 B \u7ad9\u89c2\u770b\u4e86\u848b\u8001\u5e08\u7684\u8bfe\u7a0b\u89c6\u9891\uff0c\u786e\u5b9e\u6536\u83b7\u826f\u591a\u3002\u848b\u8001\u5e08\u4f5c\u4e3a\u975e\u5e38\u5e74\u8f7b\u7684\u8001\u5e08\uff0c\u6709\u7740\u4e30\u5bcc\u7684\u4e00\u7ebf\u4ee3\u7801\u7684\u7ecf\u9a8c\uff0c\u56e0\u6b64\u8bfe\u7a0b\u8bb2\u6388\u6709\u7740\u6ee1\u6ee1\u7684 Hacker \u98ce\u683c\uff0c\u8bfe\u4e0a\u7ecf\u5e38\u201c\u4e00\u8a00\u4e0d\u5408\u201d\u5c31\u5728\u547d\u4ee4\u884c\u91cc\u5f00\u59cb\u5199\u4ee3\u7801\uff0c\u5f88\u591a\u91cd\u8981\u77e5\u8bc6\u70b9\u4e5f\u90fd\u914d\u6709\u751f\u52a8\u76f4\u767d\u7684\u4ee3\u7801\u793a\u4f8b\u3002\u8ba9\u6211\u5370\u8c61\u6700\u4e3a\u6df1\u523b\u7684\u5c31\u662f\u8001\u5e08\u4e3a\u4e86\u8ba9\u5b66\u751f\u66f4\u597d\u5730\u7406\u89e3\u52a8\u6001\u94fe\u63a5\u5e93\u7684\u8bbe\u8ba1\u601d\u60f3\uff0c\u751a\u81f3\u4e13\u95e8\u5b9e\u73b0\u4e86\u4e00\u4e2a\u8ff7\u4f60\u7684\u53ef\u6267\u884c\u6587\u4ef6\u4e0e\u4e00\u7cfb\u5217\u7684\u4e8c\u8fdb\u5236\u5de5\u5177\uff0c\u8ba9\u5f88\u591a\u56f0\u6270\u6211\u591a\u5e74\u7684\u95ee\u9898\u90fd\u5f97\u5230\u4e86\u89e3\u7b54\u3002
\u8fd9\u95e8\u8bfe\u7684\u8bb2\u6388\u601d\u8def\u4e5f\u975e\u5e38\u6709\u8da3\uff0c\u848b\u8001\u5e08\u5148\u4ece\u201c\u7a0b\u5e8f\u5c31\u662f\u72b6\u6001\u673a\u201d\u8fd9\u4e00\u89c6\u89d2\u5165\u624b\uff0c\u4e3a\u201c\u4e07\u6076\u4e4b\u6e90\u201d\u5e76\u53d1\u7a0b\u5e8f\u5efa\u7acb\u4e86\u72b6\u6001\u673a\u7684\u8f6c\u5316\u6a21\u578b\uff0c\u5e76\u5728\u6b64\u57fa\u7840\u4e0a\u8bb2\u6388\u4e86\u5e76\u53d1\u63a7\u5236\u7684\u5e38\u89c1\u624b\u6bb5\u4ee5\u53ca\u5e76\u53d1 bug \u7684\u5e94\u5bf9\u65b9\u6cd5\u3002\u63a5\u7740\u848b\u8001\u5e08\u5c06\u64cd\u4f5c\u7cfb\u7edf\u770b\u4f5c\u4e00\u7cfb\u5217\u5bf9\u8c61\uff08\u8fdb\u7a0b/\u7ebf\u7a0b\u3001\u5730\u5740\u7a7a\u95f4\u3001\u6587\u4ef6\u3001\u8bbe\u5907\u7b49\u7b49\uff09\u4ee5\u53ca\u64cd\u4f5c\u5b83\u4eec\u7684 API \uff08\u7cfb\u7edf\u8c03\u7528\uff09\u5e76\u7ed3\u5408\u4e30\u5bcc\u7684\u5b9e\u9645\u4f8b\u5b50\u4ecb\u7ecd\u4e86\u64cd\u4f5c\u7cfb\u7edf\u662f\u5982\u4f55\u5229\u7528\u8fd9\u7cfb\u5217\u5bf9\u8c61\u865a\u62df\u5316\u786c\u4ef6\u8d44\u6e90\u5e76\u7ed9\u5e94\u7528\u8f6f\u4ef6\u63d0\u4f9b\u5404\u7c7b\u670d\u52a1\u7684\u3002\u6700\u540e\u7684\u53ef\u6301\u4e45\u5316\u90e8\u5206\uff0c\u848b\u8001\u5e08\u4ece 1-bit \u7684\u5b58\u50a8\u4ecb\u8d28\u8bb2\u8d77\uff0c\u4e00\u6b65\u6b65\u6784\u5efa\u8d77\u5404\u7c7b\u5b58\u50a8\u8bbe\u5907\uff0c\u5e76\u901a\u8fc7\u8bbe\u5907\u9a71\u52a8\u62bd\u8c61\u51fa\u4e00\u7ec4\u63a5\u53e3\u6765\u65b9\u4fbf\u5730\u8bbe\u8ba1\u4e0e\u5b9e\u73b0\u6587\u4ef6\u7cfb\u7edf\u3002\u6211\u4e4b\u524d\u867d\u7136\u4e0a\u8fc7\u8bb8\u591a\u95e8\u64cd\u4f5c\u7cfb\u7edf\u7684\u8bfe\u7a0b\uff0c\u4f46\u8fd9\u79cd\u8bb2\u6cd5\u786e\u5b9e\u72ec\u6b64\u4e00\u5bb6\uff0c\u8ba9\u6211\u6536\u83b7\u4e86\u5f88\u591a\u72ec\u5230\u7684\u89c6\u89d2\u6765\u770b\u5f85\u7cfb\u7edf\u8f6f\u4ef6\u3002
"},{"location":"%E6%95%B0%E5%AD%A6%E5%9F%BA%E7%A1%80/MITLA/","title":"MIT18.06: Linear Algebra","text":""},{"location":"%E6%95%B0%E5%AD%A6%E5%9F%BA%E7%A1%80/MITLA/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u6570\u5b66\u5927\u725b Gilbert Strang \u8001\u5148\u751f\u5e74\u903e\u53e4\u7a00\u4ecd\u575a\u6301\u6388\u8bfe\uff0c\u5176\u7ecf\u5178\u6559\u6750 Introduction to Linear Algebra \u5df2\u88ab\u6e05\u534e\u91c7\u7528\u4e3a\u5b98\u65b9\u6559\u6750\u3002\u6211\u5f53\u65f6\u770b\u5b8c\u76d7\u7248 PDF \u4e4b\u540e\u6df1\u611f\u6127\u759a\uff0c\u542b\u6cea\u82b1\u4e86\u4e24\u767e\u591a\u4e70\u4e86\u4e00\u672c\u82f1\u6587\u6b63\u7248\u6536\u85cf\u3002\u4e0b\u9762\u9644\u4e0a\u6b64\u4e66\u5c01\u9762\uff0c\u5982\u679c\u4f60\u80fd\u5b8c\u5168\u7406\u89e3\u5c01\u9762\u56fe\u7684\u6570\u5b66\u542b\u4e49\uff0c\u90a3\u4f60\u5bf9\u7ebf\u6027\u4ee3\u6570\u7684\u7406\u89e3\u4e00\u5b9a\u4f1a\u8fbe\u5230\u65b0\u7684\u9ad8\u5ea6\u3002
"},{"location":"%E6%95%B0%E5%AD%A6%E5%9F%BA%E7%A1%80/information/","title":"MIT6.050J: Information theory and Entropy","text":""},{"location":"%E6%95%B0%E5%AD%A6%E5%9F%BA%E7%A1%80/information/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
MIT \u9762\u5411\u5927\u4e00\u65b0\u751f\u7684\u4fe1\u606f\u8bba\u5165\u95e8\u8bfe\u7a0b\uff0cPenfield \u6559\u6388\u4e13\u95e8\u4e3a\u8fd9\u95e8\u8bfe\u5199\u4e86\u4e00\u672c\u6559\u6750\u4f5c\u4e3a\u8bfe\u7a0b notes\uff0c\u5185\u5bb9\u6df1\u5165\u6d45\u51fa\uff0c\u751f\u52a8\u6709\u8da3\u3002
MIT \u7684\u79bb\u6563\u6570\u5b66\u4ee5\u53ca\u6982\u7387\u7efc\u5408\u8bfe\u7a0b\uff0c\u5bfc\u5e08\u662f\u5927\u540d\u9f0e\u9f0e\u7684 Tom Leighton ( Akamai \u7684\u8054\u5408\u521b\u59cb\u4eba\u4e4b\u4e00)\u3002\u5b66\u5b8c\u4e4b\u540e\u5bf9\u4e8e\u540e\u7eed\u7684\u7b97\u6cd5\u5b66\u4e60\u5927\u6709\u88e8\u76ca\u3002
"},{"location":"%E6%95%B0%E5%AD%A6%E8%BF%9B%E9%98%B6/CS126/","title":"UCB CS126 : Probability theory","text":""},{"location":"%E6%95%B0%E5%AD%A6%E8%BF%9B%E9%98%B6/CS126/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u540c\u65f6\u8fd9\u95e8\u8bfe\u975e\u5e38\u5f3a\u8c03\u7406\u8bba\u4e0e\u5b9e\u8df5\u7684\u7ed3\u5408\uff0c\u8bfe\u7a0b\u8bbe\u8ba1\u8005 Jean Walrand \u6559\u6388\u4e13\u95e8\u5199\u4e86\u4e00\u672c\u914d\u5957\u7684\u6559\u6750Probability in Electrical Engineering and Computer Science\uff0c\u4e66\u4e2d\u6bcf\u4e2a\u7ae0\u8282\u90fd\u4f1a\u4ee5\u4e00\u4e2a\u5177\u4f53\u7684\u7b97\u6cd5\u5b9e\u8df5\u4f5c\u4e3a\u4f8b\u5b50\u6765\u5c55\u793a\u7406\u8bba\u5728\u5b9e\u9645\u5f53\u4e2d\u7684\u8fd0\u7528\uff0c\u4f8b\u5982 PageRank, Route Planing, Speech Recognition \u7b49\u7b49\uff0c\u5e76\u4e14\u5168\u4e66\u5f00\u6e90\uff0c\u53ef\u4ee5\u514d\u8d39\u4e0b\u8f7d PDF \u6216\u8005 Epub \u7248\u3002
"},{"location":"%E6%95%B0%E5%AD%A6%E8%BF%9B%E9%98%B6/CS70/","title":"UCB CS70 : discrete Math and probability theory","text":""},{"location":"%E6%95%B0%E5%AD%A6%E8%BF%9B%E9%98%B6/CS70/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
"},{"location":"%E6%95%B0%E5%AD%A6%E8%BF%9B%E9%98%B6/The_Information_Theory_Pattern_Recognition_and_Neural_Networks/","title":"The Information Theory, Pattern Recognition, and Neural Networks","text":""},{"location":"%E6%95%B0%E5%AD%A6%E8%BF%9B%E9%98%B6/The_Information_Theory_Pattern_Recognition_and_Neural_Networks/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u6240\u5c5e\u5927\u5b66\uff1aCambridge
\u5148\u4fee\u8981\u6c42\uff1aCalculus, Linear Algebra, Probabilities and Statistics
\u7f16\u7a0b\u8bed\u8a00\uff1aAnything would be OK, Python preferred
\u5251\u6865\u5927\u5b66 Sir David MacKay \u6559\u6388\u7684\u4fe1\u606f\u8bba\u8bfe\u7a0b\u3002\u6559\u6388\u662f\u4e00\u4f4d\u5341\u5206\u7cbe\u901a\u4fe1\u606f\u8bba\u4e0e\u795e\u7ecf\u7f51\u7edc\u7684\u5b66\u8005\uff0c\u8bfe\u7a0b\u5bf9\u5e94\u6559\u6750\u4e5f\u662f\u4fe1\u606f\u8bba\u9886\u57df\u7684\u4e00\u90e8\u7ecf\u5178\u8457\u4f5c\u3002\u53ef\u60dc\u5929\u5992\u82f1\u624d...
"},{"location":"%E6%95%B0%E5%AD%A6%E8%BF%9B%E9%98%B6/The_Information_Theory_Pattern_Recognition_and_Neural_Networks/#rip-prof-david-mackay","title":"R.I.P Prof. David MacKay","text":""},{"location":"%E6%95%B0%E5%AD%A6%E8%BF%9B%E9%98%B6/convex/","title":"Stanford EE364A: Convex Optimization","text":""},{"location":"%E6%95%B0%E5%AD%A6%E8%BF%9B%E9%98%B6/convex/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
Stephen Boyd \u6559\u6388\u662f\u51f8\u4f18\u5316\u9886\u57df\u7684\u5927\u725b\uff0c\u5176\u7f16\u5199\u7684 Convex Optimization \u8fd9\u672c\u6559\u6750\u88ab\u4f17\u591a\u540d\u6821\u91c7\u7528\u3002\u53e6\u5916\u5176\u7814\u7a76\u56e2\u961f\u8fd8\u4e13\u95e8\u5f00\u53d1\u4e86\u4e00\u4e2a\u7528\u4e8e\u6c42\u89e3\u5e38\u89c1\u51f8\u4f18\u5316\u95ee\u9898\u7684\u7f16\u7a0b\u6846\u67b6\uff0c\u652f\u6301 Python, Julia \u7b49\u4e3b\u6d41\u7f16\u7a0b\u8bed\u8a00\uff0c\u5176\u8bfe\u7a0b\u4f5c\u4e1a\u4e5f\u662f\u91c7\u7528\u8fd9\u4e2a\u7f16\u7a0b\u6846\u67b6\u53bb\u89e3\u51b3\u5b9e\u9645\u751f\u6d3b\u5f53\u4e2d\u7684\u51f8\u4f18\u5316\u95ee\u9898\u3002
\u8fd9\u95e8\u8bfe\u4f1a\u5728\u6d6e\u70b9\u8868\u793a\u3001\u65b9\u7a0b\u6c42\u89e3\u3001\u7ebf\u6027\u4ee3\u6570\u3001\u5fae\u79ef\u5206\u3001\u5fae\u5206\u65b9\u7a0b\u7b49\u9886\u57df\u63a2\u8ba8\u5404\u7c7b\u6570\u503c\u5206\u6790\u65b9\u6cd5\uff0c\u8ba9\u4f60\u5728 Julia \u7684\u7f16\u7a0b\u5b9e\u8df5\u4e2d\u53cd\u590d\u4f53\u609f\uff081\uff09\u5982\u4f55\u5efa\u7acb\u4f30\u8ba1\uff082\uff09\u5982\u4f55\u4f30\u8ba1\u8bef\u5dee\uff083\uff09\u5982\u4f55\u7528\u7b97\u6cd5\u5b9e\u73b0\u4f30\u8ba1 \u8fd9\u4e00\u7cfb\u5217\u6b65\u9aa4\u3002
\u8fd9\u95e8\u8bfe\u7684\u8bbe\u8ba1\u8005\u8fd8\u7f16\u5199\u4e86\u914d\u5957\u7684\u5f00\u6e90\u6559\u6750\uff08\u53c2\u89c1\u4e0b\u65b9\u94fe\u63a5\uff09\uff0c\u91cc\u9762\u6709\u4e30\u5bcc\u7684 Julia \u5b9e\u4f8b\u3002
\u5305\u62ec Buffer Pool Manager (\u5185\u5b58\u7ba1\u7406), B Plus Tree (\u5b58\u50a8\u5f15\u64ce), Query Executors & Query Optimizer (\u7b97\u5b50\u4eec & \u4f18\u5316\u5668), Concurrency Control (\u5e76\u53d1\u63a7\u5236)\uff0c\u5206\u522b\u5bf9\u5e94 Project #1 \u5230 Project #4\u3002
\u6b64\u5916 bustub \u4f5c\u4e3a\u4e00\u4e2a C++ \u7f16\u5199\u7684\u4e2d\u5c0f\u578b\u9879\u76ee\u6db5\u76d6\u4e86\u7a0b\u5e8f\u6784\u5efa\u3001\u4ee3\u7801\u89c4\u8303\u3001\u5355\u5143\u6d4b\u8bd5\u7b49\u4f17\u591a\u8981\u6c42\uff0c\u53ef\u4ee5\u4f5c\u4e3a\u4e00\u4e2a\u4f18\u79c0\u7684\u5f00\u6e90\u9879\u76ee\u5b66\u4e60\u3002
\u5728 Fall 2019 \u4e2d\uff0cProject #2 \u662f\u505a\u54c8\u5e0c\u7d22\u5f15\uff0cProject #4 \u662f\u505a\u65e5\u5fd7\u4e0e\u6062\u590d\u3002
\u5728 Fall 2020 \u4e2d\uff0cProject #2 \u662f\u505a B \u6811\uff0cProject #4 \u662f\u505a\u5e76\u53d1\u63a7\u5236\u3002
\u5728 Fall 2021 \u4e2d\uff0cProject #1 \u662f\u505a\u7f13\u5b58\u6c60\u7ba1\u7406\uff0cProject #2 \u662f\u505a\u54c8\u5e0c\u7d22\u5f15\uff0cProject #4 \u662f\u505a\u5e76\u53d1\u63a7\u5236\u3002
\u5728 Fall 2022 \u4e2d\uff0c\u4e0e Fall 2021 \u76f8\u6bd4\u53ea\u6709\u54c8\u5e0c\u7d22\u5f15\u6362\u6210\u4e86 B+ \u6811\u7d22\u5f15\uff0c\u5176\u4f59\u90fd\u4e00\u6837\u3002
\u5728 Spring 2023 \u4e2d\uff0c\u5927\u4f53\u5185\u5bb9\u548c Fall 2022 \u4e00\u6837\uff08\u7f13\u5b58\u6c60\uff0cB+ \u6811\u7d22\u5f15\uff0c\u7b97\u5b50\uff0c\u5e76\u53d1\u63a7\u5236\uff09\uff0c\u53ea\u4e0d\u8fc7 Project #0 \u6362\u6210\u4e86 Copy-On-Write Trie\uff0c\u540c\u65f6\u589e\u52a0\u4e86\u5f88\u597d\u73a9\u7684\u6ce8\u518c\u5927\u5c0f\u5199\u51fd\u6570\u7684 Task\uff0c\u53ef\u4ee5\u76f4\u63a5\u5728\u7f16\u8bd1\u51fa\u7684 bustub-shell \u4e2d\u770b\u5230\u81ea\u5df1\u5199\u7684\u51fd\u6570\u7684\u5b9e\u9645\u6548\u679c\uff0c\u975e\u5e38\u6709\u6210\u5c31\u611f\u3002
\u503c\u5f97\u6ce8\u610f\u7684\u662f\uff0c\u73b0\u5728 bustub \u5728 2020 \u5e74\u4ee5\u524d\u7684 version \u90fd\u5df2\u7ecf\u505c\u6b62\u7ef4\u62a4\u3002
Fall 2019 \u7684\u6700\u540e\u4e00\u4e2a Logging & Recovery \u7684 Project \u5df2\u7ecf broken \u4e86\uff08\u572819\u5e74\u7684 git head \u4e0a\u4e5f\u8bb8\u8fd8\u53ef\u4ee5\u8dd1\uff0c\u4f46\u5c3d\u7ba1\u5982\u6b64 Gradescope \u5e94\u8be5\u4e5f\u6ca1\u6709\u63d0\u4f9b\u516c\u5171\u7684\u7248\u672c\uff0c\u6240\u4ee5\u5e76\u4e0d\u63a8\u8350\u5927\u5bb6\u53bb\u505a\uff0c\u53ea\u770b\u770b\u4ee3\u7801\u548c Handout \u5c31\u53ef\u4ee5\u4e86\uff09\u3002
\u6216\u8bb8\u5728 Fall 2023 \u7684\u7248\u672c Recovery \u76f8\u5173\u7684\u529f\u80fd\u4f1a\u88ab\u4fee\u590d\uff0c\u5c4a\u65f6\u4e5f\u53ef\u80fd\u6709\u5168\u65b0\u7684 Recovery Project\uff0c\u8ba9\u6211\u4eec\u8bd5\u76ee\u4ee5\u5f85\u5427\ud83e\udd2a
\u53e6\u5916\u5728\u8bfe\u7a0b\u7ed3\u675f\u540e\uff0c\u63a8\u8350\u9605\u8bfb\u4e00\u7bc7\u8bba\u6587 Architecture Of a Database System\uff0c\u5bf9\u5e94\u7684\u4e2d\u6587\u7248\u4e5f\u5728\u4e0a\u8ff0\u4ed3\u5e93\u4e2d\u3002\u8bba\u6587\u91cc\u7efc\u8ff0\u4e86\u6570\u636e\u5e93\u7cfb\u7edf\u7684\u6574\u4f53\u67b6\u6784\uff0c\u8ba9\u5927\u5bb6\u53ef\u4ee5\u5bf9\u6570\u636e\u5e93\u6709\u4e00\u4e2a\u66f4\u52a0\u5168\u9762\u7684\u89c6\u91ce\u3002
CMU15-721 \u4e3b\u8981\u8bb2\u4e3b\u5b58\u6570\u636e\u5e93\u6709\u5173\u7684\u5185\u5bb9\uff0c\u6bcf\u8282\u8bfe\u90fd\u6709\u5bf9\u5e94\u7684 paper \u8981\u8bfb\uff0c\u63a8\u8350\u7ed9\u5e0c\u671b\u8fdb\u9636\u6570\u636e\u5e93\u7684\u5c0f\u4f19\u4f34\u3002@ysj1173886760 \u76ee\u524d\u4e5f\u5728\u8ddf\u8fdb\u8fd9\u95e8\u8bfe\uff0c\u5b8c\u6210\u540e\u4f1a\u5728\u8fd9\u91cc\u63d0 PR \u4ee5\u63d0\u4f9b\u8fdb\u9636\u7684\u6307\u5bfc\u3002
"},{"location":"%E6%95%B0%E6%8D%AE%E5%BA%93%E7%B3%BB%E7%BB%9F/15799/","title":"CMU 15-799: Special Topics in Database Systems","text":""},{"location":"%E6%95%B0%E6%8D%AE%E5%BA%93%E7%B3%BB%E7%BB%9F/15799/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
The record management component\uff1a\u8bb0\u5f55\u7ba1\u7406\u7ec4\u4ef6\u3002
The index component\uff1aB+ \u7d22\u5f15\u7ba1\u7406\u3002
The System Management Component\uff1addl\u8bed\u53e5\u3001\u547d\u4ee4\u884c\u5de5\u5177\u3001\u6570\u636e\u52a0\u8f7d\u547d\u4ee4\u3001\u5143\u6570\u636e\u7ba1\u7406\u3002
The Query Language Component\uff1a\u5728\u8fd9\u4e2a\u90e8\u5206\u9700\u8981\u5b9e\u73b0 RQL Redbase \u67e5\u8be2\u8bed\u8a00\u3002RQL \u8981\u5b9e\u73b0 select\u3001insert\u3001delete\u3001update \u8bed\u53e5\u3002
RedBase \u9002\u5408\u5728\u5b66\u5b8c CMU 15-445 \u540e\u7ee7\u7eed\u5b66\u4e60\u6570\u636e\u5e93\u7cfb\u7edf\u4e2d\u7684\u5176\u4ed6\u7ec4\u4ef6\uff0c\u56e0\u4e3a\u5176\u4ee3\u7801\u91cf\u4e0d\u591a\uff0c\u53ef\u4ee5\u65b9\u4fbf\u7684\u6839\u636e\u9700\u8981\u6269\u5c55\u4ee3\u7801\u3002\u540c\u65f6\u4ee3\u7801\u5b8c\u5168\u7531 C++ \u7f16\u5199\uff0c\u4e5f\u53ef\u4ee5\u7528\u4e8e\u7ec3\u4e60 C++ \u7f16\u7a0b\u6280\u5de7\u3002
"},{"location":"%E6%95%B0%E6%8D%AE%E7%A7%91%E5%AD%A6/Data100/","title":"UCB Data100: Principles and Techniques of Data Science","text":""},{"location":"%E6%95%B0%E6%8D%AE%E7%A7%91%E5%AD%A6/Data100/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
"},{"location":"%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E4%B8%8E%E7%AE%97%E6%B3%95/6.006/","title":"MIT 6.006: Introduction to Algorithms","text":""},{"location":"%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E4%B8%8E%E7%AE%97%E6%B3%95/6.006/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u6240\u5c5e\u5927\u5b66\uff1aMIT
\u5148\u4fee\u8981\u6c42\uff1a\u8ba1\u7b97\u673a\u5bfc\u8bba(CS50/CS61A or equivalent)
\u8bfe\u7a0b\u6559\u6750\uff1aIntroduction to Algorithms (CLRS)
\u8bfe\u7a0b\u4f5c\u4e1a\uff1aFall 2011
"},{"location":"%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E4%B8%8E%E7%AE%97%E6%B3%95/6.046/","title":"MIT 6.046: Design and Analysis of Algorithms","text":""},{"location":"%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E4%B8%8E%E7%AE%97%E6%B3%95/6.046/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u6240\u5c5e\u5927\u5b66\uff1aMIT
\u5148\u4fee\u8981\u6c42\uff1a\u7b97\u6cd5\u5165\u95e8(6.006/CS61B/CS106B/CS106X or equivalent)
\u8bfe\u7a0b\u6559\u6750\uff1aIntroduction to Algorithms (CLRS)
\u8bfe\u7a0b\u4f5c\u4e1a\uff1aSpring 2015
"},{"location":"%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E4%B8%8E%E7%AE%97%E6%B3%95/Algo/","title":"Coursera: Algorithms I & II","text":""},{"location":"%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E4%B8%8E%E7%AE%97%E6%B3%95/Algo/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
"},{"location":"%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E4%B8%8E%E7%AE%97%E6%B3%95/CS61B/","title":"CS61B: Data Structures and Algorithms","text":""},{"location":"%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E4%B8%8E%E7%AE%97%E6%B3%95/CS61B/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
"},{"location":"%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/CS189/","title":"CS189: Introduction to Machine Learning","text":""},{"location":"%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/CS189/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u4e2a\u4eba\u4f53\u4f1a\u662f\u7b2c\u4e09\u7ae0\u5b9e\u73b0\u7b97\u5b50\u7684\u5b9e\u9a8c\u8ba9\u6211\u5bf9\u6df1\u5ea6\u5b66\u4e60\u6846\u67b6\u7684\u4e86\u89e3\u52a0\u6df1\u4e86\u5f88\u591a\u3002\u7b2c\u4e94\u7ae0\u7684\u5b9e\u9a8cBCL\u8bed\u8a00\u7f16\u5199\u7b97\u5b50\u5982\u679c\u4e86\u89e3 CUDA \u7684\u8bdd\u4f1a\u611f\u89c9\u5f88\u719f\u6089\u3002
"},{"location":"%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%E7%B3%BB%E7%BB%9F/CMU10-414/","title":"CMU 10-414/714: Deep Learning Systems","text":""},{"location":"%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%E7%B3%BB%E7%BB%9F/CMU10-414/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u8bfe\u7a0b\u7f51\u7ad9\u5305\u542b\u4e86\u6240\u6709\u7684\u8d44\u6e90\uff1aslides, notes, video, homework, and project
\u8fd9\u95e8\u8bfe\u7a0b\u662f CMU \u7684\u56fe\u6a21\u578b\u57fa\u7840 + \u8fdb\u9636\u8bfe\uff0c\u6388\u8bfe\u8001\u5e08\u4e3a Eric P. Xing\uff0c\u6db5\u76d6\u4e86\u56fe\u6a21\u578b\u57fa\u7840\uff0c\u4e0e\u795e\u7ecf\u7f51\u7edc\u7684\u7ed3\u5408\uff0c\u5728\u5f3a\u5316\u5b66\u4e60\u4e2d\u7684\u5e94\u7528\uff0c\u4ee5\u53ca\u975e\u53c2\u6570\u65b9\u6cd5\uff0c\u76f8\u5f53\u786c\u6838\u3002
\u8fd9\u662f\u4e00\u95e8\u8f83\u4e3a\u8fdb\u9636\u7684 Ph.D. \u7814\u7a76\u8bfe\u7a0b\uff0c\u6838\u5fc3\u5185\u5bb9\u662f inference \u548c control \u4e4b\u95f4\u7684\u5173\u7cfb\u3002\u6388\u8bfe\u8001\u5e08\u4e3a Chris Maddison (AlphaGo founding member, NeurIPS 14 best paper)\u3002
"},{"location":"%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%E8%BF%9B%E9%98%B6/STAT8201/","title":"Columbia STAT 8201: Deep Generative Models","text":""},{"location":"%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%E8%BF%9B%E9%98%B6/STAT8201/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u6240\u5c5e\u5927\u5b66\uff1aColumbia University
\u5148\u4fee\u8981\u6c42\uff1aMachine Learning, Deep Learning, Graphical Models
\u673a\u5668\u5b66\u4e60\u8fdb\u9636\u53ef\u80fd\u5b58\u5728\u591a\u79cd\u4e0d\u540c\u7684\u5b66\u4e60\u8def\u7ebf\uff0c\u6b64\u8def\u7ebf\u53ea\u80fd\u4ee3\u8868\u4f5c\u8005 Yao Fu \u6240\u7406\u89e3\u7684\u6700\u4f73\u8def\u5f84\uff0c\u4fa7\u91cd\u4e8e\u8d1d\u53f6\u65af\u5b66\u6d3e\u4e0b\u7684\u6982\u7387\u5efa\u6a21\u65b9\u6cd5\uff0c\u4e5f\u4f1a\u6d89\u53ca\u5230\u5404\u9879\u76f8\u5173\u5b66\u79d1\u7684\u4ea4\u53c9\u77e5\u8bc6\u3002
\u8fdb\u9636\u4e66\u7c4d\u5148\u4e0d\u8bfb\uff0c\u5148\u8bfb\u5b8c\u5fc5\u8bfb\u4e66\u7c4d\u3002\u5fc5\u8bfb\u4e66\u7c4d\u4e00\u822c\u90fd\u662f\u8981\u524d\u524d\u540e\u540e\u53cd\u590d\u770b\u8fc7 N \u904d\u624d\u7b97\u8bfb\u5b8c
\u5148\u8bfb AoS \u7b2c\u516d\u7ae0: Models, Statistical Inference and Learning\uff0c\u8fd9\u4e00\u90e8\u5206\u662f\u6700\u57fa\u7840\u7684\u79d1\u666e
\u4e8e\u662f\u6211\u5f80\u524d\u7ffb\uff0c\u7ffb\u5230\u4e86\u7b2c 3 \u7ae0 (Linear Model for Regression)\uff0c\u770b\u5230\u4e86\u6700\u7b80\u5355\u7684 posterior
"},{"location":"%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/CS224n/","title":"CS224n: Natural Language Processing","text":""},{"location":"%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/CS224n/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
"},{"location":"%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/CS224w/","title":"CS224w: Machine Learning with Graphs","text":""},{"location":"%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/CS224w/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
"},{"location":"%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/CS230/","title":"Coursera: Deep Learning","text":""},{"location":"%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/CS230/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
"},{"location":"%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/CS231/","title":"CS231n: CNN for Visual Recognition","text":""},{"location":"%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/CS231/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
"},{"location":"%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/CS285/","title":"CS285: Deep Reinforcement Learning","text":""},{"location":"%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/CS285/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
"},{"location":"%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/EECS498-007/","title":"UMich EECS 498-007 / 598-005: Deep Learning for Computer Vision","text":""},{"location":"%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/EECS498-007/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
"},{"location":"%E7%94%B5%E5%AD%90%E5%9F%BA%E7%A1%80/EE16/","title":"UCB EE16A&B: Designing Information Devices and Systems I&II","text":""},{"location":"%E7%94%B5%E5%AD%90%E5%9F%BA%E7%A1%80/EE16/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
"},{"location":"%E7%94%B5%E5%AD%90%E5%9F%BA%E7%A1%80/Signals_and_Systems_AVO/","title":"MIT 6.007 Signals and Systems","text":""},{"location":"%E7%94%B5%E5%AD%90%E5%9F%BA%E7%A1%80/Signals_and_Systems_AVO/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u6240\u5c5e\u5927\u5b66\uff1aMIT
\u5148\u4fee\u8981\u6c42\uff1aCalculus, Linear Algebra
"},{"location":"%E7%94%B5%E5%AD%90%E5%9F%BA%E7%A1%80/signal/","title":"UCB EE120: Signal and Systems","text":""},{"location":"%E7%94%B5%E5%AD%90%E5%9F%BA%E7%A1%80/signal/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
"},{"location":"%E7%B3%BB%E7%BB%9F%E5%AE%89%E5%85%A8/CSE365/","title":"ASU CSE365: Introduction to Cybersecurity","text":""},{"location":"%E7%B3%BB%E7%BB%9F%E5%AE%89%E5%85%A8/CSE365/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u6240\u5c5e\u5927\u5b66\uff1aArizona State University
\u5148\u4fee\u8981\u6c42\uff1a\u65e0
\u7f16\u7a0b\u8bed\u8a00\uff1aC, Python, x86 assembly
\u4e9a\u5229\u6851\u90a3\u5dde\u7acb\u5927\u5b66 Web \u5b89\u5168\u7684\u5bfc\u8bba\u8bfe\uff0c\u8bfe\u7a0b\u4ee5\u6a21\u5757\u5316\u7684\u5f62\u5f0f\u6784\u6210\uff0c\u4e3b\u8981\u5305\u542b\u4ee5\u4e0b\u65b9\u9762\uff1a
Program Misuse: Linux commandline, privilege escalation
"},{"location":"%E7%B3%BB%E7%BB%9F%E5%AE%89%E5%85%A8/CSE466/","title":"ASU CSE466: Computer Systems Security","text":""},{"location":"%E7%B3%BB%E7%BB%9F%E5%AE%89%E5%85%A8/CSE466/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u6240\u5c5e\u5927\u5b66\uff1aArizona State University
\u5148\u4fee\u8981\u6c42\uff1a\u65e0
\u7f16\u7a0b\u8bed\u8a00\uff1aC, Python, x86 assembly
"},{"location":"%E7%B3%BB%E7%BB%9F%E5%AE%89%E5%85%A8/MIT6.1600/","title":"MIT6.1600: Foundations of Computer Security","text":""},{"location":"%E7%B3%BB%E7%BB%9F%E5%AE%89%E5%85%A8/MIT6.1600/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
"},{"location":"%E7%B3%BB%E7%BB%9F%E5%AE%89%E5%85%A8/MIT6.858/","title":"MIT 6.858: Computer System Security","text":""},{"location":"%E7%B3%BB%E7%BB%9F%E5%AE%89%E5%85%A8/MIT6.858/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
MIT \u7684\u8ba1\u7b97\u673a\u7cfb\u7edf\u5b89\u5168\u8bfe\u7a0b\uff0c\u5b9e\u9a8c\u73af\u5883\u662f\u4e00\u4e2a Web Application Zoobar\u3002\u5b66\u751f\u5b66\u4e60\u653b\u9632\u6280\u672f\u5e76\u5e94\u7528\u4e8e\u8be5 Web Application\u3002
Lab 1: you will explore the zoobar web application, and use buffer overflow attacks to break its security properties.
Lab 2: you will improve the zoobar web application by using privilege separation, so that if one component is compromised, the adversary doesn't get control over the whole web application.
Lab 3: you will build a program analysis tool based on symbolic execution to find bugs in Python code such as the zoobar web application.
Lab 4: you will improve the zoobar application against browser attacks.
\u9664\u4e86 MIT \u5b98\u65b9\u7684\u5b66\u4e60\u8d44\u6599\u5916\uff0c\u5317\u4eac\u5927\u5b66\u56fe\u7075\u73ed\u5f00\u8bbe\u7684\u524d\u6cbf\u8ba1\u7b97\u5b9e\u8df5\u4e2d\u4e5f\u5f00\u8bbe\u4e86\u76f8\u5173\u8bfe\u7a0b\uff0c\u8d44\u6599\u4f4d\u4e8e\u8fd9\u4e2a\u7f51\u7ad9\u4e0b\uff0c\u4f9b\u5927\u5bb6\u53c2\u8003\u3002
"},{"location":"%E7%BC%96%E7%A8%8B%E5%85%A5%E9%97%A8/C/CS50/","title":"CS50: This is CS50x","text":""},{"location":"%E7%BC%96%E7%A8%8B%E5%85%A5%E9%97%A8/C/CS50/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u8bfe\u7a0b\u89c6\u9891\uff1a\u539f\u7248\u53c2\u8003\u8bfe\u7a0b\u7f51\u7ad9\uff0c\u4e5f\u53ef\u4ee5\u5728 B \u7ad9\u627e\u5230\u4e2d\u6587\u5b57\u5e55\u7248\u3002
"},{"location":"%E7%BC%96%E7%A8%8B%E5%85%A5%E9%97%A8/C/Duke-Coursera-Intro-C/","title":"Introductory C Programming Specialization","text":""},{"location":"%E7%BC%96%E7%A8%8B%E5%85%A5%E9%97%A8/C/Duke-Coursera-Intro-C/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
@haidongji \u5728\u5b66\u4e60\u8fd9\u95e8\u8bfe\u4e2d\u7684\u4f5c\u4e1a\u5b9e\u73b0\u90fd\u6c47\u603b\u5728 Duke Coursera Intro C \u4e2d\u3002\u56e0\u4e3a\u65f6\u95f4\u5173\u7cfb\uff0c\u6211\u6700\u540e\u4e00\u8bfe\u6700\u540e\u4e00\u5468\u7684\u51e0\u4e2a\u4f5c\u4e1a\u5230\u76ee\u524d\u8fd8\u6ca1\u6709\u5b8c\u6210\u3002
\u4e3b\u8bb2\u8001\u5e08 Michael Ryan Clarkson\uff0c\u6d78\u6deb\u7f16\u7a0b\u591a\u5e74\uff0c\u7528\u8bcd\u7b80\u5355\uff0c\u8868\u8ff0\u6e05\u6670\uff0c\u5185\u5bb9\u73af\u73af\u76f8\u6263\uff0c\u5256\u6790\u4e00\u9488\u89c1\u8840\u3002\u8bfe\u7a0b\u89c6\u9891\u751a\u81f3\u7528\u6765\u7ec3\u542c\u529b\uff0c\u542c\u4e0d\u61c2\u5f00\u82f1\u6587\u5b57\u5e55\u7406\u89e3\u8d77\u6765\u6beb\u4e0d\u8d39\u529b\u3002
"},{"location":"%E7%BC%96%E7%A8%8B%E5%85%A5%E9%97%A8/Java/MIT%206.092/","title":"MIT 6.092: Introduction To Programming In Java","text":""},{"location":"%E7%BC%96%E7%A8%8B%E5%85%A5%E9%97%A8/Java/MIT%206.092/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
"},{"location":"%E7%BC%96%E7%A8%8B%E5%85%A5%E9%97%A8/Python/CS50P/","title":"CS50P Introduction to Programming with Python","text":""},{"location":"%E7%BC%96%E7%A8%8B%E5%85%A5%E9%97%A8/Python/CS50P/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
"},{"location":"%E7%BC%96%E7%A8%8B%E5%85%A5%E9%97%A8/Python/CS61A/","title":"CS61A: Structure and Interpretation of Computer Programs","text":""},{"location":"%E7%BC%96%E7%A8%8B%E5%85%A5%E9%97%A8/Python/CS61A/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
"},{"location":"%E7%BC%96%E7%A8%8B%E5%85%A5%E9%97%A8/Rust/CS110L/","title":"CS110L: Safety in Systems Programming","text":""},{"location":"%E7%BC%96%E7%A8%8B%E5%85%A5%E9%97%A8/Rust/CS110L/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u5982\u679c\u4f60\u5b66\u8fc7 C \u5e76\u63a5\u89e6\u8fc7\u4e00\u4e9b\u7cfb\u7edf\u7f16\u7a0b\u7684\u8bdd\uff0c\u5e94\u8be5\u5bf9 C \u7684\u5185\u5b58\u6cc4\u6f0f\u4ee5\u53ca\u6307\u9488\u7684\u5371\u9669\u6709\u6240\u8033\u95fb\uff0c\u4f46 C \u7684\u5e95\u5c42\u7279\u6027\u4ee5\u53ca\u9ad8\u6548\u4ecd\u7136\u8ba9\u5b83\u5728\u7cfb\u7edf\u7ea7\u7f16\u7a0b\u4e2d\u65e0\u6cd5\u88ab\u4f8b\u5982 Java \u7b49\u81ea\u5e26\u5783\u573e\u6536\u96c6\u673a\u5236\u7684\u9ad8\u7ea7\u8bed\u8a00\u6240\u66ff\u4ee3\u3002\u800c Rust \u7684\u76ee\u6807\u5219\u662f\u5e0c\u671b\u5728 C \u7684\u9ad8\u6548\u57fa\u7840\u4e0a\uff0c\u5f25\u8865\u5176\u5b89\u5168\u4e0d\u8db3\u7684\u7f3a\u70b9\u3002\u56e0\u6b64 Rust \u5728\u8bbe\u8ba1\u4e4b\u521d\uff0c\u5c31\u6709\u5e26\u6709\u5f88\u591a\u7cfb\u7edf\u7f16\u7a0b\u7684\u89c2\u70b9\u3002\u5b66\u4e60 Rust\uff0c\u4e5f\u80fd\u8ba9\u4f60\u4e4b\u540e\u80fd\u7528 C \u8bed\u8a00\u7f16\u5199\u51fa\u66f4\u5b89\u5168\u66f4\u4f18\u96c5\u7684\u7cfb\u7edf\u7ea7\u4ee3\u7801\uff08\u4f8b\u5982\u64cd\u4f5c\u7cfb\u7edf\u7b49\uff09\u3002
"},{"location":"%E7%BC%96%E7%A8%8B%E5%85%A5%E9%97%A8/cpp/AUT1400/","title":"Amirkabir University of Technology 1400-2: Advanced Programming Course","text":""},{"location":"%E7%BC%96%E7%A8%8B%E5%85%A5%E9%97%A8/cpp/AUT1400/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u6240\u5c5e\u5927\u5b66\uff1aAmirkabir University of Technology
"},{"location":"%E7%BC%96%E7%A8%8B%E5%85%A5%E9%97%A8/cpp/CS106L/","title":"CS106L: Standard C++ Programming","text":""},{"location":"%E7%BC%96%E7%A8%8B%E5%85%A5%E9%97%A8/cpp/CS106L/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u6211\u4ece\u5927\u4e00\u5f00\u59cb\u4e00\u76f4\u90fd\u662f\u5199\u7684 C++ \u4ee3\u7801\uff0c\u76f4\u5230\u5b66\u5b8c\u8fd9\u95e8\u8bfe\u6211\u624d\u610f\u8bc6\u5230\uff0c\u6211\u5199\u7684 C++ \u4ee3\u7801\u5927\u6982\u53ea\u662f C \u8bed\u8a00 + cin/cout \u800c\u5df2\u3002
\u8fd9\u95e8\u8bfe\u4f1a\u6df1\u5165\u5230\u5f88\u591a\u6807\u51c6 C++ \u7684\u7279\u6027\u548c\u8bed\u6cd5\uff0c\u8ba9\u4f60\u7f16\u5199\u51fa\u9ad8\u8d28\u91cf\u7684 C++ \u4ee3\u7801\u3002\u4f8b\u5982 auto binding, uniform initialization, lambda function, move semantics\uff0cRAII \u7b49\u6280\u5de7\u90fd\u5728\u6211\u6b64\u540e\u7684\u4ee3\u7801\u751f\u6daf\u4e2d\u88ab\u53cd\u590d\u7528\u5230\uff0c\u975e\u5e38\u5b9e\u7528\u3002
\u4e3b\u8bb2\u8001\u5e08 Will Crichton \u8fd8\u5c06\u4ed6\u7684\u8bfe\u7a0b\u8bbe\u8ba1\u601d\u60f3\u5199\u6210\u4e86\u8bba\u6587 From Theory to Systems: A Grounded Approach to Programming Language Education\uff0c\u9610\u8ff0\u4e86\u8fd9\u6761\u4ece\u7406\u8bba\u8d70\u5411\u7cfb\u7edf\u7684\u6559\u5b66\u8def\u7ebf\u3002
"},{"location":"%E7%BC%96%E7%A8%8B%E8%AF%AD%E8%A8%80%E8%AE%BE%E8%AE%A1%E4%B8%8E%E5%88%86%E6%9E%90/Cambridge-Semantics/","title":"Cambridge: Semantics of Programming Languages","text":""},{"location":"%E7%BC%96%E7%A8%8B%E8%AF%AD%E8%A8%80%E8%AE%BE%E8%AE%A1%E4%B8%8E%E5%88%86%E6%9E%90/Cambridge-Semantics/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u6240\u5c5e\u5927\u5b66\uff1aUniversity of Cambridge
\u8be5\u8bfe\u7a0b\u9762\u5411\u771f\u5b9e\u7684 C \u8bed\u8a00\u800c\u975e\u81ea\u5b9a\u4e49\u7684\u73a9\u5177\u8bed\u8a00\uff0c\u5e76\u4e14\u4f1a\u4f7f\u7528 C \u8bed\u8a00 Fuzzing \u5de5\u5177 (Csmith) \u8fdb\u884c\u6d4b\u8bd5\u3002
\u8be5\u8bfe\u7a0b\u6ce8\u91cd\u5b9e\u7528\u6027\uff0c\u5bf9\u7f16\u8bd1\u5668\u524d\u7aef\u7406\u8bba\u6d89\u53ca\u5f88\u5c11\uff0c\u7b2c\u4e00\u4e2a\u5b9e\u9a8c\u4e5f\u662f\u76f4\u63a5\u4ece\u62bd\u8c61\u8bed\u6cd5\u6811\u7684\u904d\u5386\u5f00\u59cb\uff0c\u5e76\u4e0d\u8981\u6c42\u4f60\u624b\u52a8\u5b8c\u6210\u524d\u7aef\u3002\u8bfe\u7a0b\u91cd\u70b9\u5173\u6ce8\u4e8e IR \u7684\u8bbe\u8ba1\u3001\u751f\u6210\u548c\u4f18\u5316\uff0c\u4ee5\u53ca RISC-V \u6c47\u7f16\u4ee3\u7801\u751f\u6210\u3002\u672c\u8bfe\u7a0b\u5bf9\u4e8e\u7406\u89e3\u548c\u5b66\u4e60 LLVM \u4e5f\u5f88\u6709\u5e2e\u52a9\u3002
\u6559\u7a0b\u91c7\u7528\u589e\u91cf\u5f0f\u3001\u8fed\u4ee3\u5f0f\u7684\u601d\u8def\uff0c\u5f15\u5bfc\u4f60\u4ece\u4e00\u4e2a\u53ea\u80fd\u5904\u7406 main \u51fd\u6570\u7684\u7f16\u8bd1\u5668\u5f00\u59cb\uff0c\u9010\u6b65\u6269\u5c55\u5b9e\u73b0\u4e00\u4e2a\u80fd\u5904\u7406\u5305\u62ec\u63a7\u5236\u6d41\u3001\u51fd\u6570\u8c03\u7528\u3001\u6570\u7ec4\u5728\u5185\u7684\uff0c\u7c7b C \u8bed\u8a00\u7684\u7f16\u8bd1\u5668\u3002\u7f16\u8bd1\u5668\u53ef\u4ee5\u8f93\u51fa RISC-V \u6c47\u7f16\u3002
\u6559\u7a0b\u4ecb\u7ecd\u4e86\u76f8\u5173\u5de5\u5177\uff0c\u53ef\u4ee5\u4e3a\u4f60\u4ee3\u52b3\u4e00\u4e9b\u67af\u71e5\u7684\u82e6\u529b\u6d3b\uff0c\u6bd4\u5982\u751f\u6210 lexer/parser\uff0c\u89e3\u6790\u548c\u751f\u6210 IR \u7b49\u7b49\u3002\u5269\u4e0b\u7684\u4e8b\u60c5\uff0c\u5982\u6784\u5efa AST\u3001\u8bed\u4e49\u5206\u6790\u3001\u751f\u6210 IR \u4ee5\u53ca\u751f\u6210\u76ee\u6807\u4ee3\u7801\uff0c\u5b8c\u5168\u7531\u4f60\u81ea\u5df1\u7f16\u7a0b\u5b9e\u73b0\u3002
\u6700\u540e\uff0c\u5411 @MaxXing \u81f4\u4ee5\u6211\u5d07\u9ad8\u7684\u656c\u610f\u3002\u2014\u2014 from PKUFlyingPig
"},{"location":"%E7%BC%96%E8%AF%91%E5%8E%9F%E7%90%86/USTC-Compilers/","title":"USTC: Principles and Techniques of Compiler","text":""},{"location":"%E7%BC%96%E8%AF%91%E5%8E%9F%E7%90%86/USTC-Compilers/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u8fd9\u95e8\u8bfe\u7a0b\u7684\u7406\u8bba\u90e8\u5206\u5185\u5bb9\u5e7f\u6cdb\uff0c\u65e2\u6db5\u76d6\u4e86\u4f20\u7edf\u7f16\u8bd1\u539f\u7406\u8bfe\u7a0b\u7684\u8bcd\u6cd5\u5206\u6790\u3001\u8bed\u6cd5\u5206\u6790\u3001\u8bed\u6cd5\u5236\u5bfc\u7ffb\u8bd1\u3001\u4e2d\u95f4\u4ee3\u7801\u7ffb\u8bd1\uff0c\u53c8\u8986\u76d6\u4e86\u8fd0\u884c\u65f6\u7ba1\u7406\u3001\u673a\u5668\u65e0\u5173\u4e0e\u9762\u5411\u673a\u5668\u7684\u4ee3\u7801\u4f18\u5316\u3002\u5b9e\u9a8c\u90e8\u5206\u5219\u63d0\u4f9b\u4e86 C++ \u8bed\u8a00\u7f16\u5199\u7684Cminusf\u7f16\u8bd1\u5668\u6846\u67b6\u4ee3\u7801\uff0c\u4e8e6\u4e2a\u5b9e\u9a8c\u4e2d\u9010\u6b65\u6784\u5efa\u4e00\u4e2a\u5177\u5907\u73b0\u4ee3\u5b8c\u6574\u6d41\u7a0b\u7684\u7f16\u8bd1\u5668\u3002\u4e0e\u5176\u4ed6\u7f16\u8bd1\u539f\u7406\u8bfe\u7a0b\u7684\u5b9e\u9a8c\u4e0d\u540c\u7684\u662f\uff0c\u672c\u8bfe\u7a0b\u7684\u5b9e\u9a8c\u91c7\u7528\u73b0\u4ee3LLVM\u7684\u5b50\u96c6\u4f5c\u4e3a\u4e2d\u95f4\u4ee3\u7801\uff0c\u66f4\u5177\u524d\u77bb\u6027\uff0c\u540c\u65f6\u5305\u62ec\u4e86\u540e\u7aef\u4ee3\u7801\u7684\u751f\u6210\u548c\u4e2d\u95f4\u4ee3\u7801\u4f18\u5316\u7684\u90e8\u5206\uff0c\u582a\u79f0\u56fd\u9645\u4e00\u6d41\u7684\u7f16\u8bd1\u539f\u7406\u8bfe\u7a0b\u3002
"},{"location":"%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%B3%BB%E7%BB%9F%E5%9F%BA%E7%A1%80/CS110/","title":"CS110: Principles of Computer Systems","text":""},{"location":"%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%B3%BB%E7%BB%9F%E5%9F%BA%E7%A1%80/CS110/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u5317\u5927\u8d2d\u4e70\u4e86\u8fd9\u95e8\u8bfe\u7684\u7248\u6743\u5e76\u5f00\u8bbe\u4e86 Introduction to Computer System \u8fd9\u95e8\u8bfe\uff0c\u4f46\u5176\u5b9e CSAPP \u6240\u6709\u7684\u8bfe\u7a0b\u8d44\u6e90\u548c\u5b9e\u9a8c\u4ee3\u7801\u90fd\u80fd\u5728\u5b83\u7684\u5b98\u65b9\u4e3b\u9875\u4e0a\u8bbf\u95ee\u5230\uff08\u5177\u4f53\u53c2\u89c1\u4e0b\u65b9\u94fe\u63a5\uff09\u3002
\u8fd9\u95e8\u8bfe\u7684\u4e3b\u8bb2\u4eba\u4e4b\u4e00\u662f\u7f51\u7edc\u9886\u57df\u7684\u5de8\u64d8 Nick McKeown \u6559\u6388\u3002\u8fd9\u4f4d\u62e5\u6709\u81ea\u5df1\u521b\u4e1a\u516c\u53f8\u7684\u5b66\u754c\u4e1a\u754c\u53cc\u5de8\u4f6c\u4f1a\u5728\u4ed6\u6155\u8bfe\u6bcf\u4e00\u7ae0\u8282\u7684\u6700\u540e\u91c7\u8bbf\u4e00\u4f4d\u4e1a\u754c\u7684\u9ad8\u7ba1\u6216\u8005\u5b66\u754c\u7684\u9ad8\u4eba\uff0c\u975e\u5e38\u5f00\u9614\u773c\u754c\u3002
\u5728\u8fd9\u95e8\u8bfe\u7684 Project \u4e2d\uff0c\u4f60\u5c06\u7528 C++ \u5faa\u5e8f\u6e10\u8fdb\u5730\u642d\u5efa\u51fa\u6574\u4e2a TCP/IP \u534f\u8bae\u6808\uff0c\u5b9e\u73b0 IP \u8def\u7531\u4ee5\u53ca ARP \u534f\u8bae\uff0c\u6700\u540e\u5229\u7528\u4f60\u81ea\u5df1\u7684\u534f\u8bae\u6808\u4ee3\u66ff Linux Kernel \u7684\u7f51\u7edc\u534f\u8bae\u6808\u548c\u5176\u4ed6\u5b66\u751f\u7684\u8ba1\u7b97\u673a\u8fdb\u884c\u901a\u4fe1\uff0c\u975e\u5e38 amazing\uff01
"},{"location":"%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%BD%91%E7%BB%9C/topdown/","title":"Computer Networking: A Top-Down Approach","text":""},{"location":"%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%BD%91%E7%BB%9C/topdown/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u300a\u81ea\u9876\u5411\u4e0b\u65b9\u6cd5\u300b\u662f\u8ba1\u7b97\u673a\u7f51\u7edc\u9886\u57df\u7684\u4e00\u672c\u7ecf\u5178\u6559\u6750\uff0c\u4e24\u4f4d\u4f5c\u8005 Jim Kurose \u548c Keith Ross \u7cbe\u5fc3\u5236\u4f5c\u4e86\u6559\u6750\u914d\u5957\u7684\u8bfe\u7a0b\u7f51\u7ad9\uff0c\u5e76\u4e14\u516c\u5f00\u4e86\u81ea\u5df1\u5f55\u5236\u7684\u7f51\u8bfe\u89c6\u9891\uff0c\u4ea4\u4e92\u5f0f\u7684\u5728\u7ebf\u7ae0\u8282\u6d4b\u8bd5\uff0c\u4ee5\u53ca\u5229\u7528 WireShark \u8fdb\u884c\u6293\u5305\u5206\u6790\u7684 lab\u3002\u552f\u4e00\u9057\u61be\u7684\u662f\u8fd9\u95e8\u8bfe\u5e76\u6ca1\u6709\u786c\u6838\u7684\u7f16\u7a0b\u4f5c\u4e1a\uff0c\u800c Stanford \u7684 CS144 \u80fd\u5f88\u597d\u5730\u5f25\u8865\u8fd9\u4e00\u70b9\u3002
Safe from bugs. Correctness (correct behavior right now) and defensiveness (correct behavior in the future) are required in any software we build.
Easy to understand. The code has to communicate to future programmers who need to understand it and make changes in it (fixing bugs or adding new features). That future programmer might be you, months or years from now. You\u2019ll be surprised how much you forget if you don\u2019t write it down, and how much it helps your own future self to have a good design.
Ready for change. Software always changes. Some designs make it easy to make changes; others require throwing away and rewriting a lot of code.
\u4f2f\u514b\u5229\u7684\u8f6f\u4ef6\u5de5\u7a0b\u8bfe\u7a0b\uff0c\u4e0d\u540c\u4e8e\u5f88\u591a\u4f20\u7edf\u7684\u8f6f\u4ef6\u5de5\u7a0b\u8bfe\u5f3a\u8c03\u5404\u79cd\u7c7b\u56fe\u3001\u6587\u6863\u8bbe\u8ba1 (plan and document \u6a21\u5f0f)\uff0c\u8fd9\u95e8\u8bfe\u4e13\u6ce8\u4e8e\u6700\u8fd1\u9010\u6e10\u6d41\u884c\u8d77\u6765\u7684\u654f\u6377\u5f00\u53d1 (Agile Development)\u6a21\u5f0f\uff0c\u5229\u7528\u4e91\u5e73\u53f0\u63d0\u4f9b\u8f6f\u4ef6\u5373\u670d\u52a1 (software as a service)\u3002\u4e3a\u6b64\uff0c\u8bfe\u7a0b\u8bbe\u8ba1\u8005\u7f16\u5199\u4e86 Software as a service \u8fd9\u672c\u6559\u6750\uff0c\u901a\u8fc7 Ruby/Rails \u6846\u67b6\u6765\u9610\u91ca SaaS \u8fd9\u4e2a\u6982\u5ff5\uff0c\u5e76\u4e14\u6709\u4e30\u5bcc\u7684\u914d\u5957\u7f16\u7a0b\u7ec3\u4e60\u3002
\u8fd9\u95e8\u8bfe\u5728 Edx \u8fd9\u4e2a\u7531 MIT \u548c Harvard \u5927\u5b66\u53d1\u8d77\u7684\u5728\u7ebf\u6559\u80b2\u5e73\u53f0\u5168\u8d44\u6599\u5f00\u6e90\uff0c\u5927\u5bb6\u53ef\u4ee5\u5728 Edx \u81ea\u884c\u641c\u7d22 Agile SaaS Development \u8fd9\u95e8\u8bfe\u7a0b\u8fdb\u884c\u5b66\u4e60\u3002\u8bfe\u7a0b\u5185\u5bb9\u57fa\u672c\u6309\u7167\u6559\u6750\u7684\u987a\u5e8f\u5e26\u4f60\u4e00\u6b65\u6b65\u4ee5\u654f\u6377\u5f00\u53d1\u7684\u65b9\u5f0f\u642d\u5efa\u4e00\u4e2a\u8f6f\u4ef6\u5e76\u514d\u8d39\u90e8\u7f72\u5728\u4e91\u5e73\u53f0\u4e0a\u3002
This is a self-learning guide to computer science, and a memento of my three years of self-learning at university.
It is also a gift to the young students at Peking University. It would be a great encouragement and comfort to me if this book could be of even the slightest help to you in your college life.
The book is currently organized to include the following sections (if you have other good suggestions, or would like to join the ranks of contributors, please feel free to email zhongyinmin@pku.edu.cn or ask questions in the issue).
User guide for this book: Given the numerous resources covered in this book, I have developed corresponding usage guides based on different people's free time and learning objectives.
A reference CS learning plan: This is a comprehensive and systematic CS self-learning plan that I have formulated based on my own self-study experience.
Productivity Toolkit: IDE, VPN, StackOverflow, Git, Github, Vim, Latex, GNU Make and so on.
Book recommendations: Those who have read the CSAPP must have realized the importance of good books. I will list links to books and resources in different areas of Computer Science that I find rewarding to read.
List of high quality CS courses: I will summarize all the high quality foreign CS courses I have taken and the community contributed into different categories and give relevant self-learning advice. Most of them will have a separate repository containing relevant resources as well as the homework/project implementations.
"},{"location":"en/#the-place-where-dreams-start-cs61a","title":"The place where dreams start \u2014\u2014 CS61A","text":"
In my freshman year, I was a novice who knew nothing about computers. I installed a giant IDE Visual Studio and fight with OJ every day. With my high school maths background, I did pretty well in maths courses, but I felt struggled to learn courses in my major. When it came to programming, all I could do was open up that clunky IDE, create a new project that I didn't know exactly what it was for, and then cin, cout, for loops, and then CE, RE, WA loops. I was in a state where I was desperately trying to learn well but I didn't know how to learn. I listened carefully in class but I couldn't solve the homework problems. I spent almost all my spare time doing the homework after class, but the results were disappointing. I still retain the source code of the project for Introduction to Computing course \u2014\u2014 a single 1200-line C++ file with no header files, no class abstraction, no unit tests, no makefile, no version control. The only good thing is that it can run, the disadvantage is the complement of \"can run\". For a while I wondered if I wasn't cut out for computer science, as all my childhood imaginings of geekiness had been completely ruined by my first semester's experience.
It all turned around during the winter break of my freshman year, when I had a hankering to learn Python. I overheard someone recommend CS61A, a freshman introductory course at UC Berkeley on Python. I'll never forget that day, when I opened the CS61A course website. It was like Columbus discovering a new continent, and I opened the door to a new world.
I finished the course in 3 weeks and for the first time I felt that CS could be so fulfilling and interesting, and I was shocked that there existed such a great course in the world.
To avoid any suspicion of pandering to foreign courses, I will tell you about my experience of studying CS61A from the perspective of a pure student.
Course website developed by course staffs: The course website integrates all the course resources into one, with a well organised course schedule, links to all slides, recorded videos and homework, detailed and clear syllabus, list of exams and solutions from previous years. Aesthetics aside, this website is so convenient for students.
Textbook written by course instructor: The course instructor has adapted the classic MIT textbook Structure and Interpretation of Computer Programs (SICP) into Python (the original textbook was based on Scheme). This is a great way to ensure that the classroom content is consistent with the textbook, while adding more details. The entire book is open source and can be read directly online.
Various, comprehensive and interesting homework: There are 14 labs to reinforce the knowledge gained in class, 10 homework assignments to practice, and 4 projects each with thousands of lines of code, all with well-organized skeleton code and babysitting instructions. Unlike the old-school OJ and Word document assignments, each lab/homework/project has a detailed handout document, fully automated grading scripts, and CS61A staffs have even developed an automated assignment submission and grading system. Of course, one might say \"How much can you learn from a project where most of code are written by your teaching assistants?\" . For someone who is new to CS and even stumbling over installing Python, this well-developed skeleton code allows students to focus on reinforcing the core knowledge they've learned in class, but also gives them a sense of achievement that they already can make a little game despite of learning Python only for a month. It also gives them the opportunity to read and learn from other people's high quality code so that they can reuse it later. I think in the freshman year, this kind of skeleton code is absolutely beneficial. The only bad thing perhaps is for the instructors and teaching assistants, as developing such assignments can conceivably require a considerable time commitment.
Weekly discussion sessions: The teaching assistants will explain the difficult knowledge in class and add some supplementary materials which may not be covered in class. Also, there will be exercises from exams of previous years. All the exercises are written in LaTeX with solutions.
In CS61A, You don't need any prerequesites about CS at all. You just need to pay attention, spend time and work hard. The feeling that you do not know what to do, that you are not getting anything in return for all the time you put in, is gone. It suited me so well that I fell in love with self-learning.
Imagine that if someone could chew up the hard knowledge and present it to you in a vivid and straightforward way, with so many fancy and varied projects to reinforce your theoretical knowledge, you'd think they were really trying their best to make you fully grasp the course, and it was even an insult to the course builders not to learn it well.
If you think I'm exaggerating, start with CS61A, because it's where my dreams began.
"},{"location":"en/#why-write-this-book","title":"Why write this book?","text":"
In the 2020 Fall semester, I worked as a teaching assistant for the class \"Introduction to Computer Systems\" at Peking University. At that time, I had been studying totally on my own for over a year. I enjoyed this style of learning immensely. To share this joy, I have made a CS Self-learning Materials List for students in my seminar. It was purely on a whim at the time, as I wouldn't dare to encourage my students to skip classes and study on their own.
But after another year of maintenance, the list has become quite comprehensive, covering most of the courses in Computer Science, Artificial Intelligence and Soft Engineering, and I have built separate repositories for each course, summarising the self-learning materials that I used.
In my last college year, when I opened up my curriculum book, I realized that it was already a subset of my self-learning list. By then, it was only two and a half years after I had started my self-learning journey. Then, a bold idea came to my mind: perhaps I could create a self-learning book, write down the difficulty I encountered and the interest I found during these years of self-learning, hoping to make it easy for students who may also enjoy self-learning to start their wonderful self-learning journey.
If you can build up the whole CS foundation in less than three years, have relatively solid mathematical skills and coding ability, experience dozens of projects with thousands of lines of code, master at least C/C++/Java/JS/Python/Go/Rust and other mainstream programming languages, have a good understanding of algorithms, circuits, architectures, networks, operating systems, compilers, artificial intelligence, machine learning, computer vision, natural language processing, reinforcement learning, cryptography, information theory, game theory, numerical analysis, statistics, distributed systems, parallel computing, database systems, computer graphics, web development, cloud computing, supercomputing etc. I think you will be confident enough to choose the area you are interested in, and you will be quite competitive in both industry and academia.
I firmly believe that if you have read to this line, you do not lack the ability and commitment to learn CS well, you just need a good teacher to teach you a good course. And I will try my best to pick such courses for you, based on my three years of experience.
"},{"location":"en/#pros","title":"Pros","text":"
For me, the biggest advantage of self-learning is that I can adjust the pace of learning entirely according to my own progress. For difficult parts, I can watch the videos over and over again, Google it online and ask questions on StackOverflow until I have it all figured out. For those that I mastered relatively quickly, I could skip them at twice or even three times the speed.
Another great thing about self-learning is that you can learn from different perspectives. I have taken core courses such as architectures, networking, operating systems, and compilers from different universities. Different instructors may have different views on the same knowledge, which will broaden your horizon.
A third advantage of self-learning is that you do not need to go to the class, listening to the boring lectures.
"},{"location":"en/#cons","title":"Cons","text":"
Of course, as a big fan of self-learning, I have to admit that it has its disadvantages.
The first is the difficulty of communication. I'm actually a very keen questioner, and I like to follow up all the points I don't understand. But when you're facing a screen and you hear a teacher talking about something you don't understand, you can't go to the other end of the network and ask him or her for clarification. I try to mitigate this by thinking independently and making good use of Google, but it would be great to have a few friends to study together. You can refer to README for more information on participating a community group.
The second thing is that these courses are basically in English. From the videos to the slides to the assignments, all in English. You may struggle at first, but I think it's a challenge that if you overcome, it will be extremely rewarding. Because at the moment, as reluctant as I am, I have to admit that in computer science, a lot of high quality documentation, forums and websites are all in English.
The third, and I think the most difficult one, is self-discipline. Because have no DDL can sometimes be a really scary thing, especially when you get deeper, many foreign courses are quite difficult. You have to be self-driven enough to force yourself to settle down, read dozens of pages of Project Handout, understand thousands of lines of skeleton code and endure hours of debugging time. With no credits, no grades, no teachers, no classmates, just one belief - that you are getting better.
"},{"location":"en/#who-is-this-book-for","title":"Who is this book for?","text":"
As I said in the beginning, anyone who is interested in learning computer science on their own can refer to this book. If you already have some basic skills and are just interested in a particular area, you can selectively pick and choose what you are interested in to study. Of course, if you are a novice who knows nothing about computers like I did back then, and just begin your college journey, I hope this book will be your cheat sheet to get the knowledge and skills you need in the least amount of time. In a way, this book is more like a course search engine ordered according to my experience, helping you to learn high quality CS courses from the world's top universities without leaving home.
Of course, as an undergraduate student who has not yet graduated, I feel that I am not in a position nor have the right to preach one way of learning. I just hope that this material will help those who are also self-motivated and persistent to gain a richer, more varied and satisfying college life.
I would like to express my sincere gratitude to all the professors who have made their courses public for free. These courses are the culmination of decades of their teaching careers, and they have chosen to selflessly make such a high quality CS education available to all. Without them, my university life would not have been as fulfilling and enjoyable. Many of the professors would even reply with hundreds of words in length after I had sent them a thank you email, which really touched me beyond words. They also inspired me all the time that if decide to do something, do it with all heart and soul.
"},{"location":"en/#want-to-join-as-a-contributor","title":"Want to join as a contributor?","text":"
There is a limit to how much one person can do, and this book was written by me under a heavy research schedule, so there are inevitably imperfections. In addition, as I work in the area of systems, many of the courses focus on systems, and there is relatively little content related to advanced mathematics, computing theory, and advanced algorithms. If any of you would like to share your self-learning experience and resources in other areas, you can directly initiate a Pull Request in the project, or feel free to contact me by email (zhongyinmin@pku.edu.cn).
"},{"location":"en/CS%E5%AD%A6%E4%B9%A0%E8%A7%84%E5%88%92/","title":"A Reference Guide for CS Learning","text":"
The field of computer science is vast and complex, with a seemingly endless sea of knowledge. Each specialized area can lead to limitless learning if pursued deeply. Therefore, a clear and definite study plan is very important. I've taken some detours in my years of self-study and finally distilled the following content for your reference.
Before you start learning, I highly recommend a popular science video series for beginners: Crash Course: Computer Science. In just 8 hours, it vividly and comprehensively covers various aspects of computer science: the history of computers, how computers operate, the important modules that make up a computer, key ideas in computer science, and so on. As its slogan says, Computers are not magic! I hope that after watching this video, everyone will have a holistic perception of computer science and embark on the detailed and in-depth learning content below with interest.
As the saying goes: sharpening your axe will not delay your job of chopping wood. If you are a pure beginner in the world of computers, learning some tools will make you more efficient.
Learn to ask questions: You might be surprised that asking questions is the first one listed? I think in the open-source community, learning to ask questions is a very important ability. It involves two aspects. First, it indirectly cultivates your ability to solve problems independently, as the cycle of forming a question, describing it, getting answers from others, and then understanding the response is quite long. If you expect others to remotely assist you with every trivial issue, then the world of computers might not suit you. Second, if after trying, you still can't solve a problem, you can seek help from the open-source community. But at that point, how to concisely explain your situation and goal to others becomes particularly important. I recommend reading the article How To Ask Questions The Smart Way, which not only increases the probability and efficiency of solving your problems but also keeps those who provide answers in the open-source community in a good mood.
Learn to be a hacker: MIT-Missing-Semester covers many useful tools for a hacker and provides detailed usage instructions. I strongly recommend beginners to study this course. However, one thing to note is that the course occasionally refers to terms related to the development process. Therefore, it is recommended to study it at least after completing an introductory computer science course.
GFW: For well-known reasons, sites like Google and GitHub are not accessible in mainland China. However, in many cases, Google and StackOverflow can solve 99% of the problems encountered during development. Therefore, learning to use a VPN is almost an essential skill for a mainland CSer. (Considering legal issues, the methods provided in this book are only applicable to users with a Peking University email address).
Command Line: Proficiency in using the command line is often overlooked or considered difficult to master, but in reality, it greatly enhances your flexibility and productivity as an engineer. The Art of Command Line is a classic tutorial that started as a question on Quora, but with the contribution of many experts, it has become a top GitHub project with over 100,000 stars, translated into dozens of languages. The tutorial is not long, and I highly recommend everyone to read it repeatedly and internalize it through practice. Also, mastering shell script programming should not be overlooked, and you can refer to this tutorial.
IDE (Integrated Development Environment): Simply put, it's where you write your code. The importance of an IDE for a programmer goes without saying, but many IDEs are designed for large-scale projects and are quite bulky and overly feature-rich. Nowadays, some lightweight text editors with rich plugin ecosystems can basically meet the needs of daily lightweight programming. My personal favorites are VS Code and Sublime (the former has a very simple plugin configuration, while the latter is a bit more complex but aesthetically pleasing). Of course, for large projects, I would still use slightly heavier IDEs, such as Pycharm (Python), IDEA (Java), etc. (Disclaimer: all IDEs are the best in the world).
Vim: A command-line editor. Vim has a somewhat steep learning curve, but mastering it, I think, is very necessary because it will greatly improve your development efficiency. Most modern IDEs also support Vim plugins, allowing you to retain the coolness of a geek while enjoying a modern development environment.
Emacs: A classic editor that stands alongside Vim, with equally high development efficiency and more powerful expandability. It can be configured as a lightweight editor or expanded into a custom IDE, and even more sophisticated tricks.
Git: A version control tool for your project. Git, created by the father of Linux, Linus, is definitely one of the must-have tools for every CS student.
GitHub: A code hosting platform based on Git. The world's largest open-source community and a gathering place for CS experts.
GNU Make: An engineering build tool. Proficiency in GNU Make will help you develop a habit of modularizing your code and familiarize you with the compilation and linking processes of large projects.
CMake: A more powerful build tool than GNU Make, recommended for study after mastering GNU Make.
LaTex: Pretentious Paper typesetting tool.
Docker: A lighter-weight software packaging and deployment tool compared to virtual machines.
Practical Toolkit: In addition to the tools mentioned above that are frequently used in development, I have also collected many practical and interesting free tools, such as download tools, design tools, learning websites, etc.
Thesis: Tutorial for writing graduation thesis in Word.
I believe a good textbook should be people-oriented, rather than a display of technical jargon. It's certainly important to tell readers \"what it is,\" but a better approach would be for the author to integrate decades of experience in the field into the book and narratively convey to the reader \"why it is\" and what should be done in the future.
If you are a Mac user, you're in luck, as this guide will walk you through setting up the entire development environment. If you are a Windows user, thanks to the efforts of the open-source community, you can enjoy a similar experience with Scoop.
Additionally, you can refer to an environment setup guide inspired by 6.NULL MIT-Missing-Semester, focusing on terminal beautification. It also includes common software sources (such as GitHub, Anaconda, PyPI) for acceleration and replacement, as well as some IDE configuration and activation tutorials.
Server-side operation and maintenance require basic use of Linux (or other Unix-like systems) and fundamental concepts like processes, devices, networks, etc. Beginners can refer to the Linux 101 online notes compiled by the Linux User Association of the University of Science and Technology of China. If you want to delve deeper into system operation and maintenance, you can refer to the Aspects of System Administration course.
Additionally, if you need to learn a specific concept or tool, I recommend a great GitHub project, DevOps-Guide, which covers a lot of foundational knowledge and tutorials in the administration field, such as Docker, Kubernetes, Linux, CI-CD, GitHub Actions, and more.
As mentioned at the beginning of this chapter, this course map is merely a reference guide for course planning, from my perspective as an undergraduate nearing graduation. I am acutely aware that I neither have the right nor the capability to preach to others about \u201chow one should learn\u201d. Therefore, if you find any issues with the course categorization and selection below, I fully accept and deeply apologize for them. You can tailor your own course map in the next section Customize Your Own Course Map.
Apart from courses labeled as basic or introductory, there is no explicit sequence in the following categories. As long as you meet the prerequisites for a course, you are free to choose any course according to your needs and interests.
"},{"location":"en/CS%E5%AD%A6%E4%B9%A0%E8%A7%84%E5%88%92/#mathematical-foundations","title":"Mathematical Foundations","text":""},{"location":"en/CS%E5%AD%A6%E4%B9%A0%E8%A7%84%E5%88%92/#calculus-and-linear-algebra","title":"Calculus and Linear Algebra","text":"
As a freshman, mastering calculus and linear algebra is as important as learning to code. This point has been reiterated countless times by predecessors, but I feel compelled to emphasize it again: mastering calculus and linear algebra is really important! You might complain that these subjects are forgotten after exams, but I believe that indicates a lack of deep understanding of their essence. If you find the content taught in class to be obscure, consider referring to MIT\u2019s Calculus Course and 18.06: Linear Algebra course notes. For me, they greatly deepened my understanding of the essence of calculus and linear algebra. Also, I highly recommend the maths YouTuber 3Blue1Brown, whose channel features videos explaining the core of mathematics with vivid animations, offering both depth and breadth of high quality.
"},{"location":"en/CS%E5%AD%A6%E4%B9%A0%E8%A7%84%E5%88%92/#introduction-to-information-theory","title":"Introduction to Information Theory","text":"
For computer science students, gaining some foundational knowledge in information theory early on is beneficial. However, most information theory courses are targeted towards senior or even graduate students, making them quite inaccessible to beginners. MIT\u2019s 6.050J: Information theory and Entropy is tailored for freshmen, with almost no prerequisites, covering coding, compression, communication, information entropy, and more, which is very interesting.
"},{"location":"en/CS%E5%AD%A6%E4%B9%A0%E8%A7%84%E5%88%92/#advanced-mathematics","title":"Advanced Mathematics","text":""},{"location":"en/CS%E5%AD%A6%E4%B9%A0%E8%A7%84%E5%88%92/#discrete-mathematics-and-probability-theory","title":"Discrete Mathematics and Probability Theory","text":"
Set theory, graph theory, and probability theory are essential tools for algorithm derivation and proof, as well as foundations for more advanced mathematical courses. However, the teaching of these subjects often falls into a rut of being overly theoretical and formalistic, turning classes into mere recitations of theorems and conclusions without helping students grasp the essence of these theories. If theory teaching can be interspersed with examples of algorithm application, students can expand their algorithm knowledge while appreciating the power and charm of theory.
UCB CS70: Discrete Math and Probability Theory and UCB CS126: Probability Theory are UC Berkeley\u2019s probability courses. The former covers the basics of discrete mathematics and probability theory, while the latter delves into stochastic processes and more advanced theoretical content. Both emphasize the integration of theory and practice and feature abundant examples of algorithm application, with the latter including numerous Python programming assignments to apply probability theory to real-world problems.
For computer science students, developing computational thinking is crucial. Modeling and discretizing real-world problems, and simulating and analyzing them on computers, are vital skills. Recently, the Julia programming language, developed by MIT, has become popular in the field of numerical computation with its C-like speed and Python-friendly syntax. Many MIT mathematics courses have started using Julia as a teaching tool, presenting complex mathematical theories through clear and intuitive code.
ComputationalThinking is an introductory course in computational thinking offered by MIT. All course materials are open source and accessible on the course website. Using the Julia programming language, the course covers image processing, social science and data science, and climatology modeling, helping students understand algorithms, mathematical modeling, data analysis, interactive design, and graph presentation. The course content, though not difficult, profoundly impressed me with the idea that the allure of science lies not in obscure theories or jargon but in presenting complex concepts through vivid examples and concise, deep language.
After completing this experience course, if you\u2019re still eager for more, consider MIT\u2019s 18.330: Introduction to Numerical Analysis. This course also uses Julia for programming assignments but is more challenging and in-depth. It covers floating-point encoding, root finding, linear systems, differential equations, and more, with the main goal of using discrete computer representations to estimate and approximate continuous mathematical concepts. The course instructor has also written an accompanying open-source textbook, Fundamentals of Numerical Computation, which includes abundant Julia code examples and rigorous formula derivations.
If you\u2019re still not satisfied, MIT\u2019s graduate course in numerical analysis, 18.335: Introduction to Numerical Methods, is also available for reference.
Wouldn't it be cool if the motion and development of everything in the world could be described and depicted with equations? Although differential equations are not a mandatory part of any CS curriculum, I believe mastering them provides a new perspective to view the world.
Since differential equations often involve complex variable functions, you can refer to MIT18.04: Complex Variables Functions course notes to fill in prerequisite knowledge.
MIT18.03: Differential Equations mainly covers the solution of ordinary differential equations, and on this basis, MIT18.152: Partial Differential Equations dives into the modeling and solving of partial differential equations. With the powerful tool of differential equations, you will gain enhanced capabilities in modeling real-world problems and intuitively grasping the essence among various noisy variables.
As a computer science student, I often hear arguments about the uselessness of mathematics. While I neither agree nor have the authority to oppose such views, if everything is forcibly categorized as useful or useless, it indeed becomes quite dull. Therefore, the following advanced mathematics courses, aimed at senior and even graduate students, are available for those interested.
Languages are tools, and you choose the right tool for the right job. Since there's no universally perfect tool, there's no universally perfect language.
"},{"location":"en/CS%E5%AD%A6%E4%B9%A0%E8%A7%84%E5%88%92/#electronics-fundamentals","title":"Electronics Fundamentals","text":""},{"location":"en/CS%E5%AD%A6%E4%B9%A0%E8%A7%84%E5%88%92/#basics-of-circuits","title":"Basics of Circuits","text":"
For computer science students, understanding basic circuit knowledge and experiencing the entire pipeline from sensor data collection to data analysis and algorithm prediction can be very helpful for future learning and developing computational thinking. EE16A&B: Designing Information Devices and Systems I&II at UC Berkeley are introductory courses for freshmen in electrical engineering. EE16A focuses on collecting and analyzing data from the real environment through circuits, while EE16B focuses on analyzing these collected data to make predictive actions.
"},{"location":"en/CS%E5%AD%A6%E4%B9%A0%E8%A7%84%E5%88%92/#signals-and-systems","title":"Signals and Systems","text":"
Signals and Systems is a course I find very worthwhile. Initially, I studied it out of curiosity about Fourier Transform, but after completing it, I was amazed at how Fourier Transform provided a new perspective to view the world, just like differential equations, immersing you in the elegance and magic of precisely depicting the world with mathematics.
MIT 6.003: Signal and Systems provides all course recordings, written assignments, and answers. You can also check out this course's ancient version.
UCB EE120: Signal and Systems has very well-written notes on Fourier Transform and provides many interesting Python programming assignments to practically apply the theories and algorithms of signals and systems.
"},{"location":"en/CS%E5%AD%A6%E4%B9%A0%E8%A7%84%E5%88%92/#data-structures-and-algorithms","title":"Data Structures and Algorithms","text":"
Algorithms are the core of computer science and the foundation for almost all professional courses. How to abstract real-world problems into algorithmic problems mathematically and solve them under time and memory constraints using appropriate data structures is the eternal theme of algorithm courses. If you are fed up with your teacher's rote teaching, I highly recommend UC Berkeley's UCB CS61B: Data Structures and Algorithms and Princeton's Coursera: Algorithms I & II. Both courses are taught in a deep yet simple manner and have rich and interesting programming experiments to integrate theory with knowledge.
Both of these courses are based on Java. If you prefer C/C++, you can refer to Stanford's data structure and basic algorithm course Stanford CS106B/X: Programming Abstractions. For those who prefer Python, you can learn MIT's introductory algorithm course MIT 6.006: Introduction to Algorithms.
For those interested in more advanced algorithms and NP problems, consider UC Berkeley's course on algorithm design and analysis UCB CS170: Efficient Algorithms and Intractable Problems or MIT's advanced algorithms course MIT 6.046: Design and Analysis of Algorithms.
There is a fundamental difference between \u201cworking\u201d code and high-quality industrial code. Therefore, I highly recommend senior students to take MIT 6.031: Software Construction. Based on Java, this course teaches how to write high-quality code that is bug-resistant, clear, and easy to maintain and modify with rich and detailed reading materials and well-designed programming exercises. From macro data structure design to minor details like how to write comments, following these details and experiences summarized by predecessors can greatly benefit your future programming career.
Of course, if you want to systematically take a software engineering course, I recommend UC Berkeley\u2019s UCB CS169: Software Engineering. However, unlike most software engineering courses, this course does not involve the traditional design and document model that emphasizes various class diagrams, flowcharts, and document design. Instead, it adopts the Agile Development model, which has become popular in recent years, featuring small team rapid iterations and the Software as a Service model using cloud platforms.
Since childhood, I've always heard that the world of computers is made of 0s and 1s, which I didn't understand but was deeply impressed by. If you also have this curiosity, consider spending one to two months learning the barrier-free computer course Coursera: Nand2Tetris. This comprehensive course starts from 0s and 1s, allowing you to build a computer by hand and run a Tetris game on it. It covers compilation, virtual machines, assembly, architecture, digital circuits, logic gates, etc., from top to bottom, from software to hardware. Its difficulty is carefully designed to omit many complex details of modern computers, extracting the most core essence, aiming to make it understandable to everyone. In lower levels, establishing a bird's-eye view of the entire computer system is very beneficial.
Of course, if you want to delve into the complex details of modern computer architecture, you still need to take a university-level course UCB CS61C: Great Ideas in Computer Architecture. This course emphasizes practice, and you will hand-write assembly to construct neural networks in projects, build a CPU from scratch, and more, all of which will give you a deeper understanding of computer architecture, beyond the monotony of \"fetch, decode, execute, memory access, write back.\"
"},{"location":"en/CS%E5%AD%A6%E4%B9%A0%E8%A7%84%E5%88%92/#introduction-to-computer-systems","title":"Introduction to Computer Systems","text":"
Computer systems are a vast and profound topic. Before delving into a specific area, having a macro conceptual understanding of each field and some general design principles will reinforce core and even philosophical concepts in your subsequent in-depth study, rather than being shackled by complex internal details and various tricks. In my opinion, the key to learning systems is to grasp these core concepts to design and implement your own systems.
MIT6.033: System Engineering is MIT's introductory course to systems, covering topics like operating systems, networks, distributed systems, and system security. In addition to the theory, this course also teaches some writing and expression skills, helping you learn how to design, introduce, and analyze your own systems. The accompanying textbook Principles of Computer System Design: An Introduction is also very well written and recommended for reading.
CMU 15-213: Introduction to Computer System is CMU\u2019s introductory systems course, covering architecture, operating systems, linking, parallelism, networks, etc., with both breadth and depth. The accompanying textbook Computer Systems: A Programmer's Perspective is also of very high quality and strongly recommended for reading.
There\u2019s nothing like writing your own kernel to deepen your understanding of operating systems.
Operating systems provide a set of elegant abstractions to virtualize various complex underlying hardware, providing rich functional support for all application software. Understanding the design principles and internal mechanisms of operating systems is greatly beneficial for a programmer who is not satisfied with just being a coder. Out of love for operating systems, I have taken many operating system courses in different colleges, each with its own focus and merits. You can choose based on your interests.
MIT 6.S081: Operating System Engineering, offered by the famous PDOS lab at MIT, features 11 projects that modify an elegantly implemented Unix-like operating system xv6. This course made me realize that systems is not about reading PPTs; it's about writing tens of thousands of lines of code.
UCB CS162: Operating System, UC Berkeley\u2019s operating system course, uses the same Project as Stanford \u2014 an educational operating system, Pintos. As the teaching assistant for Peking University\u2019s 2022 and 2023 Spring Semester Operating Systems Course, I introduced and improved this Project. The course resources are fully open-sourced, with details on the course website.
NJU: Operating System Design and Implementation, offered by Professor Yanyan Jiang at Nanjing University, provides an in-depth and accessible explanation of various operating system concepts, combining a unique system perspective with rich code examples. All course content is in Chinese, making it very convenient for students.
HIT OS: Operating System, taught by Professor Zhijun Li at Harbin Institute of Technology, is a Chinese course on operating systems. Based on the Linux 0.11 source code, the course places great emphasis on code practice, explaining the intricacies of operating systems from the student's perspective.
"},{"location":"en/CS%E5%AD%A6%E4%B9%A0%E8%A7%84%E5%88%92/#parallel-and-distributed-systems","title":"Parallel and Distributed Systems","text":"
In recent years, the most common phrase heard in CS lectures is \"Moore's Law is coming to an end.\" As single-core capabilities reach their limits, multi-core and many-core architectures are becoming increasingly important. The changes in hardware necessitate adaptations and changes in the upper-level programming logic. Writing parallel programs has nearly become a mandatory skill for programmers to fully utilize hardware performance. Meanwhile, the rise of deep learning has brought unprecedented demands on computing power and storage, making the deployment and optimization of large-scale clusters a hot topic.
Whether you chose computer science because of a youthful dream of becoming a hacker, the reality is that becoming a hacker is a long and difficult journey.
UCB CS161: Computer Security at UC Berkeley covers stack attacks, cryptography, website security, network security, and more.
ASU CSE365: Introduction to Cybersecurity at Arizona State University focuses mainly on injections, assembly, and cryptography.
ASU CSE466: Computer Systems Security at Arizona State University covers a wide range of topics in system security. It has a high barrier to entry, requiring familiarity with Linux, C, and Python.
SU SEED Labs at Syracuse University, supported by a $1.3 million grant from the NSF, has developed hands-on experimental exercises (called SEED Labs) for cybersecurity education. The course emphasizes both theoretical teaching and practical exercises, including detailed open-source lectures, video tutorials, textbooks (printed in multiple languages), and a ready-to-use virtual machine and Docker-based attack-defense environment. This project is currently used by 1,050 institutions worldwide and covers a wide range of topics in computer and information security, including software security, network security, web security, operating system security, and mobile app security.
After mastering this theoretical knowledge, it's essential to cultivate and hone these \"hacker skills\" in practice. CTF competitions are a popular way to comprehensively test your understanding and application of computer knowledge in various fields. Peking University also successfully held the 0th and 1st editions, encouraging participation to improve skills through practice. Here are some resources I use for learning (and relaxing):
There\u2019s nothing like writing your own TCP/IP protocol stack to deepen your understanding of computer networks.
The renowned Stanford CS144: Computer Network includes 8 projects that guide you in implementing the entire TCP/IP protocol stack.
If you're just looking to understand computer networks theoretically, I recommend the famous networking textbook \"A Top-Down Approach\" and its accompanying learning resources Computer Networking: A Top-Down Approach.
There\u2019s nothing like building your own relational database to deepen your understanding of database systems.
CMU's famous database course CMU 15-445: Introduction to Database System guides you through 4 projects to add various functionalities to the educational relational database bustub. The experimental evaluation framework is also open-source, making it very suitable for self-learning. The course experiments also use many new features of C++11, offering a great opportunity to strengthen C++ coding skills.
Berkeley, as the birthplace of the famous open-source database PostgreSQL, has its own course UCB CS186: Introduction to Database System where you will implement a relational database in Java that supports SQL concurrent queries, B+ tree indexing, and fault recovery.
Front-end development is often overlooked in computer science curricula, but mastering these skills has many benefits, such as building your personal website or creating an impressive presentation website for your course projects.
Data science, machine learning, and deep learning are closely related, with a focus on practical application. Berkeley's UCB Data100: Principles and Techniques of Data Science lets you master various data analysis tools and algorithms through extensive programming exercises. The course guides you through extracting desired results from massive datasets and making predictions about future data or user behavior. For those looking to learn industrial-level data mining and analysis techniques, Stanford's big data mining course CS246: Mining Massive Data Sets is an option.
Artificial intelligence has been one of the hottest fields in computer science over the past decade. If you're not content with just hearing about AI advancements in the media and want to delve into the subject, I highly recommend Harvard's renowned CS50 series AI course Harvard CS50: Introduction to AI with Python. The course is concise and covers several major branches of traditional AI, supplemented with rich and interesting Python programming exercises to reinforce your understanding of AI algorithms. However, the content is somewhat simplified for online learners and doesn't delve into deep mathematical theories. For a more systematic and in-depth study, consider an undergraduate-level course like Berkeley's UCB CS188: Introduction to Artificial Intelligence. This course's projects feature the classic game \"Pac-Man,\" allowing you to use AI algorithms to play the game, which is very fun.
The most significant recent progress in the field of machine learning is the emergence of deep learning, a branch based on deep neural networks. However, many algorithms based on statistical learning are still widely used in data analysis. If you're new to machine learning and don't want to get bogged down in complex mathematical proofs, start with Andrew Ng's (Enda Wu) Coursera: Machine Learning. This course is well-known in the field of machine learning, and Enda Wu, with his profound theoretical knowledge and excellent presentation skills, makes many complex algorithms accessible and practical. The accompanying assignments are also of high quality, helping you get started quickly.
However, completing this course will only give you a general understanding of the field of machine learning. To truly understand the mathematical principles behind these \"magical\" algorithms or to engage in related research, you need a more \"mathematical\" course, such as Stanford CS229: Machine Learning or UCB CS189: Introduction to Machine Learning.
The popularity of AlphaGo a few years ago brought deep learning to the public eye, leading many universities to establish related majors. Many other areas of computer science also use deep learning technology for research, so regardless of your field, you will likely encounter some needs related to neural networks and deep learning. For a quick introduction, I again recommend Andrew Ng's (Enda Wu) Coursera: Deep Learning, a top-rated course on Coursera. Additionally, if you find English-language courses challenging, consider Professor Hongyi Li's course National Taiwan University: Machine Learning. Although titled \"Machine Learning,\" this course covers almost all areas of deep learning and is very comprehensive, making it suitable for getting a broad overview of the field. The professor is also very humorous, with frequent witty remarks in class.
Due to the rapid development of deep learning, there are now many research branches. For further in-depth study, consider the following representative courses:
"},{"location":"en/CS%E5%AD%A6%E4%B9%A0%E8%A7%84%E5%88%92/#customize-your-course-map","title":"Customize Your Course Map","text":"
Better to teach fishing than to give fish.
The course map above inevitably carries strong personal preferences and may not suit everyone. It is more intended to serve as a starting point for exploration. If you want to select your own areas of interest for study, you can refer to the following resources:
MIT OpenCourseWare: MIT's open-sharing project for course resources, featuring thousands of courses from various disciplines, including computer science courses numbered 6.xxx.
MIT CS Course List: List of CS courses at MIT.
UC Berkeley EECS Course Map: UC Berkeley's EECS curriculum plan, presenting the categories and prerequisites of various courses in a course map format, most of which are included in this book.
UC Berkeley CS Course List: List of CS courses at UC Berkeley.
Stanford CS Course List: List of CS courses at Stanford.
"},{"location":"en/%E4%BD%BF%E7%94%A8%E6%8C%87%E5%8D%97/","title":"How to Use This Book","text":"
As the number of contributors grows, the content of this book keeps expanding. It is impractical and unnecessary to try to complete all the courses in the book. Attempting to do so might even be counterproductive, resulting in effort without reward. To better align with our readers and make this book truly useful for you, I have roughly divided readers into the following three categories based on their needs. Everyone can plan their own self-study program accurately according to their actual situation.
If you have just entered the university or are in the lower grades, and you are studying or planning to switch to computer science, then you are lucky. As studying is your main task, you have ample time and freedom to learn what you are interested in without the pressure of work and daily life. You needn't be overly concerned with utilitarian thoughts like \"is it useful\" or \"can it help me find a job\". So, how should you arrange your studies? The first point is to break away from the passive learning style formed in high school. As a small-town problem solver, I know that most Chinese high schools fill every minute of your day with tasks, and you just need to passively follow the schedule. As long as you are diligent, the results won\u2019t be too bad. However, once you enter university, you have much more freedom. All your extracurricular time is yours to use, and no one will organize knowledge points or summarize outlines for you. Exams are not as formulaic as in high school. If you still hold the mentality of a \"good high school student\", following everything step by step, the results may not be as expected. The professional training plan may not be reasonable, the teaching may not be responsible, attending classes may not guarantee understanding, and even the exam content may not relate to what was taught. Jokingly, you might feel that the whole world is against you, and you can only rely on yourself.
Given this reality, if you want to change it, you must first survive and have the ability to question it. In the lower grades, it\u2019s important to lay a solid foundation. This foundation is comprehensive, covering both in-class knowledge and practical skills, which are often lacking in China's undergraduate computer science education. Based on personal experience, I offer the following suggestions for your reference.
First, learn how to write \"elegant\" code. Many programming introductory courses in China can be extremely boring syntax classes, less effective than reading official documentation. Initially, letting students understand what makes code elegant and what constitutes \"bad taste\" is beneficial. Introductory courses usually start with procedural programming (like C language), but even here, the concepts of modularity and encapsulation are crucial. If you write code just to pass on OpenJudge, using lengthy copy-pasting and bloated main functions, your code quality will remain poor. For larger projects, endless debugging and maintenance costs will overwhelm you. So, constantly ask yourself, is there a lot of repetitive code? Is the current function too complex (Linux advocates each function should do only one thing)? Can this code be abstracted into a function? Initially, this may seem cumbersome for simple problems, but remember, good habits are invaluable. Even middle school students can master C language, so why should a company hire you as a software engineer?
After procedural programming, the second semester of the freshman year usually introduces object-oriented programming (like C++ or Java). I highly recommend MIT 6.031: Software Construction course notes, which use Java (switch to TypeScript after 2022) to explain how to write \u201celegant\u201d code in detail, including Test-Driven development, function Specification design, exception handling, and more. Also, understanding common design patterns is necessary when learning object-oriented programming. Domestic object-oriented courses can easily become dull syntax classes, focusing on inheritance syntax and puzzling questions, neglecting that these are rarely used in real-world development. The essence of object-oriented programming is teaching students to abstract real problems into classes and their relationships, and design patterns are the essence of these abstractions. I recommend the book \"Big Talk Design Patterns\", which is very easy to understand.
Second, try to learn some productivity-enhancing tools and skills, such as Git, Shell, Vim. I strongly recommend the MIT missing semester course. Initially, you may feel awkward, but force yourself to use them, and your development efficiency will skyrocket. Additionally, many applications can greatly increase your productivity. A rule of thumb is: any action that requires your hands to leave the keyboard should be eliminated. For example, switching applications, opening files, browsing the web - there are plugins for these (like Alfred for Mac). If you find an daily operation that takes more than 1 second, try to reduce it to 0.1 seconds. After all, you'll be dealing with computers for decades, so forming a smooth workflow can greatly enhance efficiency. Lastly, learn to touch type! If you still need to look at the keyboard while typing, find a tutorial online and learn to type without looking. This will significantly increase your development efficiency.
Third, balance coursework and self-learning. We feel angry about the institution but must also follow the rules, as GPA is still important for postgraduate recommendations. Therefore, in the first year, I suggest focusing on the curriculum, complemented by high-quality extracurricular resources. For example, for calculus and linear algebra, refer to MIT 18.01/18.02 and MIT 18.06. During holidays, learn Python through UCB CS61A. Also, focus on good programming habits and practical skills mentioned above. From my experience, mathematics courses matter a lot for your GPA in the first year, and the content of math exams varies greatly between different schools and teachers. Self-learning might help you understand the essence of mathematics, but it may not guarantee good grades. Therefore, it\u2019s better to specifically practice past exams.
In your sophomore year, as computer science courses become the majority, you can fully immerse yourself in self-learning. Refer to A Reference Guide for CS Learning, a guide I created based on three years of self-learning, introducing each course and its importance. For every course in your curriculum, this guide should have a corresponding one, and I believe they are of higher quality. If there are course projects, try to adapt labs or projects from these self-learning courses. For example, I took an operating systems course and found the teacher was still using experiments long abandoned by UC Berkeley, so I emailed the teacher to switch to the MIT 6.S081 xv6 Project I was studying. This allowed me to self-learn while inadvertently promoting curriculum reform. In short, be flexible. Your goal is to master knowledge in the most convenient and efficient way. Anything that contradicts this goal can be \u201cfudged\u201d as necessary. With this attitude, after my junior year, I barely attended offline classes (I spent most of my sophomore year at home due to the pandemic), and it had no impact on my GPA.
Finally, I hope everyone can be less impetuous and more patient in their pursuit. Many ask if self-learning requires strong self-discipline. It depends on what you want. If you still hold the illusion that mastering a programming language will earn you a high salary and a share of the internet\u2019s profits, then whatever I say is pointless. Initially, my motivation was out of pure curiosity and a natural desire for knowledge, not for utilitarian reasons. The process didn't involve \u201cextraordinary efforts\u201d; I spent my days in college as usual and gradually accumulated this wealth of materials. Now, as the US-China confrontation becomes a trend, we still humbly learn techniques from the West. Who will change this? You, the newcomers. So, go for it, young man!
"},{"location":"en/%E4%BD%BF%E7%94%A8%E6%8C%87%E5%8D%97/#simplify-the-complex","title":"Simplify the Complex","text":"
If you have graduated and started postgraduate studies, or have begun working, or are in another field and want to learn coding in your spare time, you may not have enough time to systematically complete the materials in A Reference Guide for CS Learning, but still want to fill the gaps in your undergraduate foundation. Considering that these readers usually has some programming experience, there is no need to repeat introductory courses. From a practical standpoint, since the general direction of work is already determined, there is no need to deeply study every branch of computer science. Instead, focus on general principles and skills. Based on my own experience, I've selected the most important and highest quality core professional courses to deepen readers' understanding of computer science. After completing these courses, regardless of your specific job, I believe you won't just be an ordinary coder, but will have a deeper understanding of the underlying logic of computers.
Course Direction Course Name Discrete Mathematics and Probability Theory UCB CS70: Discrete Math and Probability Theory Data Structures and Algorithms Coursera: Algorithms I & II Software Engineering MIT 6.031: Software Construction Full-Stack Development MIT Web Development Course Introduction to Computer Systems CMU CS15213: CSAPP Introductory System Architecture Coursera: Nand2Tetris Advanced System Architecture CS61C: Great Ideas in Computer Architecture Principles of Databases CMU 15-445: Introduction to Database Systems Computer Networking Computer Networking: A Top-Down Approach Artificial Intelligence Harvard CS50: Introduction to AI with Python Deep Learning Coursera: Deep Learning"},{"location":"en/%E4%BD%BF%E7%94%A8%E6%8C%87%E5%8D%97/#focused-and-specialized","title":"Focused and Specialized","text":"
If you have a solid grasp of the core professional courses in computer science and have already determined your work or research direction, then there are many courses in the book not mentioned in A Reference Guide for CS Learning for you to explore.
As the number of contributors increases, new branches such as Advanced Machine Learning and Machine Learning Systems will be added to the navigation bar. Under each branch, there are several similar courses from different schools with different emphases and experiments, such as the Operating Systems branch, which includes courses from MIT, UC Berkeley, Nanjing University, and Harbin Institute of Technology. If you want to delve into a field, studying these similar courses will give you different perspectives on similar knowledge. Additionally, I plan to contact researchers in related fields to share research learning paths in specific subfields, enhancing the depth of the CS Self-learning Guide while pursuing breadth.
If you want to contribute in this area, feel free to contact the author via email zhongyinmin@pku.edu.cn.
This is Stanford's Web Application course covers HTML, CSS, JavaScript, ReactJs, NodeJS, ExpressJS, Web Security, and more. Eight projects will enhance your web development skills in practice.
This course provides a comprehensive but concise introduction to the best practices of React front-end development and React Native mobile development. It focuses on the latest versions of React and React Native and is updated every semester. It is a valuable resource for tackling the complexities of front-end development.
The course also offers a good training ground. Be prepared for a significant workload throughout the semester. The techniques and knowledge points involved in the homework will be explained in class, but code won't be written hand by hand (I personally think that hand-holding code writing is very inefficient, and most courses on Udemy are of this type). As this isn't a hand-holding course, if you are unsure about how to write React code when doing homework, I recommend spending extra time carefully reading the relevant chapters on react.dev before diving in. The starter code also provides you with a great starting point, saving you from coping with Node.js environment settings.
Although this course doesn't require prior knowledge of Javascript/HTML/CSS, the classroom introduction to syntax is relatively limited. It's recommended to frequently consult resources and ask questions when encountering syntax issues during learning and coding.
This course also includes an introduction to and practices for Dialog Flow, a ChatBot development tool by Google. You can also find content related to UX development (on the practical side) in this course.
All course materials and assignments are open-source, but you will need to request an X-CS571-ID header from the instructor, Cole Nelson (ctnelson2@wisc.edu). The header will be necessary for API request. When sending an email, it is advisable to include a brief self-introduction. It is unclear whether the instructor is willing to give everyone an ID. If you got turned down, please raise an issue for this GitHub repo.
This course serves as an introduction to modern web application development with JavaScript. The main focus is on building single page applications with ReactJS that use REST APIs built with Node.js. The course also contains a section on GraphQL, a modern alternative to REST APIs.
The course covers testing, configuration and environment management, and the use of MongoDB for storing the application\u2019s data.
Prerequisites: better if you are already proficient in a programming language
Programming Languages: JavaScript/HTML/CSS/NoSQL
Difficulty: \ud83c\udf1f\ud83c\udf1f\ud83c\udf1f
Class Hour: Varying according to the learner
Independent Activities Period (IAP) is a four-week period in January during which faculty and students are freed from the rigors of regularly scheduled classes for flexible teaching and learning and for independent study and research, and that's how this web development course was born.
Within a month, you will master the core content of designing, building, beautifying, and publishing a website from scratch, basically covering full-stack web development. If you don't need to learn web development systematically, but just want to add it to your toolkit out of interest, then this class will be perfect for you.
This introductory artificial intelligence course at UC Berkeley provides in-depth and accessible course notes, making it possible to grasp the material without necessarily watching the lecture videos. The course follows the chapters of the classic AI textbook Artificial Intelligence: A Modern Approach, covering topics such as search pruning, constraint satisfaction problems, Markov decision processes, reinforcement learning, Bayesian networks, Hidden Markov Models, as well as fundamental concepts in machine learning and neural networks.
The Fall 2018 version of the course offered free access to gradescope, allowing students to complete written assignments online and receive real-time assessment results. The course also includes 6 projects of high quality, featuring the recreation of the classic Pac-Man game. These projects challenge students to apply their AI knowledge to implement various algorithms, enabling their Pac-Man to navigate mazes, evade ghosts, and collect pellets.
Course Videos\uff1aFall 2022, Fall 2018, with links to each lecture on the course website
Course Textbook\uff1aArtificial intelligence: A Modern Approach
Course Assignments\uff1aOnline assessments for written assignments and projects, details available on the course website
"},{"location":"en/%E4%BA%BA%E5%B7%A5%E6%99%BA%E8%83%BD/CS50/","title":"Harvard's CS50: Introduction to AI with Python","text":""},{"location":"en/%E4%BA%BA%E5%B7%A5%E6%99%BA%E8%83%BD/CS50/#descriptions","title":"Descriptions","text":"
Offered by: Harvard University
Prerequisites: Basic knowledge of probability theory and Python
Programming Languages: Python
Difficulty: \ud83c\udf1f\ud83c\udf1f\ud83c\udf1f
Class Hour: 30
A very basic introductory AI course, what makes it stand out is the 12 well-designed programming assignments, all of which will use the learned knowledge to implement a simple game AI, such as using reinforcement learning to play Nim game, using max-min search with alpha-beta pruning to sweep mines, and so on. It's perfect for newbies to get started or bigwigs to relax.
This course, taught by Professor Onur Mutlu, delves into computer architecture. It appears to be an advanced course following DDCA, aimed at teaching how to design control and data paths hardware for a MIPS-like processor, how to execute machine instructions concurrently through pipelining and simple superscalar execution, and how to design fast memory and storage systems. According to student feedback, the course is at least more challenging than CS61C, and some of its content is cutting-edge. Bilibili uploaders recommend it as a supplement to Carnegie Mellon University's 18-447 course. The reading materials provided are extensive, akin to attending a semester's worth of lectures.
The official website description is as follows:
\"We will learn the fundamental concepts of the different parts of modern computing systems, as well as the latest major research topics in Industry and Academia. We will extensively cover memory systems (including DRAM and new Non-Volatile Memory technologies, memory controllers, flash memory), new paradigms like processing-in-memory, parallel computing systems (including multicore processors, coherence and consistency, GPUs), heterogeneous computing, interconnection networks, specialized systems for major data-intensive workloads (e.g., graph analytics, bioinformatics, machine learning), etc. We will focus on fundamentals as well as cutting-edge research. Significant attention will be given to real-life examples and tradeoffs, as well as critical analysis of modern computing systems.\"
The programming practice involves using Verilog to design and simulate RT implementations of a MIPS-like pipeline processor to enhance theoretical course understanding. The initial experiments include Verilog CPU pipeline programming. Additionally, students will develop a cycle-accurate processor simulator in C and explore processor design options using this simulator.
This is the last course in Berkeley's CS61 series, which dives into the internal of computer architecture and will make you understand how the C language is translated into RISC-V assembly language and executed on the CPU. Unlike Nand2Tetris, this course is much more difficult and more in-depth, covering pipelining, cache, virtual memory, and concurrency-related content.
The projects are very innovative and interesting. Project1 is a warmup assignment in C. In 2020Fall, you will implement the famous Game of Life. Project2 requires you to write a fully-connected neural network in RISC-V assembly to classify handwritten digits in MNIST dataset, which is a great exercise to write assembly code. In Project3, you will use Logisim, a digital circuit simulation software, to build a two-stage pipeline CPU from scratch and run RISC-V assembly code on it. In Project4 you will implement a toy version of Numpy, using OpenMP, SIMD, and other techniques to speed up matrix operations.
In a word, this is the best computer architecture course I have ever taken.
All the resources and assignments used by @PKUFlyingPig in this course are maintained in PKUFlyingPig/CS61C-summer20 - GitHub.
"},{"location":"en/%E4%BD%93%E7%B3%BB%E7%BB%93%E6%9E%84/DDCA/","title":"Digital Design and Computer Architecture","text":""},{"location":"en/%E4%BD%93%E7%B3%BB%E7%BB%93%E6%9E%84/DDCA/#descriptions","title":"Descriptions","text":"
Offered by: ETH Zurich
Prerequisites: CS50 or same level course; Better have a basic knowledge of C
Programming Languages: C, Verilog, MIPS, LC3
Difficulty: \ud83c\udf1f\ud83c\udf1f\ud83c\udf1f
Class Hour: 100 hours
In this course, Onur Mutlu, a great expert in the field of Computer Architecture, will teach you about digital circuits and computer architecture. The course is entirely from the perspective of a computer designer, starting with transistors and logic gates and extending to microarchitecture, caches, and virtual memory. It also covers many of the latest research advances in the field of computer architecture. After learning, you will master digital circuits, hardware description language Verilog, MIPS instruction set, CPU design and performance analysis, pipelining, cache, virtual memory, and so on.
There are 9 labs in the course. You will use the Basys 3 FPGA board and Vivado to design and synthesize the circuits, starting from combinational and sequential circuits, and eventually assembly into a complete CPU. Except for assignment solutions, all the course materials are open source.
As one of the most popular courses on Coursera, tens of thousands of people give it a full score, and over four hundred colleges and high schools teach it. It guides the students who may have no preparatory knowledge in computer science to build a whole computer from Nand logic gates and finally run the Tetris game on it.
Sounds cool, right? It's even cooler when you implement it!
The course is divided into hardware modules and software modules respectively.
In the hardware modules, you will dive into a world based on 0 and 1, create various logic gates from Nand gates, and construct a CPU step by step to run a simplified instruction set designed by the course instructors.
In the software modules, you will first write a compiler to compile a high-level language Jack which is designed by the instructors into byte codes that can run on virtual machines. Then you will further translate the byte codes into assembly language that can run on the CPU you create in the hardware modules. You will also develop a simple operating system that enables your computer to support GUI.
Finally, you can use Jack to create the Tetris game, compile it into assembly language, run it on your self-made CPU, and interact with it through the OS built by yourself. After taking this course, you will have a comprehensive and profound understanding of the entire computer architecture, which might be extremely helpful to your subsequent learning.
You may think that the course is too difficult. Don't worry, because it is completely designed for laymen. In the instructors' expectations, even high school students can understand the content. So as long as you keep pace with the syllabus, you can finish it within a month.
This course extracts the essence of computers while omitting the tedious and complex details in modern computer systems that are designed for efficiency and performance. Surely you will enjoy the elegance and magic of computers in a relaxing and jolly journey.
The professor Kayvon Fatahalian used to teach course 15-418 at CMU. After he became an assistant professor at Stanford, he offered a similar course, CS149 at Stanford. In general, the 15-418 version is more comprehensive and has lecture recordings, but CS149's programming assignments are more fashionable. Personally, I watched the recordings of 15-418 but completed the assignments of CS149.
The goal of this course is to provide a deep understanding of the fundamental principles and engineering trade-offs involved in designing modern parallel computing systems, as well as to teach how to utilize hardwares and software programming frameworks (such as CUDA, MPI, OpenMP, etc.) for writing high-performance parallel programs. Due to the complexity of parallel computing architecture, this course involves a lot of advanced computer architecture and network communication content, the knowledge is quite low-level and hardcore. Meanwhile, the five assignments develop your understanding and application of upper-level abstraction through software, specifically by analyzing bottlenecks in parallel programs, writing multi-threaded synchronization code, learning CUDA programming, OpenMP programming, and the popular Spark framework, etc. It really combines theory and practice perfectly.
This course, the same as MIT 6.S081, comes from the renowned MIT PDOS Lab. The instructor, Professor Robert Morris, was once a famous hacker who created 'Morris', the first worm virus in the world.
Each lecture will discuss a classic paper in the field of distributed systems, teaching you the important principles and key techniques of distributed systems design and implementation. The Project is known for its difficulty. In four programming assignments, you will implement a KV-store framework step by step based on the Raft consensus algorithm, allowing you to experience the randomness and complexity to implement and debug a distributed system.
This course is so famous that you can easily have access to the project solutions on the Internet. It is highly recommended to implement the projects on your own.
All the resources and assignments used by @PKUFlyingPig in this course are maintained in PKUFlyingPig/MIT6.824 - GitHub.
@OneSizeFitsQuorum has written a Lab Documentation that quite clearly describes many of the details to be considered when implementing lab 1-4 and challenge 1-2, you can read when you encounter bottlenecks ~ ~
Similar to GNU make, CMake is a cross-platform tool designed to build, test and package software. It uses CMakeLists.txt to define build configuration, and have more functionalities compared to GNU make. It is highly recommended to learn GNU Make and get familiar with Makefile first before learning CMake.
"},{"location":"en/%E5%BF%85%E5%AD%A6%E5%B7%A5%E5%85%B7/CMake/#how-to-learn-cmake","title":"How to learn CMake","text":"
Compare to Makefile, CMakeLists.txt is more obscure and difficult to understand and use. Nowadays many IDEs (e.g., Visual Studio, CLion) offer functionalities to generate CMakeLists.txt automatically, but it's still necessary to manage basic usage of CMakeLists.txt. Besides Official CMake Tutorial, this one-hour video tutorial (in Chinese) presented by IPADS group at SJTU is also a good learning resource.
The main obstacle when using software/tools developed by others is often the hassle of setting up the environment. This configuration headache can significantly dampen your enthusiasm for software and programming. While virtual machines can solve some of these issues, they are cumbersome and might not be worth simulating an entire operating system for a single application's configuration.
Docker has changed the game by making environment configuration (potentially) less painful. In essence, Docker uses lightweight \"containers\" instead of an entire operating system to support an application's configuration. Applications, along with their environment configurations, are packaged into images that can freely run on different platforms in containers, saving considerable time and effort for everyone.
"},{"location":"en/%E5%BF%85%E5%AD%A6%E5%B7%A5%E5%85%B7/Docker/#how-to-learn-docker","title":"How to learn Docker","text":"
The official Docker documentation is the best starting point, but the best teacher is often yourself\u2014try using Docker to experience its convenience. Docker has rapidly developed in the industry and is already quite mature. You can download its desktop version and use the graphical interface.
If you're like me, reinventing the wheel, consider building a Mini Docker yourself to deepen your understanding.
KodeKloud Docker for the Absolute Beginner offers a comprehensive introduction to Docker's basic functionalities with numerous hands-on exercises. It also provides a free cloud environment for practice. While other cloud-related courses, such as Kubernetes, may require payment, I highly recommend them. The explanations are detailed, suitable for beginners, and come with a corresponding Kubernetes lab environment, eliminating the need for complex setups.
Emacs is a powerful editor as famous as Vim. Emacs has almost all the benefits of Vim, such as:
Everything can be done with keyboard only, as there are a large number of shortcuts to improve the efficiency of code editing.
Supporting both graphical and non-graphical interface in various scenarios.
Besides, the biggest difference between Emacs and most other editors lies in its powerful extensibility. Emacs kernel imposes no restrictions on users behaviors. With Emacs Lisp programming language, users is able to write any plugins to extend the functionality. After decades of development, Emacs' plugin ecosystem is arguably one of the richest and most powerful in the editor world. There is a joke saying that \"Emacs is an OS that lacks a decent text editor\". Futhermore, you can also write your own Emacs extensions with only a small amount of effort.
Emacs is friendly to Vim users as there is an extension called evil that migrate Vim operations into Emacs. Users can switch from Vim to Emacs with minimum effort. Statistics show that a considerable number of users would switch from Vim to Emacs, but there were almost no users who would switch from Emacs to Vim. In fact, the only weaknesss of Emacs is that it is not as efficient as Vim in pure text editing because of Vim's multi-modal editing. However, with Emacs' powerful extensibility, it can make up for its weaknesses by combining the strengths of both.
"},{"location":"en/%E5%BF%85%E5%AD%A6%E5%B7%A5%E5%85%B7/Emacs/#how-to-learn-emacs","title":"How to learn Emacs","text":"
Same as Vim, Emacs also has a steep learning curve. But once you understand the basic underlying logic, you will never live without it.
There are plenty of tutorials for Emacs. Since Emacs is highly customizable, every user has their own learning path. Here are some good starting points:
This tutorial is a brief guide to the basic logic of Emacs.
Awesome Emacs lists a large number of useful Emacs packages, utilities, and libraries.
One of the most shortcomings of Emacs is the excessive use of the Ctrl key, which is a burden on your left little finger. It is highly recommended to change the keyboard mapping of the Ctrl key. Please refer to Vim for details to remapping.
"},{"location":"en/%E5%BF%85%E5%AD%A6%E5%B7%A5%E5%85%B7/GNU_Make/#why-gnu-make","title":"Why GNU Make","text":"
Everyone remembers their first \"hello world\" program. After editing helloworld.c, you needed to use gcc to compile and generate an executable file, and then execute it. (If you're not familiar with this, please Google gcc compilation and understand the related content first.) However, what if your project consists of hundreds of C source files scattered across various subdirectories? How do you compile and link them together? Imagine if your project takes half an hour to compile (quite common for large projects), and you only changed a semicolon\u2014would you want to wait another half an hour?
This is where GNU Make comes to the rescue. It allows you to define the entire compilation process and the dependencies between target files and source files in a script (known as a Makefile). It only recompiles the parts affected by your changes, significantly reducing compilation time.
"},{"location":"en/%E5%BF%85%E5%AD%A6%E5%B7%A5%E5%85%B7/GNU_Make/#how-to-learn-gnu-make","title":"How to learn GNU Make","text":"
Here is a well-written [document] (https://seisman.github.io/how-to-write-makefile/overview.html) for in-depth and accessible understanding.
Mastering GNU Make is relatively easy, but using it effectively requires continuous practice. Integrate it into your daily development routine, be diligent in learning, and mimic the Makefile styles from other excellent open-source projects. Develop your own template that suits your needs, and over time, you will become more proficient in using GNU Make.
Git is a distributed version control system. The father of Linux, Linus Torvalds developed Git to maintain the version control of Linux, replacing the centralized version control tools which were difficult and costly to use.
The design of Git is very elegant, but beginners usually find it very difficult to use without understanding its internal logic. It is very easy to mess up the version history if misusing the commands.
Git is a powerful tool and when you finally master it, you will find all the effort paid off.
"},{"location":"en/%E5%BF%85%E5%AD%A6%E5%B7%A5%E5%85%B7/Git/#how-to-learn-git","title":"How to learn Git","text":"
Different from Vim, I don't suggest beginners use Git rashly without fully understanding it, because its inner logic can not be acquainted by practicing. Here is my recommended learning path:
Read this Git tutorial in English, or you can watch this Git tutorial (by \u5c1a\u7845\u8c37) in Chinese.
Read Chap1 - Chap5 of this open source book Pro Git. Yes, to learn Git, you need to read a book.
Now that you have understood its principles and most of its usages, it's time to consolidate those commands by practicing. How to use Git properly is a kind of philosophy. I recommend reading this blog How to Write a Git Commit Message.
You are now in love with Git and are not content with only using it, you want to build a Git by yourself! Great, that's exactly what I was thinking. This tutorial will satisfy you!
What? Building your own Git is not enough? Seems that you are also passionate about reinventing the wheels. These two GitHub projects, build-your-own-x and project-based-learning, collected many wheel-reinventing tutorials, e.g., text editor, virtual machine, docker, TCP and so on.
"},{"location":"en/%E5%BF%85%E5%AD%A6%E5%B7%A5%E5%85%B7/GitHub/#what-is-github","title":"What is GitHub","text":"
Functionally, GitHub is an online platform for hosting code. You can host your local Git repositories on GitHub for collaborative development and maintained by a group. However, GitHub's significance has evolved far beyond that. It has become a very active and resource-rich open-source community. Developers from all over the world share a wide variety of open-source software on GitHub. From industrial-grade deep learning frameworks like PyTorch and TensorFlow to practical scripts consisting of just a few lines of code, GitHub offers hardcore knowledge sharing, beginner-friendly tutorials, and even many technical books are open-sourced here (like the one you're reading now). Browsing GitHub has become a part of my daily life.
On GitHub, stars are the ultimate affirmation for a project. If you find this book useful, you are welcome to enter the repository's homepage via the link in the upper right corner and give your precious star\u2728.
"},{"location":"en/%E5%BF%85%E5%AD%A6%E5%B7%A5%E5%85%B7/GitHub/#how-to-use-github","title":"How to Use GitHub","text":"
If you have never created your own remote repository on GitHub or cloned someone else's code, I suggest you start your open-source journey with GitHub's official tutorial.
If you want to keep up with some interesting open-source projects on GitHub, I highly recommend the HelloGitHub website. It regularly features GitHub's recently trending or very interesting open-source projects, giving you the opportunity to access various quality resources firsthand.
I believe GitHub's success is due to the \"one for all, all for one\" spirit of open source and the joy of sharing knowledge. If you also want to become the next revered open-source giant or the author of a project with tens of thousands of stars, then transform your ideas that spark during development into code and showcase them on GitHub.
However, it's important to note that the open-source community is not lawless. Many open-source softwares are not meant for arbitrary copying, distribution, or even sale. Understanding various open-source licenses and complying with them is not only a legal requirement but also the responsibility of every member of the open-source community.
If you need to write academic papers, please skip directly to the next section, as learning LaTeX is not just a choice but a necessity.
LaTeX is a typesetting system based on TeX, developed by Turing Award winner Lamport, while TeX was originally developed by Knuth, both of whom are giants in the field of computer science. Of course, the developers' prowess is not the reason we learn LaTeX. The biggest difference between LaTeX and the commonly used WYSIWYG (What You See Is What You Get) Word documents is that in LaTeX, users only need to focus on the content of the writing, leaving the typesetting entirely to the software. This allows people without any typesetting experience to produce papers or articles with highly professional formatting.
Berkeley computer science professor Christos Papadimitriou once jokingly said:
Every time I read a LaTeX document, I think, wow, this must be correct!
"},{"location":"en/%E5%BF%85%E5%AD%A6%E5%B7%A5%E5%85%B7/Latex/#how-to-learn-latex","title":"How to Learn LaTeX","text":"
The recommended learning path is as follows:
Setting up the LaTeX environment can be a headache. If you encounter problems with configuring LaTeX locally, consider using Overleaf, an online LaTeX editor. The site not only offers a variety of LaTeX templates to choose from but also eliminates the difficulty of environment setup.
Read the following three tutorials: Part-1, Part-2, Part-3.
The best way to learn LaTeX is, of course, by writing papers. However, starting with a math class and using LaTeX for homework is also a good choice.
Other recommended introductory materials include:
A brief guide to installing LaTeX [GitHub] or the TEX Live Guide (texlive-zh-cn) [PDF] can help you with installation and environment setup.
A (not so) brief introduction to LaTeX2\u03b5 (lshort-zh-cn) [PDF] [GitHub], translated by the CTEX development team, helps you get started quickly and accurately. It's recommended to read it thoroughly.
Liu Haiyang's \"Introduction to LaTeX\" can be used as a reference book, to be consulted when you have specific questions. Skip the section on CTEX suite.
Modern LaTeX Introduction Seminar
A Very Short LaTeX Introduction Document
"},{"location":"en/%E5%BF%85%E5%AD%A6%E5%B7%A5%E5%85%B7/Scoop/#why-use-scoop","title":"Why Use Scoop","text":"
Setting up a development environment in Windows has always been a complex and challenging task. The lack of a unified standard means that the installation methods for different development environments vary greatly, resulting in unnecessary time costs. Scoop helps you uniformly install and manage common development software, eliminating the need for manual downloads, installations, and environment variable configurations.
For example, to install Python and Node.js, you just need to execute:
Scoop requires Windows PowerShell 5.1 or PowerShell as its runtime environment. If you are using Windows 10 or later, Windows PowerShell is built into the system. However, the version of Windows PowerShell built into Windows 7 is outdated, and you will need to manually install a newer version of PowerShell.
Many students have encountered issues due to setting up Windows user accounts with Chinese usernames, leading to user directories also being named in Chinese. Installing software via Scoop into user directories in such cases may cause some software to execute incorrectly. Therefore, it is recommended to install in a custom directory. For other installation methods, please refer to: ScoopInstaller/Install
# Set PowerShell execution policy\nSet-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser\n# Download the installation script\nirm get.scoop.sh -outfile 'install.ps1'\n# Run the installation, use --ScoopDir parameter to specify Scoop installation path\n.\\install.ps1 -ScoopDir 'C:\\Scoop'\n
Scoop's official documentation is very user-friendly for beginners. Instead of elaborating here, it is recommended to read the official documentation or the Quick Start guide.
The Scoop community only maintains installation configurations, and all software is downloaded from the official download links provided by the software's creators. Therefore, mirror sources are not provided. If your network environment causes repeated download failures, you may need a bit of magic.
"},{"location":"en/%E5%BF%85%E5%AD%A6%E5%B7%A5%E5%85%B7/Scoop/#why-cant-i-find-java-8","title":"Why Can't I Find Java 8?","text":"
For the same reasons mentioned above, the official download links for Java 8 are no longer provided. It is recommended to use ojdkbuild8 as a substitute.
"},{"location":"en/%E5%BF%85%E5%AD%A6%E5%B7%A5%E5%85%B7/Scoop/#how-do-i-install-python-2","title":"How Do I Install Python 2?","text":"
For software that is outdated and no longer in use, the Scoop community removes it from ScoopInstaller/Main and adds it to ScoopInstaller/Versions. If you need such software, you need to manually add the bucket:
In my opinion, the Vim editor has the following benefits:
It keeps your finger on the keyboard throughout the development and moving the cursor without the arrow keys keeps your fingers in the best position for typing.
Convenient file switching and panel controls allow you to edit multiple files simultaneously or even different locations of the same file.
Vim's macros can batch repeat operations (e.g. add tabs to multi-lines, etc.)
Vim is well-suited for Linux servers without GUI. When you connect to a remote server through ssh, you can only develop from the command line because there is no GUI (of course, many IDEs such as PyCharm now provide ssh plugins to solve this problem).
A rich ecology of plugins gives you the world's most fancy command-line editor.
"},{"location":"en/%E5%BF%85%E5%AD%A6%E5%B7%A5%E5%85%B7/Vim/#how-to-learn-vim","title":"How to learn Vim","text":"
Unfortunately Vim does have a pretty steep learning curve and it took me a few weeks to get used to developing with Vim. You'll feel very uncomfortable at first, but once you get past the initial stages, trust me, you'll fall in love with Vim.
There is a vast amount of learning material available on Vim, but the best way to master it is to use it in your daily development, no need to learn all the fancy advanced Vim tricks right away. The recommended learning path is as follows:
Read This tutorial first to understand the basic Vim concepts and usage.
Use Vim's own vimtutor to practice. After installing Vim, type vimtutor directly into the command line to enter the practice program.
Then you can force yourself to use Vim for development, and you can install Vim plugins in your favorite IDE.
Once you're fully comfortable with Vim, a new world opens up to you, and you can configure your own Vim on demand (by modifying the .vimrc file), and there are countless resources on the Internet to learn from.
If you want to know more about how to customize Vim to suit your needs, Learn Vim Script the Hard Way is a perfect start point.
Ctrl and Esc keys are probably two of the most used keys in Vim. However, these two keys are pretty far away from home row. In order to make it easier to reach these keys, you can remap CapsLock to Esc or Ctrl.
On Windows, Powertoys or AutoHotkey can be used to achieve this goal. On macOS, you can remap keys in system settings, see this page. Karabiner-Elements also works.
A better solution is to make CapsLock function as Esc and Ctrl simultaneously. Click CapsLock to send Esc, hold CapsLock to use it as Ctrl key. Here's how to do it on different systems:
Neil,\u00a0Drew.\u00a0Practical Vim: Edit Text at the Speed of Thought.\u00a0N.p.,\u00a0Pragmatic Bookshelf,\u00a02015.
Neil,\u00a0Drew.\u00a0Modern Vim: Craft Your Development Environment with Vim 8 and Neovim.\u00a0United States,\u00a0Pragmatic Bookshelf.
"},{"location":"en/%E5%BF%85%E5%AD%A6%E5%B7%A5%E5%85%B7/thesis/","title":"Thesis Writing","text":""},{"location":"en/%E5%BF%85%E5%AD%A6%E5%B7%A5%E5%85%B7/thesis/#why-i-wrote-this-tutorial","title":"Why I Wrote This Tutorial","text":"
In 2022, I graduated from my college. When I started writing my thesis, I embarrassingly realized that my command of Word was limited to basic functions like adjusting fonts and saving documents. I considered switching to LaTeX, but formatting requirements for the thesis were more conveniently handled in Word. After a painful struggle, I finally completed the writing and defense of my thesis. To prevent others from following in my footsteps, I compiled relevant resources into a ready-to-use document for everyone's reference.
"},{"location":"en/%E5%BF%85%E5%AD%A6%E5%B7%A5%E5%85%B7/thesis/#how-to-write-a-graduation-thesis-in-word","title":"How to Write a Graduation Thesis in Word","text":"
Just as it takes three steps to put an elephant in a fridge, writing a graduation thesis in Word also requires three simple steps:
Determine the Format Requirements of the Thesis: Usually, colleges will provide the formatting requirements for theses (font and size for headings, sections, formatting of figures and citations, etc.), and if you're lucky, they might even provide a thesis template (if so, jump to the next step). Unfortunately, my college did not issue standard format requirements and provided a chaotic and almost useless template. Out of desperation, I found the thesis format requirements of Peking University graduate students and created a template based on their guidelines. Feel free to use it, but I take no responsibility for any issues for using it.
Learn Word Formatting: At this stage, you either have a standard template provided by your college or just a vague set of formatting requirements. Now, the priority is to learn basic Word formatting skills. If you have a template, learn to use it; if not, learn to create one. Remember, there's no need to ambitiously start with a lengthy Word tutorial video. A half-hour tutorial is enough to get started for creating a passable academic paper. I watched a concise and practical Bilibili tutorial video, which is very useful for a quick start.
Produce Academic Work: The easiest step. Everyone has their own way, so unleash your creativity. Best wishes for a smooth graduation!
excalidraw: A hand-drawn style drawing tool, great for creating diagrams in course reports or PPTs.
tldraw: A drawing tool suitable for flowcharts, architecture diagrams, etc.
draw.io: A powerful and concise online drawing website, supports flowcharts, UML diagrams, architecture diagrams, prototypes, etc., with export options for Onedrive, Google Drive, Github, and offline client availability.
origamiway: Step-by-step origami tutorials.
thingiverse: Includes various 2D/3D design resources, with STL files ready for 3D printing.
iconfont: The largest icon and illustration library in China, useful for development or drawing system architecture diagrams.
turbosquid: A platform to purchase various models.
flaticon: A site to download free and high-quality icons.
Standard Map Service System: Official standard map downloads.
GitHub: Many open-source projects' hosting platform, also a major communication platform for many open-source projects, where issues can solve many problems.
StackExchange: A programming community composed of 181 Q&A communities (including Stack Overflow).
StackOverflow: An IT technical Q&A site related to programming.
Gitee: A code hosting platform similar to GitHub, where you can find solutions to common questions in the issues of corresponding projects.
Zhihu: A Q&A community similar to Quora, where you can ask questions, with some answers containing computer knowledge.
Cnblogs: A knowledge-sharing community for developers, containing blogs on common questions. Accuracy is not guaranteed, please use with caution.
CSDN: Contains blogs on common questions. Accuracy is not guaranteed, please use with caution.
The field of computer science is vast and rapidly evolving, making lifelong learning crucial. However, our sources of knowledge in daily development and learning are complex and fragmented. We encounter extensive documentation manuals, brief blogs, and even snippets of news and public accounts on our phones that may contain interesting knowledge. Therefore, it's vital to use various tools to create a learning workflow that suits you, integrating these knowledge fragments into your personal knowledge base for easy reference and review. After two years of learning alongside work, I have developed the following learning workflow:
Initially, when learning new knowledge, I referred to Chinese blogs but often found bugs and gaps in my code practice. Gradually, I realized that the information I referred to might be incorrect, as the threshold for posting blogs is low and their credibility is not high. So, I started consulting some related Chinese books.
Chinese books indeed provide a comprehensive and systematic explanation of concepts. However, given the rapid evolution of computer technology and the US's leadership in CS, content in Chinese books often lags behind the latest knowledge. This led me to realize the importance of firsthand information. Some Chinese books are translations of English ones, and translation can take a year or two, causing a delay in information transmission and loss during translation. If a Chinese book is not a translation, it likely references other books, introducing biases in interpreting the original English text.
Therefore, I naturally started reading English books. The quality of English books is generally higher than that of Chinese ones. As I delved deeper into my studies, I discovered a hierarchy of information reliability: source code > official documentation > English books > English blogs > Chinese blogs. This led me to create an \"Information Loss Chart\":
Although firsthand information is crucial, subsequent iterations (N-th hand information) are not useless. They include the author's transformation of the source knowledge \u2014 such as logical organization (flow charts, mind maps) or personal interpretations (abstractions, analogies, extensions to other knowledge points). These transformations can help us quickly grasp and consolidate core knowledge, like using guidebooks in school. Moreover, interacting with others' interpretations during learning is important, allowing us to benefit from various perspectives. Hence, it's advisable to first choose high-quality, less distorted sources of information while also considering multiple sources for a more comprehensive and accurate understanding.
In real-life work and study, learning rarely follows a linear, deep dive into a single topic. Often, it involves other knowledge points, such as new jargon, classic papers not yet read, or unfamiliar code snippets. This requires us to think deeply and \"recursively\" learn, establishing connections between multiple knowledge points.
"},{"location":"en/%E5%BF%85%E5%AD%A6%E5%B7%A5%E5%85%B7/workflow/#choosing-the-right-note-taking-software","title":"Choosing the Right Note-taking Software","text":"
The backbone of the workflow is built around the core logic of \"multiple references for a single knowledge point and building connections among various points.\" This is similar to writing academic papers. Papers usually have footnotes explaining keywords and multiple references at the end. But our daily notes are much more casual, hence the need for a more flexible method.
I'm accustomed to jumping to related functions and implementations in an IDE. It would be great if notes could also be interlinked like code. Current \"double-link note-taking software,\" such as Roam Research, Logseq, Notion, and Obsidian, addresses this need. I chose Obsidian for the following reasons:
Obsidian is based locally, with fast opening speeds, and can store many e-books. My laptop, an Asus TUF Gaming FX505 with 32GB of RAM, runs Obsidian very smoothly.
Obsidian is Markdown-based. This is an advantage because if a note-taking software uses a proprietary format, it's inconvenient for third-party extensions and opening notes with other software.
Obsidian has a rich and active plugin ecosystem, allowing for an \"all in one\" effect, meaning various knowledge sources can be integrated in one place.
Obsidian's plugins support PDF formats, and it naturally supports Markdown. To achieve \"all in one,\" you can convert other file formats to PDF or Markdown. This presents two questions:
File formats depend on their display platforms. Before considering formats, let's list the sources of information I usually access:

The main categories are articles, papers, e-books, and courses, primarily including formats like web pages, PDFs, MOBI, AZW, and AZW3.
"},{"location":"en/%E5%BF%85%E5%AD%A6%E5%B7%A5%E5%85%B7/workflow/#conversion-to-pdf-or-markdown","title":"Conversion to PDF or Markdown","text":"
Online articles and courses are mostly presented as web pages. To convert web pages to Markdown, I use the clipping software \"Simplified Read,\" which can clip articles from nearly all platforms into Markdown and import them into Obsidian.
For papers and e-books, if the format is already PDF, it's straightforward. Otherwise, I use Calibre for conversion:
Now, using Obsidian's PDF plugin and native Markdown support, I can seamlessly take notes and reference across these documents (see \"Information Processing\" below for details).
"},{"location":"en/%E5%BF%85%E5%AD%A6%E5%B7%A5%E5%85%B7/workflow/#managing-information-sources","title":"Managing Information Sources","text":"
For file resources like PDFs, I use local or cloud storage. For web resources, I categorize and save them in browser bookmarks or clip them into Markdown notes. However, browsers don't support mobile web bookmarking. To enable cross-platform web bookmarking, I use Cubox. With a swipe on my phone, I can save interesting web pages in one place. Although the free version limits to 100 bookmarks, it's usually sufficient and prompts me to process these pages promptly.
Moreover, many of the web pages we bookmark are not from fully-featured blog platforms like Zhihu or Juejin but personal sites without mobile apps. These can be easily overlooked in browser bookmarks, and we might miss new article notifications. Here, RSS comes into play.
RSS (Rich Site Summary) is a type of web feed that allows users to access updates to online content in a standardized format. On desktops, RSSHub Radar helps discover and generate RSS feeds, which can be subscribed to using Feedly (both have official Chrome browser plugins).
With this, the information collection process is comprehensive. But no matter how well categorized, information needs to be internalized to be useful. After collecting information, the next step is processing it \u2014 reading, understanding the semantics (especially for English sources), highlighting key sentences or paragraphs, noting queries, brainstorming related knowledge points, and writing summaries. What tools are needed for this process?
For English materials, I initially used \"Youdao Dictionary\" for word translation, Google Translate for sentences, and \"Deepl\" for paragraphs. Eventually, I realized this was too slow and inefficient. Ideally, a single tool that can handle word, sentence, and paragraph translation would be optimal. After researching, I chose \"Quicker\" + \"Saladict\" for translation.
This combo allows translation outside browsers and supports words, sentences, and paragraphs, offering results from multiple translation platforms. For non-urgent word lookups, the \"Collins Advanced\" dictionary is helpful as it explains English words in English, providing context to aid understanding.
After processing text-based information, it's important to consider how to handle multimedia information. Specifically, I'm referring to English videos, as I don't have a habit of learning through podcasts or recordings and I rarely watch Chinese tutorials anymore. Many renowned universities offer open courses in video format. Wouldn't it be helpful if you could take notes on these videos? Have you ever thought it would be great if you could convert the content of a lecture into text, since we usually read faster than a lecturer speaks? Fortunately, the software Language Reactor can export subtitles from YouTube and Netflix videos, along with Chinese translations.
We can copy the subtitles exported by Language Reactor into Obsidian and read them as articles. Besides learning purposes, you can also use this plugin while watching YouTube videos. It displays subtitles in both English and Chinese, and you can click on unfamiliar words in the subtitles to see their definitions.
However, reading texts isn't always the most efficient way to learn about some abstract concepts. As the saying goes, \"A picture is worth a thousand words.\" What if we could link a segment of text to corresponding images or even video operations? While browsing the Obsidian plugin marketplace, I discovered a plugin called Media Extended. This plugin allows you to add links in your notes that jump to specific times in a video, effectively connecting your notes to the video! This works well with the video subtitles mentioned earlier, where each line of subtitles corresponds to a time stamp, allowing for jumps to specific parts of the video. This means you don't have to cut specific video segments; instead, you can jump directly within the article!
Obsidian also has a powerful plugin called Annotator, which allows you to jump from notes to the corresponding section in a PDF.
Now, with Obsidian's built-in double-chain feature, we can achieve inter-note linking, and with the above plugins, we can extend these links to multimedia. This completes the process of information handling. Learning often involves both a challenging ascent and a familiar descent. So, how can we incorporate the review process into this workflow?
Obsidian already has a plugin that connects to Anki, the renowned spaced repetition-based memory software. With this plugin, you can export segments of your notes to Anki as flashcards, each containing a link back to the original note.
This workflow evolved over two years of learning in my spare time. Frustration with repetitive processes led to specific needs, which were fortunately met by tools I discovered online. Don't force tools into your workflow just for the sake of satisfaction; life is short, so focus on what's truly important.
By the way, this article discusses the evolution of the workflow. If you're interested in the details of how this workflow is implemented, I recommend reading the following articles in order after this one:
3000+ Hours Accumulated Learning Workflow
Advanced Techniques in Obsidian | Creating Notes that Link to Any File Format
When encountering a problem, remember the first thing is to read the documentation. Don't start by searching online or asking others directly. Reviewing FAQs may quickly provide the answer.
Information retrieval, as I understand it, is essentially about skillfully using search engines to quickly find the information you need, including but not limited to programming.
The most important thing in programming is STFW (search the fucking web) and RTFM (read the fucking manual). First, you should read the documentation, and second, learn to search. With so many resources online, how you use them depends on your information retrieval skills.
To understand how to search effectively, we first need to understand how search engines work.
The working process of a search engine can generally be divided into three stages: 1
Crawling and Fetching: Search engine spiders visit web pages by tracking links, obtain the HTML code of the pages, and store it in a database.
Preprocessing: The indexing program processes the fetched web page data by extracting text, segmenting Chinese words, indexing, etc., preparing for the ranking program.
Ranking: When users enter keywords, the ranking program uses the indexed data to calculate relevance and then generates the search results page in a specific format.
The first step involves web crawlers, often exaggerated in Python courses. It can be simply understood as using an automated program to download all text, images, and related information from websites and store them locally.
The second step is the core of a search engine, but not critical for users to understand. It can be roughly understood as cleaning data and indexing pages, each with keywords for easy querying.
The third step is closely related to us. Whether it's Google, Baidu, Bing, or others, you input keywords or queries, and the search engine returns results. This article teaches you how to obtain better results.
Based on the above working principles, we can roughly understand that a search engine can be treated as a smart database. Using better query conditions can help you find the information you need faster. Here are some search techniques:
Don't search whole sentences. Although search engines automatically segment words, searching with whole sentences versus keywords can yield significantly different results in accuracy and order. Search engines are machines, not your teachers or colleagues. As mentioned above, searching is actually querying a database crawled by the search engine, so it's better to break down into keywords or phrases.
For example, if you want to know how to integrate vcpkg into a project instead of globally, searching for \"\u5982\u4f55\u5c06vcpkg\u96c6\u6210\u5230\u9879\u76ee\u4e2d\u800c\u4e0d\u662f\u5168\u5c40\" in a long sentence may not yield relevant results. It's better to break it down into keywords like \"vcpkg \u96c6\u6210 \u9879\u76ee \u5168\u5c40\".
If you can't find what you're looking for, try replacing \"\u9879\u76ee\" with \"\u5de5\u7a0b\" or remove \"\u96c6\u6210\". If that doesn't work, try advanced searching.
Use GitHub's Advanced Search page or refer to GitHub Query Syntax for advanced searches on GitHub. Examples include searching by repository name, description, readme, stars, fork count, size, update/creation date, license, language, user, and organization. These can be
Many programmers advise against using Baidu, preferring Google or Bing International. However, if you really need it, consider using alternatives like Ecosia or Yandex. For Chinese searches, Baidu might actually be the best option due to its database and indexing policies.
Firstly, the textbook: Operating Systems: Principles and Practice (2nd Edition) is written in an insightful but easy-to-understand way, well compensated for the lack of theoretical knowledge in MIT6.S081, I highly recommend you to read this book.
Secondly, the project for this course Pintos is a great journey for system hackers. Pintos is a toy operating system developed at Stanford for educational use. The author Ben Pfaff even published a paper to explain the design principles of Pintos.
Unlike the small but comprehensive design philosophy in MIT's xv6 labs, Pintos emphasizes system design and implementation more. The codebase is about 10,000 LOC and only provides the basic functions of a working operating system. The four projects let you add scheduler (Project1), system calls (Project2), virtual memory (Project3), and the file system (Project4) to this extremely simple operating system. All projects leave a a big design space for students and require more than 2000 LOC. Based on the feedback from Stanford students, the latter two projects take over 40 hours per person even in teams of 3-4 people.
Although it is tough, Stanford, Berkeley, JHU and many other top U.S. colleges have chosen Pintos as their OS course project. If you're really interested in operating systems, it will greatly improve your ability to write and debug low-level system code. For me, it is an invaluable experience to design, implement, and debug a large system independently.
Pintos will also be introduced as a course project in Peking University's OS Course. In the Spring 2022 semester, I worked with another TA to write a comprehensive lab documentation and provided a docker image for the ease of cross-platform development. In the last semester before graduation, I hope such an attempt can make more people fall in love with systems and contribute to the field of systems in China.
If you search on Zhihu for questions like \"how to self-study operating systems\", \"recommended open courses for operating systems\", \"computer courses you wish you had discovered earlier\", etc., the operating systems course by Professor Li Zhijun of Harbin Institute of Technology (HIT) is likely to appear in the high-rated answers. It's a relatively well-known and popular Chinese computer course.
This course excels at gently guiding students from their perspective. For instance, it starts from \"humbly asking, what is an operating system\" to \"lifting the lid of the operating system piano\", deriving the concept of processes from intuitive CPU management, and introducing memory management by initially \"letting the program enter memory\".
The course emphasizes the combination of theory and practice. Operating systems are tangible, and Professor Li repeatedly stresses the importance of doing experiments. You won't fully grasp operating systems if you just watch videos and theorize. The course explains and conducts experiments based on actual Linux 0.11 source code (around 20,000 lines in total), with eight small labs and four projects.
Of course, this course also has minor imperfections. For example, Linux 0.11 is very early industrial code and not designed for teaching. Thus, there are some unavoidable obscure and difficult parts of the codebase in the projects, but they don't contribute much to the understanding of operating systems.
This is the undergraduate operating system course at MIT, offered by the well-known PDOS Group. One of the instructors, Robert Morris, was once a famous hacker who created 'Morris', the first worm virus in the world.
The predecessor of this course was the famous MIT6.828. The same instructors at MIT created an educational operating system called JOS based on x86, which has been adopted by many other famous universities. While after the birth of RISC-V, they implemented it based on RISC-V, and offered MIT 6.S081. RISC-V is lightweight and user-friendly, so students don't have to struggle with the confusing legacy features in x86 as in JOS, but focus on the operating system design and implementation.
The instructors have also written a tutorial, elaborately explaining the ideas of design and details of the implementation of xv6 operating system.
The teaching style of this course is also interesting, the instructors guided the students to understand the numerous technical challenges and design principles in the operating systems by going through the xv6 source code, instead of merely teaching theoretical knowledge. Weekly Labs will let you add new features to xv6, which focus on enhancing students' practical skills. There are 11 labs in total during the whole semester which give you the chance to understand every aspect of the operating systems, bringing a great sense of achievement. Each lab has a complete framework for testing, some tests are more than a thousand lines of code, which shows how much effort the instructors have made to teach this course well.
In the second half of the course, the instructors will discuss a couple of classic papers in the operating system field, covering file systems, system security, networking, virtualization, and so on, giving you a chance to have a taste of the cutting edge research directions in the academic field.
All resources used and assignments implemented by @PKUFlyingPig when learning this course are in PKUFlyingPig/MIT6.S081-2020fall - GitHub.
@KuangjuX documented his solutions with detailed explanations and complementary knowledge. Moreover, @KuangjuX has reimplemented the xv6 operating system in Rust which contains more detailed reviews and discussions about xv6.
"},{"location":"en/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F/MIT6.S081/#some-blogs-for-references","title":"Some Blogs for References","text":"
I had always heard that the operating system course taught by Professor Yanyan Jiang at Nanjing University was excellent. This semester, I had the opportunity to watch his lectures on Bilibili and gained a lot. As a young professor with rich coding experience, his teaching is full of a hacker's spirit. Often in class, he would start coding in the command line on a whim, and many important points were illustrated with vivid and straightforward code examples. What struck me most was when he implemented a mini executable file and a series of binary tools to help students better understand the design philosophy of dynamic link libraries, solving many problems that had puzzled me for years.
In the course, Prof. Jiang starts from the perspective that \"programs are state machines\" to establish an explainable model for the \"root of all evil\" concurrent programs. Based on this, he discusses common methods of concurrency control and strategies for dealing with concurrency bugs. Then, he views the operating system as a series of objects (processes/threads, address spaces, files, devices, etc.) and their APIs (system calls), combined with rich practical examples to show how operating systems use these objects to virtualize hardware resources and provide various services to application software. In the final part about persistence, he builds up various storage devices from 1-bit storage media and abstracts a set of interfaces through device drivers to facilitate the design and implementation of file systems. Although I have taken many operating system courses before, this unique approach has given me many unique perspectives on system software.
In addition to its innovative theoretical instruction, the course's emphasis on practice is a key feature of Prof. Jiang's teaching. In class and through programming assignments, he subtly cultivates the ability to read source code and consult manuals, which are essential skills for computer professionals. During the fifth MiniLab, I read Microsoft's FAT file system manual in detail for the first time, gaining a very valuable experience.
The programming assignments consist of 5 MiniLabs and 4 OSLabs. Unfortunately, the grading system is only open to students at Nanjing University. However, Professor Jiang generously allowed me to participate after I emailed him. I completed the 5 MiniLabs, and the overall experience was excellent. Particularly, the second coroutine experiment left a deep impression on me, where I experienced the beauty and \"terror\" of context switching in a small experiment of less than a hundred lines. Also, the MiniLabs can be easily tested locally, so the lack of a grading system should not hinder self-learning. Therefore, I hope others will not collectively \"harass\" the professor for access.
Finally, I want to thank Professor Jiang again for designing and offering such an excellent operating system course, the first independently developed computer course from a domestic university included in this book. It's thanks to young, new-generation teachers like Professor Jiang, who teach with passion despite the heavy Tenure track evaluation, that many students have an unforgettable undergraduate experience. I also look forward to more such high-quality courses in China, which I will include in this book for the benefit of more people.
Gilbert Strang, a great mathematician at MIT, still insists on teaching in his eighties. His classic text book Introduction to Linear Algebra has been adopted as an official textbook by Tsinghua University. After reading the PDF version, I felt deeply guilty and spent more than 200 yuan to purchase a genuine version in English as collection. The cover of this book is attached below. If you can fully understand the mathematical meaning of the cover picture, then your understanding of linear algebra will definitely reach a new height.
In addition to the course materials, the famous Youtuber 3Blue1Brown's video series The Essence of Linear Algebra are also great learning resources.
Textbook: Introduction to Linear Algebra, Gilbert Strang
Assignments: refer to the course website
On May 15th, 2023, revered mathematics professor Gilbert Strang capped his 61-year career as a faculty member at MIT by delivering his final 18.06 Linear Algebra lecture before retiring at the age of 88. In addition to a brief review for the course final exam, the overflowing audience (both in person and on the live YouTube stream) heard recollections, appreciations, and congratulations from Prof. Strang\u2019s colleagues and former students. A rousing standing ovation concluded this historic event.
The calculus course at MIT consists of MIT18.01: Single Variable Calculus and MIT18.02: Multivariable Calculus. If you are confident in your math, you can just read the course notes, which are written in a very simple and vivid way, so that you will not be tired of doing homework but can really see the essence of calculus.
In addition to the course materials, the famous Youtuber 3Blue1Brown's video series The Essence of Calculus are also great learning resources.
This is MIT's introductory information theory course for freshmen, Professor Penfield has written a special textbook for this course as course notes, which is in-depth and interesting.
This is MIT\u2018s discrete mathematics and probability course taught by the notable Tom Leighton (co-founder of Akamai). It is very useful for learning algorithms subsequently.
This is Berkeley's advanced probability course, which involves relatively advanced theoretical content such as statistics and stochastic processes, so a solid mathematical foundation is required. But as long as you stick with it you will certainly take your mastery of probability theory to a new level.
The course is designed by Professor Jean Walrand, who has written an accompanying textbook, Probability in Electrical Engineering and Computer Science, in which each chapter uses a specific algorithm as a practical example to demonstrate the application of theory in practice. Such as PageRank, Route Planing, Speech Recognition, etc. The book is open source and can be downloaded as a free PDF or Epub version.
Jean Walrand has also created accompanying Python implementations of the examples throughout the book, which are published online as Jupyter Notebook that readers can modify, debug and run them online interactively.
In addition to the Homework, nine Labs will allow you to use probability theory to solve practical problems in Python.
All the resources and assignments used by @PKUFlyingPig in this course are maintained in PKUFlyingPig/EECS126 - GitHub
"},{"location":"en/%E6%95%B0%E5%AD%A6%E8%BF%9B%E9%98%B6/CS70/","title":"UCB CS70: Discrete Math and Probability Theory","text":""},{"location":"en/%E6%95%B0%E5%AD%A6%E8%BF%9B%E9%98%B6/CS70/#descriptions","title":"Descriptions","text":"
Offered by: UC Berkeley
Prerequisites: None
Programming Languages: None
Difficulty: \ud83c\udf1f\ud83c\udf1f\ud83c\udf1f
Class Hour: 60 hours
This is Berkeley's introductory discrete mathematics course. The biggest highlight of this course is that it not only teaches you theoretical knowledge, but also introduce the applications of theoretical knowledge in practical algorithms in each module. In this way, students majoring in CS can understand the essence of theoretical knowledge and use it in practice rather than struggle with cold formal mathematical symbols.
Specific theory-algorithm correspondences are listed below.
Logic proof: stable matching algorithm
Graph theory: network topology design
Basic number theory: RSA algorithm
Polynomial ring: error-correcting code design
Probability theory: Hash table design, load balancing, etc.
The course notes are also written in a very in-depth manner, with derivations of formulas and practical examples, providing a good reading experience.
Prerequisites: Calculus, Linear Algebra, Probabilities and Statistics
Programming Languages: Anything would be OK, Python preferred
Difficulty: \ud83c\udf1f\ud83c\udf1f\ud83c\udf1f
Class Hour: 30-50 hours
This is a course on information theory taught by Sir David MacKay at the University of Cambridge. The professor is a very famous scholar in information theory and neural networks, and the textbook for the course is a classic work in the field of information theory. Unfortunately, those whom God loves die young ...
Professor Stephen Boyd is a great expert in the field of convex optimization and his textbook Convex Optimization has been adopted by many prestigious universities. His team has also developed a programming framework for solving common convex optimization problems in Python, Julia, and other popular programming languages, and its homework assignments also use this programming framework to solve real-life convex optimization problems.
In practice, you will deeply understand that for the same problem, a small change in the modeling process can make a world of difference in the difficulty of solving the equation. It is an art to make the equations you formulate \"convex\".
While the computational power of computers has been helping people to push boundaries of science, there is a natural barrier between the discrete nature of computers and this continuous world, and how to use discrete representations to estimate and approximate those mathematically continuous concepts is an important theme in numerical analysis.
This course will explore various numerical analysis methods in the areas of floating-point representation, equation solving, linear algebra, calculus, and differential equations, allowing you to understand (1) how to design estimation (2) how to estimate errors (3) how to implement algorithms in Julia. There are also plenty of programming assignments to practice these ideas.
The designers of this course have also written an open source textbook for this course (see the link below) with plenty of Julia examples.
As an introductory course to databases at CMU, this course is taught by Andy Pavlo, a leading figure in the database field (quoted as saying, \"There are only two things I care about in this world, one is my wife, the second is the database\").
This is a high-quality, resource-rich introductory course to Databases.
The faculty and the CMU Database Group behind the course have open-sourced all the corresponding infrastructure (Autograder, Discord) and course materials (Lectures, Notes, Homework), enabling any student who is willing to learn about databases to enjoy an experience almost equivalent to that of a CMU student.
One of the highlights of this course is the relational database Bustub, which was specifically developed by the CMU Database Group for teaching purposes. It requires you to modify various components of this database and implement their functionalities.
Specifically, in 15-445, you will need to implement some key components in Bustub, a traditional disk-oriented relational database, through the progression of four Projects.
These components include the Buffer Pool Manager (for memory management), B Plus Tree (storage engine), Query Executors & Query Optimizer (operators & optimizer), and Concurrency Control, corresponding to Project #1 through Project #4.
Worth mentioning is that, during the implementation process, students can compile bustub-shell through shell.cpp to observe in real-time whether their implemented components are correct. The feedback is very sufficient.
Furthermore, as a medium-sized project written in C++, bustub covers many requirements such as program construction, code standards, unit testing, etc., making it an excellent open-source project for learning.
Course Website: Fall 2019, Fall 2020, Fall 2021, Fall 2022, Spring 2023
Recording: The course website is freely accessible, and the Youtube Lectures for Fall 2022 are fully open-source.
Textbook: Database System Concepts
Assignments: Five Projects and Five Homework
In Fall 2019, Project #2 involved creating a hash index, and Project #4 focused on logging and recovery.
In Fall 2020, Project #2 was centered on B-trees, while Project #4 dealt with concurrency control.
In Fall 2021, Project #1 required the creation of a buffer pool manager, Project #2 involved a hash index, and Project #4 focused on concurrency control.
In Fall 2022, the curriculum was similar to that of Fall 2021, with the only change being that the hash index was replaced by a B+ tree index, and everything else remained the same.
In Spring 2023, the overall content was largely identical to Fall 2022 (buffer pool, B+ tree index, operators, concurrency control), except Project #0 shifted to Copy-On-Write Trie. Additionally, a fun task of registering uppercase and lowercase functions was introduced, which allows you to see the actual effects of the functions you write directly in the compiled bustub-shell, providing a great sense of achievement.
It's important to note that the versions of bustub prior to 2020 are no longer maintained.
The last Logging & Recovery Project in Fall 2019 is broken (it may still run on the git head from 2019, but Gradescope doesn't provide a public version, so it is not recommended to work on it, it is sufficient to just review the code and handout).
Perhaps in the Fall 2023 version, the recovery features will be fixed, and there may also be an entirely new Recovery Project. Let's wait and see \ud83e\udd2a.
If you have the energy, I highly recommend giving all of them a try, or if there's something in the book that you don't quite understand, attempting the corresponding project can deepen your understanding (I personally suggest completing all of them, as I believe it will definitely be beneficial).
The unofficial Discord is a great platform for discussion. The chat history practically documents the challenges that other students have encountered. You can also raise your own questions or help answer others', which I believe will be a great reference.
For a guidance to get through Spring 2023, you can refer to this article by @xzhseh on Zhihu (Note: Since the article is originally written in Chinese, you may need a translator to read it :) ). It covers all the tools you need to succeed, along with guides and, most importantly, pitfalls that I've encountered, seen, or stepped into during the process of doing the Project.
All the resources and assignments used by @ysj1173886760 in this course are maintained in ysj1173886760/Learning:db - GitHub.
Due to Andy's request, the repository does not contain the source code for the project, only the solution for homework. In particular, for Homework1, @ysj1173886760 wrote a shell script to help you evaluate your solution automatically.
After the course, it is recommended to read the paper Architecture Of a Database System. This paper provides an overview of the overall architecture of database systems so that you can have a more comprehensive view of the database.
CMU15-721 is a graduate-level course on advanced database system topics. It mainly focuses on the in-memory database, and each class has a corresponding paper to read. It is suitable for those who wish to do research in the field of databases. @ysj1173886760 is currently following up on this course and will create a pull request here after completing it to provide advanced guidance.
This course has only been offered twice so far, in Fall 2013 and Spring 2022, and it discusses some cutting-edge topics in the field of databases. The Fall 2013 session covered topics like Streaming, Graph DB, NVM, etc., while the Spring 2022 session mainly focused on Self-Driving DBMS, with relevant papers provided.
The tasks for the Spring 2022 version of the course included:
Task One: Manual performance tuning based on PostgreSQL.
Task Two: Improving the Self-Driving DBMS based on NoisePage Pilot, with no limitations on features.
The teaching style is more akin to a seminar, with fewer programming assignments. This course can broaden the horizons for general students and may be particularly beneficial for those specializing in databases.
Caltech's course, unlike CMU15-445 which does not offer SQL layer functionality, focuses on the implementation at the SQL layer in its CS122 course labs. It covers various modules of a query optimizer, such as SQL parsing, translation, implementation of joins, statistics and cost estimation, subquery implementation, and the implementation of aggregations and group by operations. Additionally, there are experiments related to B+ trees and Write-Ahead Logging (WAL). This course is suitable for students who have completed the CMU15-445 course and are interested in query optimization.
Below is an overview of the first three assignments or lab experiments of this course:
Perform plan cost calculation for various plan nodes.
Calculate the selectivity of various predicates that may appear in the execution plan.
Update the tuple statistics of the plan nodes' outputs based on predicates.
For the remaining Assignments and Challenges, please refer to the course description. It is recommended to use IDEA to open the project and Maven for building, keeping in mind the log-related configurations.
How to write SQL queries? How are SQL commands disassembled, optimized, and transformed into on-disk query commands step by step? How to implement a high-concurrency database? How to implement database failure recovery? What is NoSQL? This course elaborates on the internal details of relational databases. Besides the theoretical knowledge, you will use Java to implement a real relational database that supports SQL concurrent query, B+ tree index, and failure recovery.
From a practical point of view, you will have the opportunity to write SQL queries and NoSQL queries in course projects, which is very helpful for building full-stack projects.
RedBase, the project for CS346, involves the implementation of a simplified database system and is highly structured. The project can be divided into the following parts, which also correspond to the four labs that need to be completed:
The Record Management Component: This involves the implementation of record management functionalities.
The Index Component: Focuses on the management of B+ tree indexing.
The System Management Component: Deals with DDL statements, command-line tools, data loading commands, and metadata management.
The Query Language Component: In this part, students are required to implement the RQL Redbase Query Language, including select, insert, delete, and update statements.
Extension Component: Beyond the basic components of a database system, students must implement an extension component, which could be a Blob type, network module, join algorithms, CBO optimizer, OLAP, transactions, etc.
RedBase is an ideal follow-up project for students who have completed CMU 15-445 and wish to learn other components of a database system. Due to its manageable codebase, it allows for convenient expansion as needed. Furthermore, as it is entirely written in C++, it also serves as good practice for C++ programming skills.
This is Berkeley's introductory course in data science, covering the basics of data cleaning, feature extraction, data visualization, machine learning and inference, as well as common data science tools such as Pandas, Numpy, and Matplotlib. The course is also rich in interesting programming assignments, which is one of the highlights of the course.
Probably the most precious course from the EECS department of MIT. Taught by Erik Demaine, one of the geniuses in Algorithms.
Compared with CS106B/X (Data structures and algorithms using C++), 6.006 emphasizes the algorithms more. It also covers several classical data structures such as AVL trees. You may use it to learn more about algorithms after CS106B/X.
Part 2 of the MIT Algorithms Trilogy. Taught by Erik Demaine, Srini Devadas, and Nancy Lynch.
Compared with 6.006 where you just learn and use the algorithms directly, in 6.046 you will be required to learn a methodology to \"Design and analyze\" algorithms to solve certain problems. There are few programming exercises in this course, and most of the assignmnets are about proposing an algorithm and do some mathematical proofs. Therefore, it would be much harder than 6.006.
Part 3 of the MIT Algorithms Trilogy is 6.854 Advanced Algorithms. But for the most of the exercises you'll encounter in tests and job-hunting, 6.046 is definitely enough.
This is the highest rated algorithms course on Coursera, and Robert Sedgewick has the magic to make even the most complex algorithms incredibly easy to understand. To be honest, the KMP and network flow algorithms that I have been struggling with for years were made clear to me in this course, and I can even write derivations and proofs for both of them two years later.
Do you feel that you forget the algorithms quickly after learning them? I think the key to fully grasping an algorithm lies in understanding the three points as follows:
Why should do this? (Correctness derivation, or the essence of the entire algorithm.)
How to implement it? (Talk is cheap. Show me the code.)
How to use it to solve practical problems? (Bridge the gap between theory and real life.)
The composition of this course covers the three points above very well. Watching the course videos and reading the professor's textbook will help you understand the essence of the algorithm and allow you to tell others why the algorithm should look like this in very simple and vivid terms.
After understanding the algorithms, you can read the professor's code implementation of all the data structures and algorithms taught in the course. Note that these codes are not demos, but production-ready, time-efficient implementations. They have extensive annotations and comments, and the modularization is also quite good. I learned a lot by just reading the codes.
Finally, the most exciting part of the course is the 10 high-quality projects, all with real-world backgrounds, rich test cases, and an automated scoring system (code style is also a part of the scoring). You'll get a taste of algorithms in real life.
This is Berkeley's algorithm design and analysis course. It focuses on the theoretical foundations and complexity analysis of algorithms, covering Divide-and-Conquer, Graph Algorithms, Shortest Paths, Spanning Trees, Greedy Algorithms, Dynamic programming, Union Finds, Linear Programming, Network Flows, NP-Completeness, Randomized Algorithms, Hashing, etc.
The textbook for this course is well written and very suitable as a reference book. In addition, this class has written assignments and is recommended to use LaTeX. You can take this opportunity to practice your LaTeX skills.
It is the second course of UC Berkeley's CS61 series. It mainly focuses on the design of data structures and algorithms as well as giving students the opportunity to be exposed to thousands of lines of engineering code and gain a preliminary understanding of software engineering through Java.
I took the version for 2018 Spring. Josh Hug, the instructor, generously made the autograder open-source. You can use gradescope invitation code published on the website for free and easily test your implementation.
All programming assignments in this course are done in Java. Students without Java experience don't have to worry. There will be detailed tutorials in the course from the configuration of IDEA to the core syntax and features of Java.
The quality of homework in this class is also unparalleled. The 14 labs will allow you to implement most of the data structures mentioned in the class by yourself, and the 10 homework will allow you to use data structures and algorithms to solve practical problems. In addition, there are 3 projects that give you the opportunity to be exposed to thousands of lines of engineering code and enhance your Java skills in practice.
Assignments: Slightly different every year. In the spring semester of 2018, there are 14 Labs, 10 Homework and 3 Projects. Please refer to the course website for specific requirements.
I did not take this course but used its lecture notes as reference books. From the course website, I think it is better than CS299 because all the assignments and autograder are open source. Also, this course is quite theoretical and in-depth.
This is another ML course offered by Andrew Ng. Since it is graduate-level, it focuses more on the mathematical theory behind machine learning. If you are not satisfied with using off-the-shelf tools but want to understand the essence of the algorithm, or aspire to engage in theoretical research on machine learning, you can take this course. All the lecture notes are provided on the course website, written in a professional and theoretical way, requiring a solid mathematical background.
Prerequisites: entry level of AI and proficient in Python
Programming Languages: Python
Difficulty: \ud83c\udf1f\ud83c\udf1f\ud83c\udf1f
Class Hour: 100 hours
When it comes to Andrew Ng, no one in the AI community should be unaware of him. He is one of the founders of the famous online education platform Coursera, and also a famous professor at Stanford. This introductory machine learning course must be one of his famous works (the other is his deep learning course), and has hundreds of thousands of learners on Coursera (note that these are people who paid for the certificate, which costs several hundred dollars), and the number of nonpaying learners should be far more than that.
The class is extremely friendly to novices, and Andrew has the ability to make machine learning as straightforward as 1+1=2. You'll learn about linear regression, logistic regression, support vector machines, unsupervised learning, dimensionality reduction, anomaly detection, and recommender systems, etc. and solidify your understanding with hands-on programming. The quality of the assignments needs no word to say. With detailed code frameworks and practical background, you can use what you've learned to solve real problems.
Of course, as a public mooc, the difficulty of this course has been deliberately lowered, and many mathematical derivations are skimmed over. If you are interested in machine learning theory and want to investigate the mathematical theory behind these algorithms, you can refer to CS229 and CS189.
My implementation is lost in system reinstallation. However, the course is so famous that you can easily find related resources online. Also, course material is available on Coursera.
Intelligent computing systems serve as the backbone for global AI, producing billions of devices annually, including smartphones, servers, and wearables. Training professionals for these systems is critical for China's AI industry competitiveness. Understanding intelligent computing systems is vital for computer science students, shaping their core skills.
Prof. Yunji Chen's course, taught in various universities, uses experiments to provide a holistic view of the AI tech stack. Covering deep learning frameworks, coding in low-level languages, and hardware design, the course fosters a systematic approach.
Personally, completing experiments 2-5 enhanced my grasp of deep learning frameworks. The BCL language experiment in chapter five is reminiscent of CUDA for those familiar.
I recommend the textbook for a comprehensive tech stack understanding. Deep learning-savvy students can start from chapter five to delve into deep learning framework internals.
Inspired by the course, I developed a simple deep learning framework and plan a tutorial. Written in Python, it's code-light, suitable for students with some foundation. Future plans include more operators and potential porting to C++ for balanced performance and efficiency.
Course Textbook\uff1a\"Intelligent Computing Systems\" by Chen Yunji
"},{"location":"en/%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%E7%B3%BB%E7%BB%9F/AICS/#personal-resources","title":"Personal Resources","text":""},{"location":"en/%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%E7%B3%BB%E7%BB%9F/AICS/#new-edition-experiments-for-2024","title":"New Edition Experiments for 2024","text":"
The 2024 edition of the Intelligent Computing Systems lab has undergone extensive adjustments in the knowledge structure, experimental topics, and lab manuals, including comprehensive use of PyTorch instead of TensorFlow, and the addition of experiments related to large models.
As the new lab topics and manuals have not been updated on the Cambricon Forum, the following repository is provided to store the new versions of the Intelligent Computing Systems lab topics, manuals, and individual experiment answers:
The resources for the new edition will be updated following the course schedule of the UCAS Spring Semester 2024, with completion expected by June 2024.
2024 New labs, manuals, and answers created by @Yuichi: https://github.com/Yuichi1001/2024-AICS-EXP
Old edition coursework: 6 experiments (including writing convolution operators, adding operators to TensorFlow, writing operators with BCL and integrating them into TensorFlow, etc.) (details can be found on the official website)
Old edition lab manuals: Experiment 2.0 Instruction Manual
Learning notes: https://sanzo.top/categories/AI-Computing-Systems/, notes summarized from the lab manuals (link is no longer active)
@ysj1173886760 has compiled all resources and homework implementations used in this course at ysj1173886760/Learning: ai-system - GitHub.
Prerequisites: Introduction to Systems (e.g., 15-213), Basics of Deep Learning, Fundamental Mathematical Knowledge
Programming Languages: Python, C++
Difficulty: \ud83c\udf1f\ud83c\udf1f\ud83c\udf1f
Estimated Hours: 100 hours
The rise of deep learning owes much to user-friendly frameworks like PyTorch and TensorFlow. Yet, many users remain unfamiliar with these frameworks' internals. If you're curious or aspiring to delve into deep learning framework development, this course is an excellent starting point.
Covering the full spectrum of deep learning systems, the curriculum spans top-level framework design, autodifferentiation principles, hardware acceleration, and real-world deployment. The hands-on experience includes five assignments, building a deep learning library called Needle. Needle supports automatic differentiation, GPU acceleration, and various neural networks like CNNs, RNNs, LSTMs, and Transformers.
Even for beginners, the course gradually covers simple classification and backpropagation optimization. Detailed Jupyter notebooks accompany complex neural networks, providing insights. For those with foundational knowledge, assignments post autodifferentiation are approachable, offering new understandings.
Instructors Zico Kolter and Tianqi Chen released open-source content. Online evaluations and forums are closed, but local testing in framework code remains. Hope for an online version next fall.
This course, offered by top scholar Chen Tianqi during the summer of 2022, focuses on the field of machine learning compilation. As of now, this area remains cutting-edge and rapidly evolving, with no dedicated courses available domestically or internationally. If you're interested in gaining a comprehensive overview of machine learning compilation, this course is worth exploring.
The curriculum predominantly centers around the popular machine learning compilation framework Apache TVM, co-founded by Chen Tianqi. It delves into transforming various machine learning models developed in frameworks like Tensorflow, Pytorch, and Jax into deployment patterns with higher performance and adaptability across different hardware. The course imparts knowledge at a relatively high level, presenting macro-level concepts. Each session is accompanied by a Jupyter Notebook that provides code-based explanations of the concepts. If you are involved in TVM-related programming and development, this course offers rich and standardized code examples for reference.
All course resources are open-source, with versions available in both Chinese and English. The course recordings can be found on both Bilibili and YouTube in both languages.
Course Resources: The course website includes slides, notes, videos, homework, and project materials.
CMU's course on Probabilistic Graphical Models, taught by Eric P. Xing, is a foundational and advanced course on graphical models. The curriculum covers the basics of graphical models, their integration with neural networks, applications in reinforcement learning, and non-parametric methods, making it a highly rigorous and comprehensive course.
For students with a solid background in machine learning, deep learning, and reinforcement learning, this course provides a deep dive into the theoretical and practical aspects of probabilistic graphical models. The extensive resources available on the course website make it an invaluable learning tool for anyone looking to master this complex and rapidly evolving field.
This course offers a rigorous blend of classical learning theory and the latest developments in deep learning theory, making it exceptionally challenging and comprehensive. Previously taught by Percy Liang, the course is now led by Tengyu Ma, ensuring a high level of expertise and insight into the theoretical aspects of machine learning.
The curriculum is designed for students with a solid foundation in machine learning, deep learning, and statistics, aiming to deepen their understanding of the underlying theoretical principles in these fields. This course is an excellent choice for anyone looking to gain a thorough understanding of both the traditional and contemporary theoretical approaches in machine learning.
\"Minimizing Expectations\" is an advanced Ph.D. level research course, focusing on the interplay between inference and control. The course is taught by Chris Maddison, a founding member of AlphaGo and a NeurIPS 2014 best paper awardee.
This course is notably challenging and is designed for students who have a strong background in Bayesian Inference and Reinforcement Learning. The curriculum explores deep theoretical concepts and their practical applications in the fields of machine learning and artificial intelligence.
Chris Maddison's expertise and his significant contributions to the field, particularly in the development of AlphaGo, make this course highly prestigious and insightful for Ph.D. students and researchers looking to deepen their understanding of inference and control in advanced machine learning contexts. The course website provides valuable resources for anyone interested in this specialized area of study.
\"Deep Generative Models\" is a Ph.D. level seminar course at Columbia University, taught by John Cunningham. This course is structured around weekly paper presentations and discussions, focusing on deep generative models, which represent the intersection of graphical models and neural networks and are one of the most important directions in modern machine learning.
The course is designed to explore the latest advancements and theoretical foundations in deep generative models. Participants engage in in-depth discussions about current research papers, fostering a deep understanding of the subject matter. This format not only helps students keep abreast of the latest developments in this rapidly evolving field but also sharpens their critical thinking and research skills.
Given the advanced nature of the course, it is ideal for Ph.D. students and researchers who have a solid foundation in machine learning, deep learning, and graphical models, and are looking to delve into the cutting-edge of deep generative models. The course website provides a valuable resource for accessing the curriculum and related materials.
This learning path is suitable for students who have already learned the basics of machine learning (ML, NLP, CV, RL), such as senior undergraduates or junior graduate students, and have published at least one paper in top conferences (NeurIPS, ICML, ICLR, ACL, EMNLP, NAACL, CVPR, ICCV) and are interested in pursuing a research path in machine learning.
The goal of this path is to lay the theoretical groundwork for understanding and publishing papers at top machine learning conferences, especially in the track of Probabilistic Methods.
There can be multiple advanced learning paths in machine learning, and this one represents the best path as understood by the author Yao Fu, focusing on probabilistic modeling methods under the Bayesian school and involving interdisciplinary knowledge.
W&J: Graphical Models, Exponential Families, and Variational Inference by Martin Wainwright and Michael Jordan
Theory of Point Estimation by E. L. Lehmann and George Casella
"},{"location":"en/%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%E8%BF%9B%E9%98%B6/roadmap/#reading-guidelines","title":"Reading Guidelines","text":""},{"location":"en/%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%E8%BF%9B%E9%98%B6/roadmap/#how-to-approach","title":"How to Approach","text":"
Essential textbooks are a must-read.
Reference books are like dictionaries: consult them when encountering unfamiliar concepts (instead of Wikipedia).
Advanced books should be approached after completing the essential textbooks, which should be read multiple times for thorough understanding.
Contrastive-comparative reading is crucial: open two books on the same topic, compare similarities, differences, and connections.
Recall previously read papers during reading and compare them with textbook content.
Start with AoS Chapter 6: Models, Statistical Inference, and Learning as a basic introduction.
Read PRML Chapters 10 and 11:
Chapter 10 covers Variational Inference, and Chapter 11 covers MCMC, the two main routes for Bayesian inference.
Consult earlier chapters in PRML or MLAPP for any unclear terms.
AoS Chapter 8 (Parametric Inference) and Chapter 11 (Bayesian Inference) can also serve as references. Compare these chapters with the relevant PRML chapters.
After PRML Chapters 10 and 11, proceed to AoS Chapter 24 (Simulation Methods) and compare it with PRML Chapter 11, focusing on MCMC.
If foundational concepts are still unclear, review PRML Chapter 3 and compare it with AoS Chapter 11.
Read PRML Chapter 13 (skip Chapter 12) and compare it with MLAPP Chapters 17 and 18, focusing on HMM and LDS.
After completing PRML Chapter 13, move on to Chapter 8 (Graphical Models).
Cross-reference these topics with CMU 10-708 PGM course materials.
By this point, you should have a grasp of:
Basic definitions of probabilistic models
Exact inference - Sum-Product
Approximate inference - MCMC
Approximate inference - VI
Afterward, you can proceed to more advanced topics.
CS224n is an introductory course in Natural Language Processing (NLP) offered by Stanford and led by renowned NLP expert Chris Manning, the creator of the word2vec algorithm. The course covers core concepts in the field of NLP, including word embeddings, RNNs, LSTMs, Seq2Seq models, machine translation, attention mechanisms, Transformers, and more.
The course consists of 5 progressively challenging programming assignments covering word vectors, the word2vec algorithm, dependency parsing, machine translation, and fine-tuning a Transformer.
The final project involves training a Question Answering (QA) model on the well-known SQuAD dataset. Some students' final projects have even led to publications in top conferences.
Stanford's Introduction to Graph Neural Networks course, I haven't taken this course, but many friends who are focusing on GNN have recommended it to me, so I guess Stanford's course quality is still guaranteed as always. The instructor of this course is very young and handsome :)
Yet another popular online course offered by Andrew Ng on Coursera. It has attracted many learners and can be seen as the Bible of fundamental deep learning. The course provides well-covered projects, with clear but thorough instructions. The course starts from basic neural networks, to CNN, RNN, and all the way to Transformer, which has been a hot topic these days. After learning this course, you'll be equipped with the basic knowledge and skills for deep learning, and you may want to participate in Kaggle competitions to practice your skills with real tasks.
Stanford's CV introductory class, led by the giant of the computer field, Fei-Fei Li (the research team of the epoch-making famous dataset ImageNet in CV field), but its content is relatively basic and friendly, if you have taken CS230, you can directly start the Project as practice.
The CS285 course, currently taught by Professor Sergey Levine, covers various aspects of deep reinforcement learning. It is suitable for students with a foundational understanding of machine learning, including concepts such as Markov Decision Processes (MDPs). The course involves a substantial amount of mathematical formulas, so a reasonable mathematical background is recommended. Additionally, the professor regularly updates the course content and assignments to reflect the latest research developments, making it a dynamic learning experience.
For course content access, as of the Fall 2022 semester, the teaching format involves pre-recorded videos for students to watch before class. The live sessions mainly focus on Q&A, where the professor discusses selected topics from the videos and answers students' questions. Therefore, the provided course video links already include all the content. The assignments consist of five programming projects, each involving the implementation and comparison of classical models. Occasionally, assignments may also include the reproduction of recent models. The final submission typically includes a report. Given that assignments provide a framework and often involve code completion based on hints, the difficulty level is not excessively high.
In summary, this course is suitable for beginners entering the field of deep reinforcement learning. Although the difficulty increases as the course progresses, it offers a rewarding learning experience.
The University of Michigan's Computer Vision course is of exceptionally high quality, with its videos and assignments covering an extensive range of topics.
The assignments gradually increase in difficulty and cover all stages of mainstream CV model development, making this an excellent introductory course for Computer Vision.
In each assignment, you'll build and train models or frameworks mentioned in the lectures, following the provided handouts.
You don't need any prior experience with deep learning frameworks.
The course will teach you from scratch how to use Pytorch in the early assignments, and it can subsequently serve as a reference book for you.
As each assignment deals with different themes, you'll not only gain a first-hand understanding of the development of mainstream CV models through these progressive assignments but also appreciate the impacts of different models and training methods on final performance and accuracy.
Moreover, you'll get hands-on experience in implementing them.
In Assignment 1 (A1), you'll learn how to use Pytorch and Google Colab.
In Assignment 2 (A2), you will build a Linear Classifier and a two-layer neural network. Finally, you'll have the opportunity to work with the MNIST dataset, on which you will train and evaluate your neural network.
In Assignment 3 (A3), you'll encounter the classic Convolutional Neural Network (CNN) and experience the power of convolutional neural networks.
In Assignment 4 (A4), you'll have the opportunity to build an object detection model from scratch, following the handout to implement a One-Stage Detector and a Two-Stage Detector from two research papers.
By Assignment 5 (A5), you'll transition from CNN to RNN. You'll have the opportunity to build two different attention-based models, RNNs (Vanilla RNN & LSTM), and the famous Transformer.
In the final assignment (A6), you'll get a chance to implement two more advanced models, VAE and GAN, and apply them to the MNIST dataset. Finally, you'll implement two very cool features: network visualization and style transfer.
Beyond the assignments, you can also implement a Mini-Project, building a complete deep learning pipeline. You can refer to the course homepage for specifics.
All the resources involved in the course, such as lectures, notes, and assignments, are open source.
The only downside is that the Autograder is only available to students enrolled at the University of Michigan.
However, given that the correctness of the implementation and the expected results can already be confirmed in the provided *.ipynb (i.e., the Handout), I personally feel that the absence of Autograder doesn't affect the learning process.
It's worth mentioning that the main lecturer for this course, Justin Johnson, is a Ph.D. graduate of Fei-Fei Li and currently an Assistant Professor at the University of Michigan.
The open-source 2017 version of Stanford's CS231N was taught by Justin Johnson.
Because CS231N was mainly developed by Justin Johnson and Andrej Karpathy, this course also adopts some materials from CS231N.
Therefore, students who have studied CS231N might find some materials in this course familiar.
Lastly, I recommend every student enrolled in this course to watch the lectures on YouTube. Justin Johnson's teaching style and content are very clear and easy to understand, making them a fantastic resource.
@Michael-Jetson The 200,000 to 300,000 words of notes I have taken (and did not include homework, etc.) can be used as a reference:Michael-Jetson/ML_DL_CV_with_pytorch
"},{"location":"en/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/LHY/","title":"National Taiwan University: Machine Learning by Hung-yi Lee","text":""},{"location":"en/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/LHY/#course-overview","title":"Course Overview","text":"
Professor Hung-yi Lee, a professor at National Taiwan University, is known for his humorous and engaging teaching style. He often incorporates fun elements like Pok\u00e9mon into his slides, making the learning experience enjoyable.
Although labeled as a machine learning course, the breadth of topics covered is impressive. The course includes a total of 15 labs covering Regression, Classification, CNN, Self-Attention, Transformer, GAN, BERT, Anomaly Detection, Explainable AI, Attack, Adaptation, RL, Compression, Life-Long Learning, and Meta Learning. This wide coverage allows students to gain insights into various domains of deep learning, helping them choose areas for further in-depth study.
Don't be overly concerned about the difficulty of the assignments. All assignments come with example code from teaching assistants, guiding students through data processing, model building, and more. Students are required to make modifications based on the provided code. This presents an excellent opportunity to learn from high-quality code, and the assignments serve as valuable resources for those looking to breeze through course projects.
This introductory class for freshmen majoring in electronics at UC Berkeley teaches the fundamentals of circuitry. Through a variety of hands-on labs, students will experience collecting information from the environment through sensors and analyzing it to make predictions. Due to the COVID-19, all labs have remote online version, making them ideal for self-study.
The highlight of this course is the six exciting labs that will allow you to use signals and systems theory to solve practical problems in Python. For example, in lab3 you will implement the FFT algorithm and compare the performance with Numpy's official implementation. In lab4 you will infer the heart rate by processing the video of fingers. Lab5 is the most awesome one where you will reduce the noise in the photos taken by the Hubble telescope to recover the brilliant and bright starry sky. In lab6 you will build a feedback system to stabilize the pole on the cart.
Computer Security course from UC Berkeley, devided into 5 parts:
Security principles: how to design a secure system
Memory safety: buffer overflow attack
Cryptography: symmetric encryption, asymmetric encryption, MAC, digital signature .........
Web: SQL-injection, XSS, XSRF .......
Networking: attacks for each layer
The most impressive part to me is Project2, which requires you to design and implement a secure file sharing system in Go. It took me three full days to complete this extremely difficult project, with over 3 thousand lines of code. Such an intensive development experience can greatly enhance your ability to design and implement a secure system.
In 2020 summer semester, the lecture recordings are posted publicly, which can be found in the links below.
The course is mainly based on challenges, supplemented by lectures and reading materials. The challenges are developed in the form of CTF, and the difficulty increases in order.
For hackers with weak foundations, getting stuck is a normal phenomenon. If you encounter difficulties in solving the problem, you can seek help from the Discord Server given in the Chat column on the homepage.
Lectures on YouTube: https://youtube.com/pwncollege
Live Broadcasts on Twitch: https://twitch.tv/pwncollege
Chat on Discord: https://pwn.college/discord
Open Source on GitHub: https://github.com/pwncollege
Contact us via Email: pwn-college@asu.edu
In addition, due to an important factor in evaluating ASU students' course grades, the course does not encourage uploading problem-solving ideas, except for the first two challenges of each module.
Like CSE365, the course is also based on challenges, supplemented by lectures and reading materials. The challenges are developed in the form of CTF, and the difficulty increases in order.
The quality of the exercises is excellent, but some modules are quite difficult, especially the parts involving the kernel. Sometimes you'll spend a whole day struggling at one challenge with no progress. If you encounter difficulties in solving the problem, you can seek help from the Discord Server given in the Chat column on the homepage.
Lectures on YouTube: https://youtube.com/pwncollege
Live Broadcasts on Twitch: https://twitch.tv/pwncollege
Chat on Discord: https://pwn.college/discord
Open Source on GitHub: https://github.com/pwncollege
Contact us via Email: pwn-college@asu.edu
In addition, due to an important factor in evaluating ASU students' course grades, the course does not encourage uploading problem-solving ideas, except for the first two challenges of each module and challenge 16 in the reversing module.
Prerequisites: discrete mathematics, basic programming, basic knowledge of computer systems
Programming Languages: Python3
Difficulty: \ud83c\udf1f\ud83c\udf1f\ud83c\udf1f
Class Hour: 50 hours
MIT6.1600 is the undergraduate course on computer system security at MIT. The course is divided into five modules: authentication, transport security, platform security, software security, and human/end-user security. The organization of the course is quite clear: the authentication module focuses on authentication security, that is, how to prove that the \"you\" in the computer world is indeed \"you\". It then moves to the topic on communication security, such as data encryption and decryption, key exchange, etc. However, transport is only one aspect; the code ultimately needs to run on a device, which involves the security of the platform on which the code runs and even the software code itself. The course will also cover some content about privacy security, discussing group information security from a sociological perspective.
After completing this course, you will master many important fundamental concepts of computer security, such as public and private key encryption algorithms, hash algorithms, digital signatures, key exchange algorithms, and more. Besides the mathematics and theorem proofs, the course also uses the theoretical knowledge to explain many real-world security vulnerabilities, giving you a more concrete understanding of these security concepts. Additionally, there are six interesting labs that allow you to exploit many vulnerabilities through programming, deepening your understanding of the knowledge in practice, which I personally find quite interesting.
This is MIT's Computer Systems Security course. Lectures cover threat models, attacks that compromise security, and techniques for achieving security, based on recent research papers. Topics include operating system (OS) security, capabilities, information flow control, language security, network protocols, hardware security, and security in web applications.
Assignments include labs that involve implementing and compromising a secure web server and web application, and a group final project:
Lab 1: you will explore the zoobar web application, and use buffer overflow attacks to break its security properties.
Lab 2: you will improve the zoobar web application by using privilege separation, so that if one component is compromised, the adversary doesn't get control over the whole web application.
Lab 3: you will build a program analysis tool based on symbolic execution to find bugs in Python code such as the zoobar web application.
Lab 4: you will improve the zoobar application against browser attacks.
I mainly did Lab 3 in this course. Lab 3 requires you to traverse all the branches of a program by concolic execution, and it is not difficult to do once you understand the idea of symbolic execution. This Lab visually demonstrates the use of symbolic execution.
In the Final Project, you will build a remote file system, SecFS, that provides both confidentiality and integrity in the face of a completely untrusted server. Reference Papers: SUNDR
Syracuse University's cybersecurity course, supported by a $1.3 million grant from the NSF, has developed hands-on practical lab exercises known as SEED Labs. This course emphasizes both theoretical instruction and practical hands-on experience, providing detailed open-source lecture materials, video tutorials, textbooks printed in multiple languages, and ready-to-use attack and defense environments based on virtual machines and Docker. Currently, 1,050 research institutions worldwide are using this project.
It covers a wide range of topics in the field of computer and information security, including software security, network security, web security, operating system security, and mobile application security.
Assignments: There are more than 40 labs in this course, the lab environment can be built with customized virtual machines and docker provided by the course in quickly set up , and detailed principle explanations and experimental guidance are also provided. Take Buffer Overflow Experiment as an example. This experiment belongs to Software Security Topic, here is its Experimental Guide, here is its corresponding Textbook Content
This is an introductory course on Linux from UCB, which I find more systematic and clearer than MIT's similarly aimed open course, Missing Semester. This is the main reason I recommend it. While Missing Semester seems more like a course for filling gaps for students who have started programming but haven't systematically used these tools, DeCal is more suitable for absolute beginners. The twelve-week course covers Linux basics, shell programming (including tmux and vim), package management, services, basic computer networks, network services, security (key management), Git, Docker, Kubernetes, Puppet, and CUDA. It's ideal for newcomers to understand and get started with the Linux environment.
A slight drawback is that some course assignments require operations on remote servers, like exercises on ssh, which need UCB internal account access. However, most assignments can be practiced by setting up a virtual machine and using tools like Xshell or directly using a Linux desktop version. After completing the full course and assignments, you should have a basic understanding of Linux.
To compensate for the inability to use remote servers and to familiarize with the Linux command line, I recommend bandit. Bandit is a Wargame from OverTheWire, providing a free practice range for CTF enthusiasts. The first 15 levels of bandit are basic Linux operations without any CTF knowledge. These exercises perfectly supplement the parts of DeCal that are inaccessible to external students (mainly remote connections, file permissions, etc.).
Course Videos: Available on the official course website, Bilibili has an incomplete translation that only includes the first part.
Course Textbook: No specified textbook, but each week's labs contain enough reading material for in-depth study.
Course Assignments: Available on the official course website.
"},{"location":"en/%E7%BC%96%E7%A8%8B%E5%85%A5%E9%97%A8/MIT-Missing-Semester/","title":"MIT: The Missing Semester of Your CS Education","text":""},{"location":"en/%E7%BC%96%E7%A8%8B%E5%85%A5%E9%97%A8/MIT-Missing-Semester/#descriptions","title":"Descriptions","text":"
Offered by: MIT
Prerequisites: None
Programming Languages: Shell
Difficulty: \ud83c\udf1f\ud83c\udf1f
Class Hour: 10 hours
Just as the course name indicated, this course will teach the missing things in the university courses. It will cover shell programming, git, vim editor, tmux, ssh, sed, awk and even how to beautify your terminal. Trust me, this will be your first step to become a hacker!
This course has been voted the most popular public course by Harvard students for many years. Professor Malan is very passionate in class. I still remember the scene where he tears up the Yellow pages to explain the dichotomy method. Since this is a university-wide public course, the contents are pretty friendly to beginners and even if you already have some programming experience, all the programming assignments are quite exciting and worth a try.
This is an excellent course which I benefited a lot from.
The course teaches fundamental concepts such as frame, stack memory, heap memory, etc.
There are great programming assignments to deepen and reinforce your understanding of the hardest part in C, like pointers.
The course provides excellent practice in GDB, Valgrind, and the assignments will cover some basic Git exercises.
The course instructor recommends using Emacs for homework, so it's a good opportunity to learn Emacs. If you already know how to use Vim, I suggest you use Evil. This way you don't lose the editing capabilities of Vim, and you get to experience the power of Emacs. Having both Emacs and Vim in your kit will increase your efficiency considerably. Emacs' org-mode, smooth integration of GDB, etc., are convenient for developers.
It may require payment, but I think it's worth it.
Although this is an introductory course, it has both breadth and depth.
All the resources and assignments used by in this course are maintained in Duke Coursera Intro C. Several assignments have not been completed so far for time reasons.
Prerequisites: basic knowledge about imperative programming\uff0csuch as C, Python, Java
Programming Languages: OCaml
Difficulty: \ud83c\udf1f\ud83c\udf1f\ud83c\udf1f
Class Hour: 40 hours
"},{"location":"en/%E7%BC%96%E7%A8%8B%E5%85%A5%E9%97%A8/Functional/CS3110/#evaluation-for-course-modern-sicp","title":"Evaluation for course: Modern SICP","text":"
If the best course for getting started with programming is SICP, then following it is CS3110.
If you are unfamiliar with what a functional programming language is, or have only heard the term, then this course, just like its name, will allow you to experience what is meant by correctness, efficiency, and elegance.
CS3110 is not only limited to functional programming, but it also combines theory and practical applications extensively. The course content goes further, covering OCaml language fundamentals, data structures and algorithms, test development, formal proofs, language feature implementation, and many more topics. Moreover, these contents are not isolated; instead, they are progressive and complementary, making it highly worth studying.
The main instructor, Michael Ryan Clarkson, with years of immersion in programming, employs simple language, clear explanations, and dissects the content with precision. The course videos are even useful for improving listening skills, and understanding is effortless with the aid of English subtitles.
"},{"location":"en/%E7%BC%96%E7%A8%8B%E5%85%A5%E9%97%A8/Functional/CS3110/#a-brief-history-of-cs-3110","title":"A Brief History of CS 3110","text":"
CS3110 is a course meticulously crafted by Cornell University over more than 20 years. Initially inspired by MIT6.001 SICP, it has been enriched with stricter methodologies and materials, encompassing functional programming, environment modeling, data structures, algorithms, and language implementation. In 2008, its formal title changed to CS3110, transitioning to the OCaml language. In the fall of 2018, the process of writing the course textbook began. The current course instructor announced course videos on YouTube in 2021.
Recordings on youtube: https://www.youtube.com/playlist?list=PLre5AT9JnKShBOPeuiD9b-I4XROIJhkIU
Recordings on Bilibili: https://www.bilibili.com/video/BV1dv4y127Ui/
Textbook\uff1ahttps://cs3110.github.io/textbook
Assignments\uff1aIn the textbook, exercises are optional, with difficulty ranging from 1 to 4 stars, noting that the difficulty between 3-star and 4-star exercises varies significantly.
Functional programming is increasingly being integrated into modern programming languages. Streams in Java, Promises in JavaScript, and Record & Tuple in the draft phase of ECMAScript... When I was learning these things, I always felt like I was memorizing the behaviours of their API, and although I was able to write some programs using them, I never felt like I had mastered them. Why do they exist? Why are they like that? What is the idea behind their design? Learning functional programming will give you the answer.
Its core ingredient is functional programming. Just like Java is probably the default choice for teaching object-oriented programming.
This course will teach just enough Haskell syntax, library functions, and a small number of tools to explain the core program semantics and the core idea of functional programming. This will save you time not getting bogged down in the details of the language and its ecology, which I think is the biggest advantage of the course.
Topics covered in the course:
Pure Function
Lazy Evaluation
Strongly Typed
Type Inferred
Curry
Monoid / Functor / Monad / Applicative
If you have some programming experience, part 1 of the course is very easy. Most of the difficulties lie in part 2, after chap 13. Its exercises are great, which can give you a feeling of doing exercise of CS61A. There are enough hints in the comments and the solutions will be given to you after submission, and you can ask questions or discuss them with others in the official Telegram community.
All the resources and assignments used by @showtheunli in this course are maintained in showthesunli/haskell-mooc - GitHub. (It is highly discouraged to refer to other people's implementations when working on assignments.)
MIT's Java introductory course is suitable for beginners with no programming background. Each session consists of one hour of lecture (knowledge explanation) and one hour of lab (code practice), with a total of seven sessions. Although it's a fourteen-hour course, the learning process is fast, and you can complete it in about a day. It feels quite manageable for beginners.
The course content includes:
Rapid introduction to fundamental concepts needed for Java: the Java compilation principle, the classic \"Hello world\" code, and the eight primitive types in the first session.
How to maintain good code style: emphasizing naming conventions, indentation, and proper use of spaces in the third session.
Debugging techniques: Using Eclipse warnings, assertions in the sixth session, and handling exceptions in the seventh session.
The assignments in the lab are not very difficult, and many of them are discussed in the following lecture after each lab session. The key point to note is that coding is a skill that requires practical experience. For beginners, the most important aspect of learning to code is to practice and write code regularly, whether in lectures or lab sessions.
For those who want to advance after completing this course, you can consider studying MIT 6.005/6.031.
One of the CS50 families, taught by David J. Malan. You'll learn how to program in Python and \"Pythonic\" ways to deal with everything. The course also introduces libraries, code testing, and handling exceptions.
No programming experiences are assumed. So it may be appropriate for anyone who wants to learn Python.
This is the first course in the Berkeley CS61 series, and my introductory course to Python.
The CS61 series is composed of introductory courses to the CS major at Berkeley, where
CS61A: Emphasizes abstraction and equips students to use programs to solve real-world problems without focusing on the underlying hardware details.
CS61B: Focuses on algorithms and data structures and the construction of large-scale programs, where students combine knowledge of algorithms and data structures with the Java language to build large-scale projects at the thousand-line code level (such as a simple Google Maps, a two-dimensional version of Minecraft).
CS61C: Focusing on computer architecture, students will understand how high-level languages (e.g. C) are converted step-by-step into machine-understandable bit strings and executed on CPUs. Students will learn about the RISC-V architecture and implement a CPU on their own by using Logism.
CS61B and CS61C are both included in this guidebook.
Going back to CS61A, you will note that this is not just a programming language class, but goes deeper into the principles of program construction and operation. Finally you will implement an interpreter for Scheme in Python in Project 4. In addition, abstraction will be a major theme in this class, as you will learn about functional programming, data abstraction, object orientation, etc. to make your code more readable and modular. Of course, learning a programming language is also a big part of this course. You will master three programming languages, Python, Scheme, and SQL, and in learning and comparing them, you will be equiped with the ability to quickly master a new programming language.
Note: If you have no prior programming experience at all, getting started with CS61A requires a relatively high level of learning ability and self-discipline. To avoid the frustration of a struggling experience, you may choose a more friendly introductory programming course at first. For example, CS10 at Berkeley or CS50 at Harvard are both good choices.
Prerequisites: basic knowledge about programming and computer system
Programming Languages: Rust
Difficulty: \ud83c\udf1f\ud83c\udf1f\ud83c\udf1f
Class Hour: 30 hours
In this course, you will learn a fantastic language, Rust.
If you have studied C and have some knowledge of systems programming, you should have heard about memory leaks and the danger of pointers, but C's high efficiency makes it impossible to be replaced by other higher-level languages with garbage collection such as Java in system-level programming. Whereas Rust aims to make up for C's lack of security while having competitive efficiency. Therefore, Rust was designed from a system programmer's point of view. By learning Rust, you will learn the principles to write safer and more elegant system code (e.g., operating systems, etc.).
The latter part of this course focuses on the topic of concurrency, where you will systematically learn multi-processing, multi-threading, event-driven programming, and several other techniques. In the second project, you will compare the pros and cons of each method.
Personally, I find the concept of \"futures\" in Rust fascinating and elegant, and mastering this idea will help you in your following systems-related courses. In addition, Tsinghua University's operating system lab, rCore is based on Rust. You can see the documentation for more details.
Assignments: 6 Labs, 2 Projects, the course website has specific requirements. The projects are quite interesting where you will Implement a GDB-like debugger and a load balancer in Rust.
All the resources and assignments used by @PKUFlyingPig in this course are maintained in PKUFlyingPig/CS110L - GitHub.
Due to the rapid evolution of Rust, the libraries used in the 2020 version of the course project are obsolete, so @fung-hwang tried to adapt these libraries (in November 2022). His adaptation advice and completed assignments are maintained in fung-hwang/CS110L-2020spr - GitHub. It is possible that Rust and these libraries will have changed again when you start to learn CS110L, but you can still refer to this repo for help.
CS431 is a course about concurrent programming, mainly using Rust. The course consists of two parts: theory and practice. The theory part focuses on building a programming model under concurrent situations, while the practice part mainly focuses on understanding the implementation principles of locks and lock-free data structures in Rust-related libraries.
This course is accompanied by a series of assignments with small code size but not simple to consolidate your understanding of concurrent programming, from the design of concurrent safe cache and linked list based on locks, to lock-free hash table and the famous hazard pointer. Like many high-quality courses, these assignments are of high quality and come with detailed local tests, which are suitable for self-study.
This course is much more in-depth than I expected. The knowledge I know about spin locks and mutex locks is the most basic in this course, while the introduction of promising semantics, memory model and lock-free data structures gives me a deeper understanding of concurrency and Rust.
This is an accidentally discovered C++ course. The quality of the homework assignments is outstanding, with each being independently structured and simple, complemented by comprehensive unit tests, making it highly suitable for learning C++ programming. The course includes a total of 7 homework assignments, as follows:
Implement a Matrix class and related functions.
Implement a program that simulates the operation of a cryptocurrency client/server.
Implement a Binary Search Tree (BST).
Implement SharedPtr and UniquePtr smart pointers in C++.
Use inheritance and polymorphism to implement multiple classes.
Solve 4 problems using the STL library.
There's a Python project, for those interested.
The course homepage was not found, but the source code for the homework (named AP1400-2-HW) can be found on GitHub.
CS106B/X are advanced programming courses at Stanford. CS106X is more difficult and in-depth than CS106B, but the main content is similar. Based on programming assignments in C++ language, students will develop the ability to solve real-world problems through programming abstraction. It also covers some simple data structures and algorithms, but is generally not as systematic as a specialized data structures course.
Some very basic but practical data structures and algorithms: collections, ADT, recursion, BFS, DFS, backtracking, sorting, hash, pointer, linked list, BST, OOP, pass by value, pass by reference, stack allocation, heap allocation, memory management. Additionally, some very useful techniques, such as how to use a debugger to troubleshoot, and how to escape from an initialized maze by reading the content in the debugger in assignment 8.
Like CS61A, code frameworks and test programs are provided. Although not as detailed as the CS61A tests, the assignments also require you to add your own test cases. Each assignment comes with a detailed document that guides you step-by-step to achieve each milestone. In the end, you can observe the results of your data structures and algorithm implementations in the GUI provided by the starter code, which is very rewarding. Each assignment corresponds to very interesting and practical cases, such as the final task of implementing Huffman encoding to compress and decompress files.
@Andy-xiaokang All the resources and assignment implementations used in studying this course are compiled in Andy-xiaokang/CS106B - GitHub about the incompatible libray you can refer to readme and I recommend the video youtube spring 2015
"},{"location":"en/%E7%BC%96%E7%A8%8B%E5%85%A5%E9%97%A8/cpp/CS106L/","title":"CS106L: Stanford C++ Programming","text":""},{"location":"en/%E7%BC%96%E7%A8%8B%E5%85%A5%E9%97%A8/cpp/CS106L/#descriptions","title":"Descriptions","text":"
Offered by: Stanford
Prerequisites: better if you are already proficient in a programming language
Programming Languages: C++
Difficulty: \ud83c\udf1f\ud83c\udf1f\ud83c\udf1f
Class Hour: 20 hours
I've been writing C++ code since freshman year, and it wasn't until I finished this class that I realized the C++ code I was writing was probably just C + cin/cout.
This class will dive into a lot of standard C++ features and syntax that will allow you to write quality C++ code. Techniques such as auto binding, uniform initialization, lambda function, move semantics, RAII, etc. have been used repeatedly in my coding career since then and are very useful.
It is worth mentioning that in this class, you will implement a HashMap (similar to unordered_map in STL), which almost ties the whole course together and is a great test of coding skills. Especially after the implementation of iterator, I started to understand why Linus is so sarcastic about C/C++, because it is really hard to write correctly.
In short, the course is not difficult but very informative which requires you to consolidate repeatedly in later practice. The reason why Stanford offers a single C++ programming class is that many of the subsequent CS courses' projects are based on C++. For example, CS144 Computer Networks and CS143 Compilers. Both of these courses are included in this book.
CS242 is a course about programming languages (PL), but it is not a pure theoretical course in the traditional sense. This course first introduces classic PL theories such as Lambda calculus and type system, then uses the ideas and actual programming languages of system programming to motivate students to understand these theories, and shows how they help developers avoid various errors in actual programming.
The instructor Will Crichton also wrote his course design ideas into a paper From Theory to Systems: A Grounded Approach to Programming Language Education, which elaborates this teaching route from theory to systems.
We help readers understand the specific content of this course by simply introducing each assignment:
Formalization and proof of JSON
Classic Lambda calculus in PL
Introduction to functional programming using OCaml
Use OCaml to implement a type checker and interpreter for a functional language, which is also a classic assignment in PL
Theory and practice of WebAssembly
Linear Type and Rust's ownership mechanism
Rust's asynchronous programming basics
Design state machines and implement session-typed TCP libraries using Rust's type system
The final assignment has four options:
Theorem proving in Lean
Read-Log-Update in Rust
Verified filesystems in F-Star
Deep learning framework in OCaml from a PL perspective
These assignments cover a wide range of knowledge, from the classic PL theory and practice to the impact of programming languages such as Rust on programming and system design, and finally the distinctive projects. Almost all programming assignments have detailed local tests, especially the deep learning framework in the final project has more than 200 tests, which is suitable for self-study.
The first few assignments are more about PL theory, and the later assignments are more about system programming. If you think that the course content and assignments in the first few times are too theoretical, you can focus on the assignment of implementing the interpreter using OCaml, which can not only help you have a deeper understanding of the previous theory, but also let you practice the type checking and interpretation of a functional language.
The later assignments tend to use theory to guide system programming and design, especially Rust and its unique ownership mechanism and type system. Although we often have to fight with the compiler, this also just shows the significance of type systems and theories for programming and design.
I personally feel that the assignments are difficult, but the gains are great. When the programming practice in the later assignments intersects with the theoretical knowledge learned before, there will be a pleasant feeling of sudden enlightenment. If you encounter difficulties in completing the assignments, this is normal. Please calm down and think carefully, or read the assignment guide again.
Prerequisites: elementary Discrete Mathematics, including logic and proof methodology, basic functional programming
Programming Languages: OCaml (ML)
Difficulty: \ud83c\udf1f\ud83c\udf1f\ud83c\udf1f
Class Hour: 20 to 30 hours (12 hours of lecture)
This course offers a structural, operational approach to programming language semantics. It provides a very beginner-friendly but mathematically rigorous introduction to the constructs and specification declaration of programming languages, in the context of actually defining and designing a language. It is also one of the few PLT courses that offers publicly available videos.
The course covers semantics topics ranging from operational and denotational semantics. The course starts with introducing the basic operational semantics of a simple imperative language defined by BNF, and gradually coming to introducing formal type systems, using mathematical induction (especially structural induction) to build rule-based induction proofs. It then comes to how we manipulate data under a functional programming perspective and introduces subtyping and handling of functions. Finally it comes to the discussion of semantics equivalence, congruence property and semantics under concurrency.
This course was taught to 2nd year undergraduate students, however building up some very important concepts. It would be a pivotal capstone for further studies on type theory, category theory, hoare logic and model checking.
Prerequisite: Data Structures and Algorithms, familiar with at least one programming language
Programming Languages: Java
Difficulty: \ud83c\udf1f\ud83c\udf1f\ud83c\udf1f
Learning Hours: 60 hours
Software Analysis is a course jointly offered by Yue Li and Tian Tan of Nanjing University. It mainly introduces program analysis, which refers to the theory and practice of static analysis. The idea of static analysis is to obtain approximate answers about specific properties of the program without running it. This course starts with the abstract syntax tree, control flow graph and intermediate representation, then introduces the theory and practice of data flow analysis and pointer analysis, and finally introduces several advanced topics, such as IFDS.
In my opinion, there are two reasons why this course is worth learning:
Teaching. Program analysis is generally not easy to get started, but the two teachers are particularly meticulous in their lectures, and they will also guide you step by step through the process of an algorithm. Personally, I think that as long as you listen carefully in class, there is no problem that you can't understand.
Assignments. The assignments are based on the Java program analysis framework Tai-e created by the teachers. The eight assignments cover a variety of static analysis techniques, including compiler optimization (liveness analysis, constant propagation, dead code detection), basic program analysis (program call graph construction, non/context-sensitive pointer analysis), and the application of program analysis in software security (taint analysis). The course also provides an online evaluation system available to everyone, which is suitable for self-study.
The assignments are mainly to implement the pseudo-code algorithms in class, so as to better help you understand the knowledge taught in class. I feel that the difficulty is not particularly high, especially suitable for completing the corresponding experiments after class to test your mastery of the knowledge taught in class. However, it is still challenging to pass all the test cases of each assignment.
Compared with the Software Analysis course of Nanjing University, this course covers more comprehensive theoretical and practical content of program analysis, and is more difficult. My main way of learning this course is to listen to the course. Prof. Xiong's lectures are very interesting. In addition to the theoretical content, he occasionally tells some academic related stories :)
The course project of this experiment is to implement a pointer analysis system on Java and a program synthesis tool, which is also a very interesting practice.
This course aims to impart the principles of compiler construction for programming languages to students. The instructors have designed a \u201cCOOL language\u201d, namely Classroom-Object-Oriented-Language. By study and practice, you will design and implement a compiler, which can translate the human-readable COOL language into machine-readable MIPS assembly which can be run on the SPIM emulator.
Following the Dragon Book, the theoretical part of the course covers lexical analysis, syntax analysis, semantics analysis, runtime environments, register allocation, optimization, and code generation. The practical part, accordingly, is divided into 4 steps: 3 for the frontend and 1 for the backend. The difficulty is considered gradual, increasing at a proper rate. Should you have enough time and interest even after completing all the required work, there\u2019s a huge room left for you to do optimization.
Textbook: Compilers: Principles, Techniques and Tools (Dragon Book)
Assignments: 5 written assignments + 5 programming labs
"},{"location":"en/%E7%BC%96%E8%AF%91%E5%8E%9F%E7%90%86/CS143/#collection-of-course-resources","title":"Collection of Course Resources","text":"
@skyzluo has been maintaining a repo of course resources used and reference implementations of programming labs: skyzluo/CS143-Compilers-Stanford - GitHub.
This course provides a compiler framework code called KECC(KAIST Educational C Compiler) written in Rust, based on which students build some core parts of the compiler, include AST print, SSA-based IR generation, IR optimization and RISC-V assembly generation. Compared to other compiler courses, this course has the following main characteristics:
The course focuses on the real C language rather than a custom toy language, and uses C language fuzzing tools(Csmith) for testing.
This course emphasizes on practicality. It does not talk much about the theory of compiler frontend and the assignments start with the traversal of AST so you do not need to build the frontend yourself. The course mainly focuses on IR design, generation and optimization, as well as RISC-V assembly code generation. This course is also helpful for understanding and learning LLVM.
The course comes with accompanying videos that provide detailed code tours, which is beginner-friendly.
The compiler principles course at Nanjing University utilizes the popular ANTLR (ANother Tool for Language Recognition) v4 programming language parsing and code generation tool to aid in teaching. This tool allows users to focus on designing lexical or syntactic analysis while ANTLR 4 generates repetitive template code. IDE plugins are also available, enabling real-time visualization of the parse tree for easier student comprehension.
ANTLR 4 is an LL parser generator, which, compared to LR and LALR parser generators, can handle a narrower scope of grammars. However, its generated parsers have the advantage of being easier to understand and use. Additionally, its support for \"infinite lookahead\" scanning improves handling of narrow grammar scopes.
The instructor delivers lectures on compiler design in a humorous and engaging manner, incorporating appropriate diagrams and real-life examples to maintain student interest. Particularly in this version of the course, the approach involves first practically completing small examples using ANTLR 4, followed by supplementing with theoretical knowledge. This allows students to approach theoretical aspects with specific questions in mind, enhancing memorability. Through the study of theoretical knowledge, the \"mysterious veil\" of the C language is gradually lifted.
The theoretical part follows the rhythm outlined in the \"Dragon Book,\" covering topics such as lexical analysis, syntax analysis, semantic analysis, runtime environments, register allocation, code optimization, and generation.
The practical aspect is the highlight of this course, guiding students step by step to implement their own compiler from simple to complex.
The instructor is extremely generous, allowing even non-university students to access the Online Judge and participate in course discussions. The instructor also meticulously organizes study materials from previous years, making them easily accessible on the course website.
The instructor also openly shares the Zulip address for the teaching group (if there are any changes, they can be found on the course website), meaning that students can ask questions and see the questions of other Nanjing University students studying the same material. These questions receive responses from teaching assistants and the instructor, eliminating the need to reiterate pitfalls or experiences, as students can exchange information on one platform with others studying the same content.
The biggest takeaway is that there is no longer a sense of difficulty or uncertainty in implementing a compiler. Upon completing the course, students have a preliminary and effective approach that enables them to face challenges confidently.
The practice course of Compiler Principles at Peking University aims to teach student to implement a compiler that translates from a simplified version of the C language \u2014 SysY to RISC-V assembly. Unlike other courses that provide skeleton code, this course grants you a great degree of freedom. The test programs only check the correctness of the assembly code your compiler outputs, without imposing any restrictions on the specific design of your compiler or even the programming language used. You need to start from scratch and gradually build your own compiler. However, this is quite challenging even for Peking University students, so in 2022, the course TA @MaxXing significantly upgraded this course, designing a special intermediate representation, Koopa IR, for the course. Koopa IR is more rationally designed and, while similar to LLVM IR, it simplifies many details, focusing only on the practical aspects needed. At the same time, a corresponding runtime library was designed for Koopa IR, allowing you to easily parse/generate/modify/output Koopa IR without having to consider other superfluous details. Additionally, a detailed document breaks down the large project of building a compiler into nine small steps, making it easier for any student willing to invest the time to implement their own compiler.
The following content is excerpted from @MaxXing's Blog which introduces this course in more details:
You may have seen countless tutorials teaching how to write a compiler, but they may have various issues that still leave you puzzled about where to start:
The tutorials are not aimed at people with \"zero compiler foundation,\" and can be difficult to understand.
They teach how to make a compiler but not why to do it that way, leaving you still in a fog after reading.
Complicated environment setup is required before starting coding, discouraging beginners at the start.
The initial tasks are unrelated to \"compiling a program,\" and it can take a month following the tutorial to see a running program from your compiler, resulting in a long feedback cycle.
What you finally write is just an interpreter, or it can't compile to a real ISA (like outputting some bytecode), or it's highly dependent on other frameworks (like LLVM), which doesn't let you feel the accomplishment of \"I really made a compiler\" and the exhilaration of \"doing everything myself.\"
The compiler implemented can only compile simple programs, such as sorting algorithms, which seem very boring. Who sorts just for fun?
Tutorials and their resources are not in Chinese, or they require payment and are not open source.
During my graduate studies, I was the TA in the undergraduate Compiler Principles course. To help undergraduates better understand how compilers work, after referring to several other tutorials, I designed a new set of tutorials that teach you how to write a compiler from scratch:
You can use C/C++/Rust to develop your compiler, the tutorial only requires you to have the ability to program in these languages, without any need for foundational knowledge of compiler principles or related practical experience.
The tutorial not only tells you how to write a compiler but also why to do it that way, and what else you could do.
The tutorial adopts an incremental, iterative approach, guiding you from a compiler that can only handle the main function to gradually expanding to implement a compiler for a C-like language that includes control flow, function calls, and arrays. The compiler can output RISC-V assembly.
Providing a Docker-based environment for one-click setup. The environment also includes automatic testing scripts for one-click testing of your compiler.
The tutorial introduces tools that can take over some of the tedious grunt work, such as generating lexer/parser, parsing and generating IR, etc. The rest, like building AST, semantic analysis, generating IR, and producing target code, is entirely up to you to implement.
The compiler you ultimately implement will be capable of compiling many complex programs, such as the Mandelbrot set drawing program or a Lisp interpreter (this interpreter can even interpret another Lisp interpreter). We will provide these programs for you to experience the real joy of using your compiler.
The tutorial and its accompanying tools, experimental environments, etc., are all open source and completely free!
You can access this tutorial on GitHub Pages: Peking University Compiler Practice Course Online Documentation. If you have never tried writing a compiler yourself, why not try it now?
My wish is that everyone feels the joy of writing compilers.
Finally, my highest regards to @MaxXing. \u2014 from PKUFlyingPig
The theoretical part of this course covers a wide range of topics, including lexical analysis, syntax analysis, syntax-directed translation, and intermediate code translation from traditional compiler principles courses, as well as runtime management and both machine-independent and machine-specific code optimization. The practical component provides C++ code for the Cminusf compiler framework, allowing students to progressively build a fully functional modern compiler over six labs. Unlike other compiler courses, this course uses a subset of modern LLVM as the intermediate code, offering a forward-looking approach and including backend code generation and intermediate code optimization, making it a world-class compiler course.
The course labs use scripts to provide comprehensive automated testing, with complete tutorials available on the course homepage.
The course includes a full set of open-source course materials, lab framework code, and lab tutorials, making it beginner-friendly.
The labs progress gradually, increasing in difficulty, ensuring that students with varying levels of prior knowledge can benefit.
In Lab 1, Flex and Bison are used to implement the compiler frontend. Lab 2 involves generating intermediate code with LightIR (a subset of LLVM). Lab 3 covers backend code generation for the Loongson assembly language. Lab 4 focuses on intermediate code optimization. Lab 5 implements machine-independent optimization, and Lab 6 deals with register allocation.
This course provides a comprehensive introduction to computer graphics. It focuses on fundamental concepts and techniques, and their cross-cutting relationship to multiple problem domains in graphics (rendering, animation, geometry, imaging). Topics include: sampling, aliasing, interpolation, rasterization, geometric transformations, parameterization, visibility, compositing, filtering, convolution, curves & surfaces, geometric data structures, subdivision, meshing, spatial hierarchies, ray tracing, radiometry, reflectance, light fields, geometric optics, Monte Carlo rendering, importance sampling, camera models, high-performance ray tracing, differential equations, time integration, numerical differentiation, physically-based animation, optimization, numerical linear algebra, inverse kinematics, Fourier methods, data fitting, example-based synthesis.
This introductory course in computer graphics begins with using Blender to generate images and understanding the underlying mathematical concepts, including triangles, normals, interpolation, texture mapping, bump mapping, and more. It then delves into light and color and how they affect computer displays and printing. The course also covers BRDF and some basic lighting and shading models. Towards the end, topics like ray tracing, anti-aliasing, and acceleration structures are introduced.
For more detailed information, you can visit the course website.
This course is somewhat less in-depth compared to GAMES101 and uses Python, making it more accessible for students who are not familiar with C++.
This course comprehensively and systematically introduces the four major components of modern computer graphics: (1) rasterization imaging, (2) geometric representation, (3) the theory of light propagation, and (4) animation and simulation. Each aspect is explained from basic principles to practical applications, along with the introduction of cutting-edge theoretical research. Through this course, you can learn the mathematics and physics behind computer graphics and enhance your practical programming skills. As an introduction, this course aims to cover as many aspects of graphics as possible, clearly explaining the basic concepts of each part to provide a complete, top-down understanding of computer graphics. A global understanding is crucial; after completing this course, you will realize that graphics is not just OpenGL or ray tracing but a set of methods for creating virtual worlds. The title of this course also contains the word \"modern,\" indicating that the knowledge imparted is contemporary and essential for the modern graphics industry.
GAMES101 is a well-known graphics course in China. Unlike the traditionally math and algorithm-heavy perception of graphics, this course introduces the field of graphics in a very vivid way.
Each project is not code-heavy but is quite interesting. Through these projects, students will implement simple rasterization to render basic models and ray tracing for better rendering quality. Each project also includes optional extensions to enhance the quality and speed of the rendered models.
If you enjoy gaming, you might be familiar with real-time ray tracing, a technology that the course instructor, Lingqi Yan, has directly contributed to. By following the course videos and completing each project, you'll likely develop a strong interest in graphics and modern rendering techniques, just as I did.
All resources and homework implementations used by @ysj1173886760 during the course are compiled at ysj1173886760/Learning: graphics/GAMES101 - GitHub.
This course serves as an introduction to physics-based computer animation techniques, focusing on various fundamental physical animation simulation technologies.
The course mainly covers four areas: 1) Rigid body simulation; 2) Particle systems, springs, constraints, and cloth simulation; 3) Elastic body simulation based on the finite element method; 4) Fluid simulation.
The course content will not delve into specific physical simulation engines but will discuss the technologies behind various engines and their pros and cons. Since developing and learning physical simulations requires a solid mathematical foundation, the initial stages of the course will also spend some time reviewing necessary mathematical concepts. Upon successful completion of the course, students should have a deep understanding of basic physical simulation techniques and some exposure to advanced simulation technologies.
In graphics, the field can be roughly divided into rendering, simulation, and geometry. While GAMES101 and GAMES202 mainly focus on rendering, GAMES103 is an excellent resource for learning about physical simulation.
All resources and homework requirements used by @indevn during the course are compiled at GAMES103 Unofficial. For detailed implementations of the assignments, there are many articles on Zhihu that provide in-depth explanations and can be referenced.
This course comprehensively introduces the key issues and solutions in modern real-time rendering. Since real-time rendering (>30 FPS) demands high speed, the focus of this course is on how to break the trade-off between speed and quality under strict time constraints, ensuring both high-speed real-time performance and photorealism.
The course will be presented in a thematic manner, covering cutting-edge content from both academia and industry, including: (1) real-time soft shadow rendering; (2) ambient lighting; (3) global illumination with or without precomputation; (4) physically-based shading models and methods; (5) real-time ray tracing; (6) anti-aliasing and supersampling; as well as various common acceleration methods.
In addition to the latest and most comprehensive content, an important distinction of this course from other real-time rendering tutorials is that it does not teach the use of game engines or emphasize specific shader implementation techniques. Instead, it focuses on the science and knowledge behind real-time rendering. The goal of this course is to provide you with a solid foundation to develop your own real-time rendering engine upon completion.
As an advanced course following GAMES101, GAMES202 offers a slightly increased level of difficulty, but it's manageable for students who have completed GAMES101. Each project requires a moderate amount of coding but involves significant thought.
Prerequisites: Calculus, Linear Algebra, C/C++ Programming, Data Structures
Programming Languages: C/C++
Difficulty: \ud83c\udf1f\ud83c\udf1f\ud83c\udf1f
Class Hour: 100 hours
Mr. Liu Ligang from the School of Mathematics at USTC uploaded the course during the 2020 epidemic, and I personally feel that it is more comprehensive compared to Games101's focus on rendering, with content such as discrete geometry processing that the latter does not have, and it seems to be more mathematical, so it can be complemented with Games101, and the course materials are fully open to the public.
Textbooks:E. Angel, Interactive Computer Graphics \u2014 A top-down approach using OpenGL\u2122, 6th ed., 2011.(This course does not prescribe the use of a prescribed textbook, and focuses on cutting-edge academic papers; the following textbooks are for reference only)
Assignments:http://staff.ustc.edu.cn/~lgliu/Courses/ComputerGraphics_2020_spring-summer/default.htm, 9 homework and 1 project
Prerequisites: Students should be able to write moderately complex programs, read and understand portions of large code bases, trace memory diagrams, and be fluent with Unix, GDB, Valgrind, and Make.
This course builds upon the foundational knowledge gained in CS107 and delves into advanced computer systems and program construction. It focuses on designing large systems, software that spans multiple machines, and parallel computing. The course aims to teach students the principles and practice of engineering of computer software and hardware systems.
The course covers a broad range of topics including how your programs map onto the components of computer systems, understanding of program behavior and execution, understanding the designs and tradeoffs of large systems, writing software that spans multiple machines, and writing software that runs tasks in parallel on a single machine.
The teaching style of this course is engaging and practical. The instructors guide the students to understand the numerous technical challenges and design principles in computer systems by going through the course materials and labs. Weekly labs let you add new features to the projects, which focus on enhancing students' practical skills. There are several labs during the whole semester which give you the chance to understand every aspect of the computer systems.
In addition to the labs, the course also includes assignments that are designed to provide hands-on experience and deepen understanding of the course material. Each assignment has a complete framework for testing.
This course is one of CMU's most reputable courses, and is known for its extensive content and difficult projects. The course covers assembly language, computer architecture, operating systems, compilation and linking, parallelism, networking, etc. As an introductory course of computer system, it has both breadth and depth, and does require considerable perseverance and coding skills if you learn it on your own.
The textbook for this course, known as CSAPP, was written by Professor Bryant, Dean of the School of Computer Science at CMU. This is also the first computer textbook that I read carefully from the start to the end, although it was tough, I gained a lot from it.
Peking University purchased the copyright of the course and opened a similar one, but you can have access to all of the course resources on its official homepage (see the link below for details).
This course is so famous that you can easily have access to the project solutions on the Internet. But if you really want to practice your coding skills, it is highly recommended to implement the projects on your own.
After completing this course, your understanding of computer systems will definitely go up a notch.
Textbook: Computer Systems: A Programmer's Perspective, 3/E
Assignments: 11 Projects, skeleton code all open source.
If you have trouble with Chapter 7 Linking, I recommend reading the book Programmer's Self-Cultivation, subtitled link. load and library. This book can complete our understanding of program linking, and I believe after reading this book you will have a deeper comprehension of program linking, ELF files, and dynamic libraries. It is highly recommended to be read as a supplementary material after reading CSAPP and having a certain understanding of computer systems.
One of the lecturers of this course is Professor Nick McKeown, a giant in the field of Networking. At the end of each chapter of MOOC, he will interview an executive in the industry or an expert in the academia, which can certainly broaden your horizons.
In the projects, you will use C++ to build the entire TCP/IP protocol stack, the IP router, and the ARP protocol step by step from scratch. Finally, you will replace Linux Kernel's protocol stack with your own and use socket programming to communicate with your classmates, which is really amazing and exciting.
Prerequisites: basic knowledge about computer system
Programming Languages: None
Difficulty: \ud83c\udf1f\ud83c\udf1f\ud83c\udf1f
Class Hour: 40 hours
Computer Networking: A Top-Down Approach is a classic textbook in the field of computer networking. The two authors, Jim Kurose and Keith Ross, have carefully crafted a course website to support the textbook, with lecture recordings, interactive online questions, and WireShark labs for network packet analysis. The only pity is that this course doesn't have hardcore programming assignments, and Stanford's CS144 makes up for that.
This course is a well-known computer networking course on the Chinese Internet, it adopts the renowned textbook: Computer Networking: A Top-Down Approach, 7th Edition. This a practical course that is not limited to theoretical knowledge, but it is Strongly recommended to read the textbook before watching videos, otherwise you may not catch up with the course easily.
The course covers the majority of the textbook and also includes exam content, so enjoy it.
The recordings of the lectures were uploaded by Prof. Zheng himself on Bilibili. Moreover, he has been answering questions in the comments below the videos since 2020, which is very patient and responsible.
Prerequisites: solid foundations of computer science
Programming Languages: Any
Difficulty: \ud83c\udf1f\ud83c\udf1f\ud83c\udf1f
Class Hour: 100 hours
This course focuses on a relatively \"unfamiliar\" area \u2014 empirical research in software engineering. It is taught by Bogdan Vasilescu, who has extensive expertise in empirical studies and open-source software research.
The course is offered by CMU for PhD students pursuing research in this field. It covers a range of qualitative and quantitative research methods, such as interviews, qualitative coding, survey design, and various statistical analysis methods, helping students understand, learn, and engage in empirical research. The course also introduces the extraction and integration of data from software repositories like GitHub and Stack Overflow, applying statistical modeling, social network analysis, and other data analytics techniques.
Although the field of computer science traditionally focuses more on engineering technology, empirical research is essential for the design, evaluation, and potential social value of tools and technologies. For example, it involves evaluating new algorithms or new technological frameworks, analyzing relevant data within a field, and understanding challenges that practitioners might face. This course can expand and complement a focus on technical aspects. For those interested in pursuing research involving empirical studies in the field of software engineering, this course could be an excellent introduction.
The goal of this course is for you to learn how to write high quality code, and what is meant by high quality is to meet the following three targets:
Safe from bugs. Correctness (correct behavior right now) and defensiveness (correct behavior in the future) are required in any software we build.
Easy to understand. The code has to communicate to future programmers who need to understand it and make changes in it (fixing bugs or adding new features). That future programmer might be you, months or years from now. You\u2019ll be surprised how much you forget if you don\u2019t write it down, and how much it helps your own future self to have a good design.
Ready for change. Software always changes. Some designs make it easy to make changes; others require throwing away and rewriting a lot of code.
To achieve this, the instructors write a book explaining many of the core principles of software construction and valuable lessons learned from the past. The book covers many practical topics such as how to write comments and specifications, how to design abstract data structures, and many parallel programming caveats. You will explore all of these ideas in the programming assignments.
In the 2016 spring, the course open-sourced all of its programming assignments, and the textbook can be found on the latest website (see links below).
This is Berkeley's software engineering course. Unlike many traditional software engineering courses that emphasize UML diagrams, plans, and documents, this course adopts agile development methodologies and uses the cloud platform to provide software as a service. The instructors wrote a textbook Software as a service to explain the concept of SaaS and agile development. Also, there are plenty of programming assignments using Ruby + Rails framework.
This course is available on Edx, an online education platform sponsored by MIT and Harvard, where you can search for the course Agile SaaS Development and learn it yourself. The course content follows the textbook's order and takes you to build software step by step in an agile development way and deploy it on the cloud platform for free.
All the resources and assignments used by @PKUFlyingPig in this course are maintained in PKUFlyingPig/CS169-Software-Engineering - GitHub.
"}]}
\ No newline at end of file
+{"config":{"lang":["zh","en"],"separator":"[\\s\\u200b\\u3000\\-\u3001\u3002\uff0c\uff0e\uff1f\uff01\uff1b]+","pipeline":["stemmer"]},"docs":[{"location":"","title":"\u524d\u8a00","text":""},{"location":"#_1","title":"\u524d\u8a00","text":"
\u5927\u4e00\u5165\u5b66\u65f6\u6211\u662f\u4e00\u4e2a\u5bf9\u8ba1\u7b97\u673a\u4e00\u65e0\u6240\u77e5\u7684\u5c0f\u767d\uff0c\u88c5\u4e86\u51e0\u5341\u4e2a G \u7684 Visual Studio \u5929\u5929\u548c OJ \u4f60\u6b7b\u6211\u6d3b\u3002\u51ed\u7740\u9ad8\u4e2d\u7684\u6570\u5b66\u5e95\u5b50\u6211\u6570\u5b66\u8bfe\u5b66\u5f97\u8fd8\u4e0d\u9519\uff0c\u4f46\u5728\u4e13\u4e1a\u8bfe\u4e0a\u5bf9\u7ade\u8d5b\u5927\u4f6c\u53ea\u6709\u4ef0\u671b\u3002\u63d0\u5230\u7f16\u7a0b\u6211\u53ea\u4f1a\u6253\u5f00\u90a3\u7b28\u91cd\u7684 IDE\uff0c\u65b0\u5efa\u4e00\u4e2a\u6211\u4e5f\u4e0d\u77e5\u9053\u5177\u4f53\u662f\u5e72\u5565\u7684\u547d\u4ee4\u884c\u9879\u76ee\uff0c\u7136\u540e\u5c31\u662f cin, cout, for \u5faa\u73af\uff0c\u7136\u540e CE, RE, WA \u5faa\u73af\u3002\u5f53\u65f6\u7684\u6211\u5c31\u5904\u5728\u4e00\u79cd\u62fc\u547d\u60f3\u5b66\u597d\u4f46\u4e0d\u77e5\u9053\u600e\u4e48\u5b66\uff0c\u8bfe\u4e0a\u8ba4\u771f\u542c\u8bb2\u4f46\u9898\u8fd8\u4e0d\u4f1a\u505a\uff0c\u8bfe\u540e\u505a\u4f5c\u4e1a\u5b8c\u5168\u662f\u7528\u65f6\u95f4\u548c\u5b83\u786c\u8017\u7684\u75db\u82e6\u72b6\u6001\u3002\u6211\u81f3\u4eca\u7535\u8111\u91cc\u8fd8\u5b58\u7740\u81ea\u5df1\u5927\u4e00\u4e0a\u5b66\u671f\u8ba1\u7b97\u6982\u8bba\u5927\u4f5c\u4e1a\u7684\u6e90\u4ee3\u7801 \u2014\u2014 \u4e00\u4e2a 1200 \u884c\u7684 C++ \u6587\u4ef6\uff0c\u6ca1\u6709\u5934\u6587\u4ef6\u3001\u6ca1\u6709\u7c7b\u3001\u6ca1\u6709\u5c01\u88c5\u3001\u6ca1\u6709 unit test\u3001\u6ca1\u6709 Makefile\u3001\u6ca1\u6709 Git\uff0c\u552f\u4e00\u7684\u4f18\u70b9\u662f\u5b83\u786e\u5b9e\u80fd\u8dd1\uff0c\u7f3a\u70b9\u662f\u201c\u80fd\u8dd1\u201d\u7684\u8865\u96c6\u3002\u6211\u4e00\u5ea6\u6000\u7591\u6211\u662f\u4e0d\u662f\u4e0d\u9002\u5408\u5b66\u8ba1\u7b97\u673a\uff0c\u56e0\u4e3a\u7ae5\u5e74\u5bf9\u4e8e\u6781\u5ba2\u7684\u6240\u6709\u60f3\u8c61\uff0c\u5df2\u7ecf\u88ab\u6211\u7b2c\u4e00\u4e2a\u5b66\u671f\u7684\u4f53\u9a8c\u5f7b\u5e95\u7c89\u788e\u4e86\u3002
\u8bfe\u7a0b\u6559\u6388\u4eb2\u81ea\u7f16\u5199\u7684\u6559\u6750\uff1aCS61A \u8fd9\u95e8\u8bfe\u7684\u5f00\u8bfe\u8001\u5e08\u5c06 MIT \u7684\u7ecf\u5178\u6559\u6750 Structure and Interpretation of Computer Programs (SICP) \u7528Python\u8fd9\u95e8\u8bed\u8a00\u8fdb\u884c\u6539\u7f16\uff08\u539f\u6559\u6750\u57fa\u4e8e Scheme \u8bed\u8a00\uff09\uff0c\u4fdd\u8bc1\u4e86\u8bfe\u5802\u5185\u5bb9\u4e0e\u6559\u6750\u5185\u5bb9\u7684\u4e00\u81f4\u6027\uff0c\u540c\u65f6\u8865\u5145\u4e86\u66f4\u591a\u7ec6\u8282\uff0c\u53ef\u4ee5\u8bf4\u8bda\u610f\u6ee1\u6ee1\u3002\u800c\u4e14\u5168\u4e66\u5f00\u6e90\uff0c\u53ef\u4ee5\u76f4\u63a5\u7ebf\u4e0a\u9605\u8bfb\u3002
\u7b2c\u4e00\u5c31\u662f\u4ea4\u6d41\u6c9f\u901a\u7684\u4e0d\u4fbf\u3002\u6211\u5176\u5b9e\u662f\u4e00\u4e2a\u5f88\u70ed\u8877\u4e8e\u63d0\u95ee\u7684\u4eba\uff0c\u5bf9\u4e8e\u6240\u6709\u6ca1\u6709\u5f04\u660e\u767d\u7684\u70b9\uff0c\u6211\u90fd\u559c\u6b22\u7a77\u8ffd\u5230\u5e95\u3002\u4f46\u5f53\u4f60\u9762\u5bf9\u7740\u5c4f\u5e55\u542c\u5230\u8001\u5e08\u8bb2\u4e86\u4e00\u4e2a\u4f60\u6ca1\u660e\u767d\u7684\u77e5\u8bc6\u70b9\u7684\u65f6\u5019\uff0c\u4f60\u65e0\u6cd5\u987a\u7740\u7f51\u7ebf\u5230\u53e6\u4e00\u7aef\u5411\u8001\u5e08\u95ee\u4e2a\u660e\u767d\u3002\u6211\u52aa\u529b\u901a\u8fc7\u72ec\u7acb\u601d\u8003\u548c\u5584\u7528 Google \u6765\u7f13\u89e3\u8fd9\u4e00\u70b9\uff0c\u4f46\u662f\uff0c\u5982\u679c\u80fd\u6709\u51e0\u4e2a\u5fd7\u540c\u9053\u5408\u7684\u4f19\u4f34\u7ed3\u4f34\u81ea\u5b66\uff0c\u90a3\u5c06\u662f\u6781\u597d\u7684\u3002\u5173\u4e8e\u4ea4\u6d41\u7fa4\u7684\u5efa\u7acb\uff0c\u5927\u5bb6\u53ef\u4ee5\u53c2\u8003\u4ed3\u5e93 README \u4e2d\u7684\u6559\u7a0b\u3002
\u672c\u4e66\u7684\u5185\u5bb9\u662f\u5b8c\u5168\u5f00\u6e90\u514d\u8d39\u7684\uff0c\u5982\u679c\u4f60\u89c9\u5f97\u8be5\u9879\u76ee\u5bf9\u4f60\u771f\u7684\u6709\u5e2e\u52a9\uff0c\u53ef\u4ee5\u7ed9\u4ed3\u5e93\u70b9\u4e2a star \u6216\u8005\u8bf7\u4f5c\u8005\u559d\u4e00\u676f\u4e0b\u5348\u8336\u3002
IDE (Integrated Development Environment)\uff1a\u96c6\u6210\u5f00\u53d1\u73af\u5883\uff0c\u8bf4\u767d\u4e86\u5c31\u662f\u4f60\u5199\u4ee3\u7801\u7684\u5730\u65b9\u3002\u4f5c\u4e3a\u4e00\u4e2a\u7801\u519c\uff0cIDE \u7684\u91cd\u8981\u6027\u4e0d\u8a00\u800c\u55bb\uff0c\u4f46\u7531\u4e8e\u5f88\u591a IDE \u662f\u4e3a\u5927\u578b\u5de5\u7a0b\u9879\u76ee\u8bbe\u8ba1\u7684\uff0c\u4f53\u91cf\u8f83\u5927\uff0c\u529f\u80fd\u4e5f\u8fc7\u4e8e\u4e30\u5bcc\u3002\u5176\u5b9e\u5982\u4eca\u4e00\u4e9b\u8f7b\u4fbf\u7684\u6587\u672c\u7f16\u8f91\u5668\u914d\u5408\u4e30\u5bcc\u7684\u63d2\u4ef6\u751f\u6001\u57fa\u672c\u53ef\u4ee5\u6ee1\u8db3\u65e5\u5e38\u7684\u8f7b\u91cf\u7f16\u7a0b\u9700\u6c42\u3002\u4e2a\u4eba\u5e38\u7528\u7684\u7f16\u8f91\u5668\u662f VS Code \u548c Sublime\uff08\u524d\u8005\u7684\u63d2\u4ef6\u914d\u7f6e\u975e\u5e38\u7b80\u5355\uff0c\u540e\u8005\u7565\u663e\u590d\u6742\u4f46\u989c\u503c\u5f88\u9ad8\uff09\u3002\u5f53\u7136\u5bf9\u4e8e\u5927\u578b\u9879\u76ee\u6211\u8fd8\u662f\u4f1a\u91c7\u7528\u7565\u91cd\u578b\u7684 IDE\uff0c\u4f8b\u5982 Pycharm (Python)\uff0cIDEA (Java) \u7b49\u7b49\uff08\u514d\u8d23\u7533\u660e\uff1a\u6240\u6709\u7684 IDE \u90fd\u662f\u4e16\u754c\u4e0a\u6700\u597d\u7684 IDE\uff09\u3002
Vim\uff1a\u4e00\u6b3e\u547d\u4ee4\u884c\u7f16\u8f91\u5de5\u5177\u3002\u8fd9\u662f\u4e00\u4e2a\u5b66\u4e60\u66f2\u7ebf\u6709\u4e9b\u9661\u5ced\u7684\u7f16\u8f91\u5668\uff0c\u4e0d\u8fc7\u5b66\u4f1a\u5b83\u6211\u89c9\u5f97\u662f\u975e\u5e38\u6709\u5fc5\u8981\u7684\uff0c\u56e0\u4e3a\u5b83\u5c06\u6781\u5927\u5730\u63d0\u9ad8\u4f60\u7684\u5f00\u53d1\u6548\u7387\u3002\u73b0\u5728\u7edd\u5927\u591a\u6570 IDE \u4e5f\u90fd\u652f\u6301 Vim \u63d2\u4ef6\uff0c\u8ba9\u4f60\u5728\u4eab\u53d7\u73b0\u4ee3\u5f00\u53d1\u73af\u5883\u7684\u540c\u65f6\u4fdd\u7559\u6781\u5ba2\u7684\u70ab\u9177\uff08yue\uff09\u3002
Emacs\uff1a\u4e0e Vim \u9f50\u540d\u7684\u7ecf\u5178\u7f16\u8f91\u5668\uff0c\u540c\u6837\u5177\u6709\u6781\u9ad8\u7684\u5f00\u53d1\u6548\u7387\uff0c\u540c\u65f6\u5177\u6709\u66f4\u4e3a\u5f3a\u5927\u7684\u6269\u5c55\u6027\uff0c\u5b83\u65e2\u53ef\u4ee5\u914d\u7f6e\u4e3a\u4e00\u4e2a\u8f7b\u91cf\u7f16\u8f91\u5668\uff0c\u4e5f\u53ef\u4ee5\u6269\u5c55\u6210\u4e00\u4e2a\u4e2a\u4eba\u5b9a\u5236\u7684 IDE\uff0c\u751a\u81f3\u53ef\u4ee5\u6709\u66f4\u591a\u5947\u6280\u6deb\u5de7\u3002
Git\uff1a\u4e00\u6b3e\u4ee3\u7801\u7248\u672c\u63a7\u5236\u5de5\u5177\u3002Git\u7684\u5b66\u4e60\u66f2\u7ebf\u53ef\u80fd\u66f4\u4e3a\u9661\u5ced\uff0c\u4f46\u51fa\u81ea Linux \u4e4b\u7236 Linus \u4e4b\u624b\u7684 Git \u7edd\u5bf9\u662f\u6bcf\u4e2a\u5b66 CS \u7684\u7ae5\u978b\u5fc5\u987b\u638c\u63e1\u7684\u795e\u5668\u4e4b\u4e00\u3002
GNU Make\uff1a\u4e00\u6b3e\u5de5\u7a0b\u6784\u5efa\u5de5\u5177\u3002\u5584\u7528 GNU Make \u4f1a\u8ba9\u4f60\u517b\u6210\u4ee3\u7801\u6a21\u5757\u5316\u7684\u4e60\u60ef\uff0c\u540c\u65f6\u4e5f\u80fd\u8ba9\u4f60\u719f\u6089\u4e00\u4e9b\u5927\u578b\u5de5\u7a0b\u7684\u7f16\u8bd1\u94fe\u63a5\u6d41\u7a0b\u3002
CMake\uff1a\u4e00\u6b3e\u529f\u80fd\u6bd4 GNU Make \u66f4\u4e3a\u5f3a\u5927\u7684\u6784\u5efa\u5de5\u5177\uff0c\u5efa\u8bae\u638c\u63e1 GNU Make \u4e4b\u540e\u518d\u52a0\u4ee5\u5b66\u4e60\u3002
\u5982\u679c\u4f60\u662f Mac \u7528\u6237\uff0c\u90a3\u4e48\u4f60\u5f88\u5e78\u8fd0\uff0c\u8fd9\u4efd\u6307\u5357 \u5c06\u4f1a\u624b\u628a\u624b\u5730\u5e26\u4f60\u642d\u5efa\u8d77\u6574\u5957\u5f00\u53d1\u73af\u5883\u3002\u5982\u679c\u4f60\u662f Windows \u7528\u6237\uff0c\u5728\u5f00\u6e90\u793e\u533a\u7684\u52aa\u529b\u4e0b\uff0c\u4f60\u540c\u6837\u53ef\u4ee5\u83b7\u5f97\u4e0e\u5176\u4ed6\u5e73\u53f0\u7c7b\u4f3c\u7684\u4f53\u9a8c\uff1aScoop\u3002
\u670d\u52a1\u5668\u7aef\u7684\u8fd0\u7ef4\u9700\u8981\u638c\u63e1 Linux\uff08\u6216\u8005\u5176\u4ed6\u7c7b Unix \u7cfb\u7edf\uff09\u7684\u57fa\u672c\u4f7f\u7528\u4ee5\u53ca\u8fdb\u7a0b\u3001\u8bbe\u5907\u3001\u7f51\u7edc\u7b49\u7cfb\u7edf\u76f8\u5173\u7684\u57fa\u672c\u6982\u5ff5\uff0c\u5c0f\u767d\u53ef\u4ee5\u53c2\u8003\u4e2d\u56fd\u79d1\u5b66\u6280\u672f\u5927\u5b66 Linux \u7528\u6237\u534f\u4f1a\u7f16\u5199\u7684\u300aLinux 101\u300b\u5728\u7ebf\u8bb2\u4e49\u3002\u5982\u679c\u60f3\u6df1\u5165\u5b66\u4e60\u7cfb\u7edf\u8fd0\u7ef4\u76f8\u5173\u7684\u77e5\u8bc6\uff0c\u53ef\u4ee5\u53c2\u8003 Aspects of System Administration \u8fd9\u95e8\u8bfe\u7a0b\u3002
\u4f5c\u4e3a\u8ba1\u7b97\u673a\u7cfb\u7684\u5b66\u751f\uff0c\u53ca\u65e9\u4e86\u89e3\u4e00\u4e9b\u4fe1\u606f\u8bba\u7684\u57fa\u7840\u77e5\u8bc6\uff0c\u6211\u89c9\u5f97\u662f\u5927\u6709\u88e8\u76ca\u7684\u3002\u4f46\u5927\u591a\u4fe1\u606f\u8bba\u8bfe\u7a0b\u90fd\u9762\u5411\u9ad8\u5e74\u7ea7\u672c\u79d1\u751f\u751a\u81f3\u7814\u7a76\u751f\uff0c\u5bf9\u65b0\u624b\u6781\u4e0d\u53cb\u597d\u3002\u800c MIT \u7684 6.050J: Information theory and Entropy \u8fd9\u95e8\u8bfe\u6b63\u662f\u4e3a\u5927\u4e00\u65b0\u751f\u91cf\u8eab\u5b9a\u5236\u7684\uff0c\u51e0\u4e4e\u6ca1\u6709\u5148\u4fee\u8981\u6c42\uff0c\u6db5\u76d6\u4e86\u7f16\u7801\u3001\u538b\u7f29\u3001\u901a\u4fe1\u3001\u4fe1\u606f\u71b5\u7b49\u7b49\u5185\u5bb9\uff0c\u975e\u5e38\u6709\u8da3\u3002
UCB CS70 : discrete Math and probability theory \u548c UCB CS126 : Probability theory \u662f UC Berkeley \u7684\u6982\u7387\u8bba\u8bfe\u7a0b\uff0c\u524d\u8005\u8986\u76d6\u4e86\u79bb\u6563\u6570\u5b66\u548c\u6982\u7387\u8bba\u57fa\u7840\uff0c\u540e\u8005\u5219\u6d89\u53ca\u968f\u673a\u8fc7\u7a0b\u4ee5\u53ca\u6df1\u5165\u7684\u7406\u8bba\u5185\u5bb9\u3002\u4e24\u8005\u90fd\u975e\u5e38\u6ce8\u91cd\u7406\u8bba\u548c\u5b9e\u8df5\u7684\u7ed3\u5408\uff0c\u6709\u4e30\u5bcc\u7684\u7b97\u6cd5\u5b9e\u9645\u8fd0\u7528\u5b9e\u4f8b\uff0c\u540e\u8005\u8fd8\u6709\u5927\u91cf\u7684 Python \u7f16\u7a0b\u4f5c\u4e1a\u6765\u8ba9\u5b66\u751f\u8fd0\u7528\u6982\u7387\u8bba\u7684\u77e5\u8bc6\u89e3\u51b3\u5b9e\u9645\u95ee\u9898\u3002
\u4f5c\u4e3a\u8ba1\u7b97\u673a\u7cfb\u7684\u5b66\u751f\uff0c\u57f9\u517b\u8ba1\u7b97\u601d\u7ef4\u662f\u5f88\u91cd\u8981\u7684\uff0c\u5b9e\u9645\u95ee\u9898\u7684\u5efa\u6a21\u3001\u79bb\u6563\u5316\uff0c\u8ba1\u7b97\u673a\u7684\u6a21\u62df\u3001\u5206\u6790\uff0c\u662f\u4e00\u9879\u5f88\u91cd\u8981\u7684\u80fd\u529b\u3002\u800c\u8fd9\u4e24\u5e74\u5f00\u59cb\u98ce\u9761\u7684\uff0c\u7531 MIT \u6253\u9020\u7684 Julia \u7f16\u7a0b\u8bed\u8a00\u4ee5\u5176 C \u4e00\u6837\u7684\u901f\u5ea6\u548c Python \u4e00\u6837\u53cb\u597d\u7684\u8bed\u6cd5\u5728\u6570\u503c\u8ba1\u7b97\u9886\u57df\u6709\u4e00\u7edf\u5929\u4e0b\u4e4b\u52bf\uff0cMIT \u7684\u8bb8\u591a\u6570\u5b66\u8bfe\u7a0b\u4e5f\u5f00\u59cb\u7528 Julia \u4f5c\u4e3a\u6559\u5b66\u5de5\u5177\uff0c\u628a\u8270\u6df1\u7684\u6570\u5b66\u7406\u8bba\u7528\u76f4\u89c2\u6e05\u6670\u7684\u4ee3\u7801\u5c55\u793a\u51fa\u6765\u3002
ComputationalThinking \u662f MIT \u5f00\u8bbe\u7684\u4e00\u95e8\u8ba1\u7b97\u601d\u7ef4\u5165\u95e8\u8bfe\uff0c\u6240\u6709\u8bfe\u7a0b\u5185\u5bb9\u5168\u90e8\u5f00\u6e90\uff0c\u53ef\u4ee5\u5728\u8bfe\u7a0b\u7f51\u7ad9\u76f4\u63a5\u8bbf\u95ee\u3002\u8fd9\u95e8\u8bfe\u5229\u7528 Julia \u7f16\u7a0b\u8bed\u8a00\uff0c\u5728\u56fe\u50cf\u5904\u7406\u3001\u793e\u4f1a\u79d1\u5b66\u4e0e\u6570\u636e\u79d1\u5b66\u3001\u6c14\u5019\u5b66\u5efa\u6a21\u4e09\u4e2a topic \u4e0b\u5e26\u9886\u5b66\u751f\u7406\u89e3\u7b97\u6cd5\u3001\u6570\u5b66\u5efa\u6a21\u3001\u6570\u636e\u5206\u6790\u3001\u4ea4\u4e92\u8bbe\u8ba1\u3001\u56fe\u4f8b\u5c55\u793a\uff0c\u8ba9\u5b66\u751f\u4f53\u9a8c\u8ba1\u7b97\u4e0e\u79d1\u5b66\u7684\u7f8e\u5999\u7ed3\u5408\u3002\u5185\u5bb9\u867d\u7136\u4e0d\u96be\uff0c\u4f46\u7ed9\u6211\u6700\u6df1\u523b\u7684\u611f\u53d7\u5c31\u662f\uff0c\u79d1\u5b66\u7684\u9b45\u529b\u5e76\u4e0d\u662f\u6545\u5f04\u7384\u865a\u7684\u8270\u6df1\u7406\u8bba\uff0c\u4e0d\u662f\u8bd8\u5c48\u8071\u7259\u7684\u672f\u8bed\u884c\u8bdd\uff0c\u800c\u662f\u7528\u76f4\u89c2\u751f\u52a8\u7684\u6848\u4f8b\uff0c\u7528\u7b80\u7ec3\u6df1\u523b\u7684\u8bed\u8a00\uff0c\u8ba9\u6bcf\u4e2a\u666e\u901a\u4eba\u90fd\u80fd\u7406\u89e3\u3002
\u4e0a\u5b8c\u4e0a\u9762\u7684\u4f53\u9a8c\u8bfe\u4e4b\u540e\uff0c\u5982\u679c\u610f\u72b9\u672a\u5c3d\u7684\u8bdd\uff0c\u4e0d\u59a8\u8bd5\u8bd5 MIT \u7684 18.330 : Introduction to numerical analysis\uff0c\u8fd9\u95e8\u8bfe\u7684\u7f16\u7a0b\u4f5c\u4e1a\u540c\u6837\u4f1a\u7528 Julia \u7f16\u7a0b\u8bed\u8a00\uff0c\u4e0d\u8fc7\u96be\u5ea6\u548c\u6df1\u5ea6\u4e0a\u90fd\u4e0a\u4e86\u4e00\u4e2a\u53f0\u9636\u3002\u5185\u5bb9\u6d89\u53ca\u4e86\u6d6e\u70b9\u7f16\u7801\u3001Root finding\u3001\u7ebf\u6027\u7cfb\u7edf\u3001\u5fae\u5206\u65b9\u7a0b\u7b49\u7b49\u65b9\u9762\uff0c\u6574\u95e8\u8bfe\u7684\u4e3b\u65e8\u5c31\u662f\u8ba9\u4f60\u5229\u7528\u79bb\u6563\u5316\u7684\u8ba1\u7b97\u673a\u8868\u793a\u53bb\u4f30\u8ba1\u548c\u903c\u8fd1\u4e00\u4e2a\u6570\u5b66\u4e0a\u8fde\u7eed\u7684\u6982\u5ff5\u3002\u8fd9\u95e8\u8bfe\u7684\u6559\u6388\u8fd8\u4e13\u95e8\u64b0\u5199\u4e86\u4e00\u672c\u914d\u5957\u7684\u5f00\u6e90\u6559\u6750 Fundamentals of Numerical Computation\uff0c\u91cc\u9762\u9644\u6709\u4e30\u5bcc\u7684 Julia \u4ee3\u7801\u5b9e\u4f8b\u548c\u4e25\u8c28\u7684\u516c\u5f0f\u63a8\u5bfc\u3002
\u5982\u679c\u4f60\u8fd8\u610f\u72b9\u672a\u5c3d\u7684\u8bdd\uff0c\u8fd8\u6709 MIT \u7684\u6570\u503c\u5206\u6790\u7814\u7a76\u751f\u8bfe\u7a0b 18.335: Introduction to numerical method \u4f9b\u4f60\u53c2\u8003\u3002
Languages are tools, you choose the right tool to do the right thing. Since there's no universally perfect tool, there's no universally perfect language.
\u4f5c\u4e3a\u8ba1\u7b97\u673a\u7cfb\u7684\u5b66\u751f\uff0c\u4e86\u89e3\u4e00\u4e9b\u57fa\u7840\u7684\u7535\u8def\u77e5\u8bc6\uff0c\u611f\u53d7\u4ece\u4f20\u611f\u5668\u6536\u96c6\u6570\u636e\u5230\u6570\u636e\u5206\u6790\u518d\u5230\u7b97\u6cd5\u9884\u6d4b\u6574\u6761\u6d41\u6c34\u7ebf\uff0c\u5bf9\u4e8e\u540e\u7eed\u77e5\u8bc6\u7684\u5b66\u4e60\u4ee5\u53ca\u8ba1\u7b97\u601d\u7ef4\u7684\u57f9\u517b\u8fd8\u662f\u5f88\u6709\u5e2e\u52a9\u7684\u3002EE16A&B: Designing Information Devices and Systems I&II \u662f\u4f2f\u514b\u5229 EE \u5b66\u751f\u7684\u5927\u4e00\u5165\u95e8\u8bfe\uff0c\u5176\u4e2d EE16A \u6ce8\u91cd\u901a\u8fc7\u7535\u8def\u4ece\u5b9e\u9645\u73af\u5883\u4e2d\u6536\u96c6\u548c\u5206\u6790\u6570\u636e\uff0c\u800c EE16B \u5219\u4fa7\u91cd\u4ece\u8fd9\u4e9b\u6536\u96c6\u5230\u7684\u6570\u636e\u8fdb\u884c\u5206\u6790\u5e76\u505a\u51fa\u9884\u6d4b\u884c\u4e3a\u3002
MIT 6.003: signal and systems \u63d0\u4f9b\u4e86\u5168\u90e8\u7684\u8bfe\u7a0b\u5f55\u5f71\u3001\u4e66\u9762\u4f5c\u4e1a\u4ee5\u53ca\u7b54\u6848\u3002\u4e5f\u53ef\u4ee5\u53bb\u770b\u8fd9\u95e8\u8bfe\u7684\u8fdc\u53e4\u7248\u672c
\u800c UCB EE120: Signal and Systems \u5173\u4e8e\u5085\u7acb\u53f6\u53d8\u6362\u7684 notes \u5199\u5f97\u975e\u5e38\u597d\uff0c\u5e76\u4e14\u63d0\u4f9b\u4e866 \u4e2a\u975e\u5e38\u6709\u8da3\u7684 Python \u7f16\u7a0b\u4f5c\u4e1a\uff0c\u8ba9\u4f60\u5b9e\u8df5\u4e2d\u8fd0\u7528\u4fe1\u53f7\u4e0e\u7cfb\u7edf\u7684\u7406\u8bba\u4e0e\u7b97\u6cd5\u3002
\u7b97\u6cd5\u662f\u8ba1\u7b97\u673a\u79d1\u5b66\u7684\u6838\u5fc3\uff0c\u4e5f\u662f\u51e0\u4e4e\u4e00\u5207\u4e13\u4e1a\u8bfe\u7a0b\u7684\u57fa\u7840\u3002\u5982\u4f55\u5c06\u5b9e\u9645\u95ee\u9898\u901a\u8fc7\u6570\u5b66\u62bd\u8c61\u8f6c\u5316\u4e3a\u7b97\u6cd5\u95ee\u9898\uff0c\u5e76\u9009\u7528\u5408\u9002\u7684\u6570\u636e\u7ed3\u6784\u5728\u65f6\u95f4\u548c\u5185\u5b58\u5927\u5c0f\u7684\u9650\u5236\u4e0b\u5c06\u5176\u89e3\u51b3\u662f\u7b97\u6cd5\u8bfe\u7684\u6c38\u6052\u4e3b\u9898\u3002\u5982\u679c\u4f60\u53d7\u591f\u4e86\u8001\u5e08\u7684\u7167\u672c\u5ba3\u79d1\uff0c\u90a3\u4e48\u6211\u5f3a\u70c8\u63a8\u8350\u4f2f\u514b\u5229\u7684 UCB CS61B: Data Structures and Algorithms \u548c\u666e\u6797\u65af\u987f\u7684 Coursera: Algorithms I & II\uff0c\u8fd9\u4e24\u95e8\u8bfe\u7684\u90fd\u8bb2\u5f97\u6df1\u5165\u6d45\u51fa\u5e76\u4e14\u4f1a\u6709\u4e30\u5bcc\u4e14\u6709\u8da3\u7684\u7f16\u7a0b\u5b9e\u9a8c\u5c06\u7406\u8bba\u4e0e\u77e5\u8bc6\u7ed3\u5408\u8d77\u6765\u3002
\u4ee5\u4e0a\u4e24\u95e8\u8bfe\u7a0b\u90fd\u662f\u57fa\u4e8e Java \u8bed\u8a00\uff0c\u5982\u679c\u4f60\u60f3\u5b66\u4e60 C/C++ \u63cf\u8ff0\u7684\u7248\u672c\uff0c\u53ef\u4ee5\u53c2\u8003\u65af\u5766\u798f\u7684\u6570\u636e\u7ed3\u6784\u4e0e\u57fa\u7840\u7b97\u6cd5\u8bfe\u7a0b Stanford CS106B/X: Programming Abstractions\u3002\u504f\u597d Python \u7684\u540c\u5b66\u53ef\u4ee5\u5b66\u4e60 MIT \u7684\u7b97\u6cd5\u5165\u95e8\u8bfe MIT 6.006: Introduction to Algorithms
\u5bf9\u4e00\u4e9b\u66f4\u9ad8\u7ea7\u7684\u7b97\u6cd5\u4ee5\u53ca NP \u95ee\u9898\u611f\u5174\u8da3\u7684\u540c\u5b66\u53ef\u4ee5\u5b66\u4e60\u4f2f\u514b\u5229\u7684\u7b97\u6cd5\u8bbe\u8ba1\u4e0e\u5206\u6790\u8bfe\u7a0b UCB CS170: Efficient Algorithms and Intractable Problems \u6216\u8005 MIT \u7684\u9ad8\u9636\u7b97\u6cd5 MIT 6.046: Design and Analysis of Algorithms\u3002
\u4e00\u4efd\u201c\u80fd\u8dd1\u201d\u7684\u4ee3\u7801\uff0c\u548c\u4e00\u4efd\u9ad8\u8d28\u91cf\u7684\u5de5\u4e1a\u7ea7\u4ee3\u7801\u662f\u6709\u672c\u8d28\u533a\u522b\u7684\u3002\u56e0\u6b64\u6211\u975e\u5e38\u63a8\u8350\u4f4e\u5e74\u7ea7\u7684\u540c\u5b66\u5b66\u4e60\u4e00\u4e0b MIT 6.031: Software Construction \u8fd9\u95e8\u8bfe\uff0c\u5b83\u4f1a\u4ee5 Java \u8bed\u8a00\u4e3a\u57fa\u7840\uff0c\u4ee5\u4e30\u5bcc\u7ec6\u81f4\u7684\u9605\u8bfb\u6750\u6599\u548c\u7cbe\u5fc3\u8bbe\u8ba1\u7684\u7f16\u7a0b\u7ec3\u4e60\u4f20\u6388\u5982\u4f55\u7f16\u5199\u4e0d\u6613\u51fa bug\u3001\u7b80\u660e\u6613\u61c2\u3001\u6613\u4e8e\u7ef4\u62a4\u4fee\u6539\u7684\u9ad8\u8d28\u91cf\u4ee3\u7801\u3002\u5927\u5230\u5b8f\u89c2\u6570\u636e\u7ed3\u6784\u8bbe\u8ba1\uff0c\u5c0f\u5230\u5982\u4f55\u5199\u6ce8\u91ca\uff0c\u9075\u5faa\u8fd9\u4e9b\u524d\u4eba\u603b\u7ed3\u7684\u7ec6\u8282\u548c\u7ecf\u9a8c\uff0c\u5bf9\u4e8e\u4f60\u6b64\u540e\u7684\u7f16\u7a0b\u751f\u6daf\u5927\u6709\u88e8\u76ca\u3002
\u5f53\u7136\uff0c\u5982\u679c\u4f60\u60f3\u7cfb\u7edf\u6027\u5730\u4e0a\u4e00\u95e8\u8f6f\u4ef6\u5de5\u7a0b\u7684\u8bfe\u7a0b\uff0c\u90a3\u6211\u63a8\u8350\u7684\u662f\u4f2f\u514b\u5229\u7684 UCB CS169: software engineering\u3002\u4f46\u9700\u8981\u63d0\u9192\u7684\u662f\uff0c\u548c\u5927\u591a\u5b66\u6821\uff08\u5305\u62ec\u8d35\u6821\uff09\u7684\u8f6f\u4ef6\u5de5\u7a0b\u8bfe\u7a0b\u4e0d\u540c\uff0c\u8fd9\u95e8\u8bfe\u4e0d\u4f1a\u6d89\u53ca\u4f20\u7edf\u7684 design and document \u6a21\u5f0f\uff0c\u5373\u5f3a\u8c03\u5404\u79cd\u7c7b\u56fe\u3001\u6d41\u7a0b\u56fe\u53ca\u6587\u6863\u8bbe\u8ba1\uff0c\u800c\u662f\u91c7\u7528\u8fd1\u4e9b\u5e74\u6d41\u884c\u8d77\u6765\u7684\u5c0f\u56e2\u961f\u5feb\u901f\u8fed\u4ee3 Agile Develepment \u5f00\u53d1\u6a21\u5f0f\u4ee5\u53ca\u5229\u7528\u4e91\u5e73\u53f0\u7684 Software as a service \u670d\u52a1\u6a21\u5f0f\u3002
MIT6.033: System Engineering \u662f MIT \u7684\u7cfb\u7edf\u5165\u95e8\u8bfe\uff0c\u4e3b\u9898\u6d89\u53ca\u4e86\u64cd\u4f5c\u7cfb\u7edf\u3001\u7f51\u7edc\u3001\u5206\u5e03\u5f0f\u548c\u7cfb\u7edf\u5b89\u5168\uff0c\u9664\u4e86\u77e5\u8bc6\u70b9\u7684\u4f20\u6388\u5916\uff0c\u8fd9\u95e8\u8bfe\u8fd8\u4f1a\u8bb2\u6388\u4e00\u4e9b\u5199\u4f5c\u548c\u8868\u8fbe\u4e0a\u7684\u6280\u5de7\uff0c\u8ba9\u4f60\u5b66\u4f1a\u5982\u4f55\u8bbe\u8ba1\u5e76\u5411\u522b\u4eba\u4ecb\u7ecd\u548c\u5206\u6790\u81ea\u5df1\u7684\u7cfb\u7edf\u3002\u8fd9\u672c\u4e66\u914d\u5957\u7684\u6559\u6750 Principles of Computer System Design: An Introduction \u4e5f\u5199\u5f97\u975e\u5e38\u597d\uff0c\u63a8\u8350\u5927\u5bb6\u9605\u8bfb\u3002
CMU 15-213: Introduction to Computer System \u662f CMU \u7684\u7cfb\u7edf\u5165\u95e8\u8bfe\uff0c\u5185\u5bb9\u8986\u76d6\u4e86\u4f53\u7cfb\u7ed3\u6784\u3001\u64cd\u4f5c\u7cfb\u7edf\u3001\u94fe\u63a5\u3001\u5e76\u884c\u3001\u7f51\u7edc\u7b49\u7b49\uff0c\u517c\u5177\u5e7f\u5ea6\u548c\u6df1\u5ea6\uff0c\u914d\u5957\u7684\u6559\u6750 Computer Systems: A Programmer's Perspective \u4e5f\u662f\u8d28\u91cf\u6781\u9ad8\uff0c\u5f3a\u70c8\u5efa\u8bae\u9605\u8bfb\u3002
NJU: Operating System Design and Implementation\uff0c\u5357\u4eac\u5927\u5b66\u7684\u848b\u708e\u5ca9\u8001\u5e08\u5f00\u8bbe\u7684\u64cd\u4f5c\u7cfb\u7edf\u8bfe\u7a0b\u3002\u848b\u8001\u5e08\u4ee5\u5176\u72ec\u5230\u7684\u7cfb\u7edf\u89c6\u89d2\u7ed3\u5408\u4e30\u5bcc\u7684\u4ee3\u7801\u793a\u4f8b\u5c06\u4f17\u591a\u64cd\u4f5c\u7cfb\u7edf\u7684\u6982\u5ff5\u8bb2\u5f97\u6df1\u5165\u6d45\u51fa\uff0c\u6b64\u5916\u8fd9\u95e8\u8bfe\u7684\u5168\u90e8\u8bfe\u7a0b\u5185\u5bb9\u90fd\u662f\u4e2d\u6587\u7684\uff0c\u975e\u5e38\u65b9\u4fbf\u5927\u5bb6\u5b66\u4e60\u3002
HIT OS: Operating System\uff0c\u54c8\u5c14\u6ee8\u5de5\u4e1a\u5927\u5b66\u7684\u674e\u6cbb\u519b\u8001\u5e08\u5f00\u8bbe\u7684\u4e2d\u6587\u64cd\u4f5c\u7cfb\u7edf\u8bfe\u7a0b\u3002\u674e\u8001\u5e08\u7684\u8bfe\u7a0b\u57fa\u4e8e Linux 0.11 \u6e90\u7801\uff0c\u5341\u5206\u6ce8\u91cd\u4ee3\u7801\u5b9e\u8df5\uff0c\u5e76\u7ad9\u5728\u5b66\u751f\u89c6\u89d2\u5c06\u64cd\u4f5c\u7cfb\u7edf\u7684\u6765\u9f99\u53bb\u8109\u5a13\u5a13\u9053\u6765\u3002
ASU CSE365: Introduction to Cybersecurity \u4e9a\u5229\u6851\u90a3\u5dde\u7acb\u5927\u5b66\u7684 Web \u5b89\u5168\u8bfe\u7a0b\uff0c\u4e3b\u8981\u6d89\u53ca\u6ce8\u5165\u3001\u6c47\u7f16\u4e0e\u5bc6\u7801\u5b66\u7684\u5185\u5bb9\u3002
ASU CSE466: Computer Systems Security \u4e9a\u5229\u6851\u90a3\u5dde\u7acb\u5927\u5b66\u7684\u7cfb\u7edf\u5b89\u5168\u8bfe\u7a0b\uff0c\u6d89\u53ca\u5185\u5bb9\u5168\u9762\u3002\u95e8\u69db\u8f83\u9ad8\uff0c\u9700\u8981\u5bf9 Linux, C \u4e0e Python \u5145\u5206\u719f\u6089\u3002
\u5176\u5b9e\u6570\u636e\u79d1\u5b66\u548c\u673a\u5668\u5b66\u4e60\u4e0e\u6df1\u5ea6\u5b66\u4e60\u6709\u7740\u5f88\u7d27\u5bc6\u7684\u8054\u7cfb\uff0c\u4f46\u53ef\u80fd\u66f4\u4fa7\u91cd\u4e8e\u5b9e\u8df5\u3002Berkeley \u7684 UCB Data100: Principles and Techniques of Data Science \u901a\u8fc7\u4e30\u5bcc\u7684\u7f16\u7a0b\u7ec3\u4e60\u8ba9\u4f60\u5728\u5b9e\u8df5\u4e2d\u638c\u63e1\u5404\u7c7b\u6570\u636e\u5206\u6790\u5de5\u5177\u548c\u7b97\u6cd5\uff0c\u5e76\u5e26\u9886\u4f60\u4f53\u9a8c\u4ece\u6d77\u91cf\u7684\u6570\u636e\u96c6\u4e2d\u63d0\u53d6\u51fa\u60f3\u8981\u7684\u7ed3\u679c\uff0c\u5e76\u5bf9\u672a\u6765\u7684\u6570\u636e\u6216\u7528\u6237\u7684\u884c\u4e3a\u505a\u51fa\u76f8\u5e94\u7684\u9884\u6d4b\u3002\u4f46\u8fd9\u53ea\u662f\u4e00\u95e8\u57fa\u7840\u8bfe\uff0c\u5982\u679c\u60f3\u5b66\u4e60\u5de5\u4e1a\u7ea7\u522b\u7684\u6570\u636e\u6316\u6398\u4e0e\u5206\u6790\u6280\u672f\uff0c\u53ef\u4ee5\u5c1d\u8bd5 Stanford \u7684\u5927\u6570\u636e\u6316\u6398\u8bfe\u7a0b CS246: Mining Massive Data Sets\u3002
\u673a\u5668\u5b66\u4e60\u9886\u57df\u8fd1\u4e9b\u5e74\u6700\u91cd\u8981\u7684\u8fdb\u5c55\u5c31\u662f\u53d1\u5c55\u51fa\u4e86\u57fa\u4e8e\u795e\u7ecf\u7f51\u7edc\u7684\u6df1\u5ea6\u5b66\u4e60\u5206\u652f\uff0c\u4f46\u5176\u5b9e\u5f88\u591a\u57fa\u4e8e\u7edf\u8ba1\u5b66\u4e60\u7684\u7b97\u6cd5\u4f9d\u7136\u5728\u6570\u636e\u5206\u6790\u9886\u57df\u6709\u7740\u5e7f\u6cdb\u7684\u5e94\u7528\u3002\u5982\u679c\u4f60\u4e4b\u524d\u4ece\u672a\u63a5\u89e6\u8fc7\u673a\u5668\u5b66\u4e60\u7684\u76f8\u5173\u77e5\u8bc6\uff0c\u800c\u4e14\u4e0d\u60f3\u4e00\u5f00\u59cb\u5c31\u9677\u5165\u8270\u6df1\u6666\u6da9\u7684\u6570\u5b66\u8bc1\u660e\uff0c\u90a3\u4e48\u4e0d\u59a8\u5148\u4ece Andrew Ng \uff08\u5434\u6069\u8fbe\uff09\u7684 Coursera: Machine Learning \u5b66\u8d77\u3002\u8fd9\u95e8\u8bfe\u5728\u673a\u5668\u5b66\u4e60\u9886\u57df\u57fa\u672c\u65e0\u4eba\u4e0d\u6653\uff0c\u5434\u6069\u8fbe\u4ee5\u5176\u6df1\u539a\u7684\u7406\u8bba\u529f\u5e95\u548c\u51fa\u8272\u7684\u8868\u8fbe\u80fd\u529b\u628a\u5f88\u591a\u8270\u6df1\u7684\u7b97\u6cd5\u8bb2\u5f97\u6df1\u5165\u6d45\u51fa\uff0c\u5e76\u4e14\u975e\u5e38\u5b9e\u7528\u3002\u5176\u914d\u5957\u7684\u4f5c\u4e1a\u4e5f\u662f\u8d28\u91cf\u76f8\u5f53\u4e0a\u4e58\uff0c\u53ef\u4ee5\u5e2e\u52a9\u4f60\u5feb\u901f\u5165\u95e8\u3002
\u524d\u51e0\u5e74 AlphaGo \u7684\u5927\u70ed\u8ba9\u6df1\u5ea6\u5b66\u4e60\u8fdb\u5165\u4e86\u5927\u4f17\u7684\u89c6\u91ce\uff0c\u4e0d\u5c11\u5927\u5b66\u751a\u81f3\u4e13\u95e8\u6210\u7acb\u4e86\u76f8\u5173\u4e13\u4e1a\u3002\u5f88\u591a\u8ba1\u7b97\u673a\u7684\u5176\u4ed6\u9886\u57df\u4e5f\u4f1a\u501f\u52a9\u6df1\u5ea6\u5b66\u4e60\u7684\u6280\u672f\u6765\u505a\u7814\u7a76\uff0c\u56e0\u6b64\u57fa\u672c\u4e0d\u7ba1\u4f60\u5e72\u5565\u591a\u5c11\u90fd\u4f1a\u63a5\u89e6\u5230\u4e00\u4e9b\u795e\u7ecf\u7f51\u7edc\u3001\u6df1\u5ea6\u5b66\u4e60\u76f8\u5173\u7684\u6280\u672f\u9700\u6c42\u3002\u5982\u679c\u60f3\u5feb\u901f\u5165\u95e8\uff0c\u540c\u6837\u63a8\u8350 Andrew Ng \uff08\u5434\u6069\u8fbe\uff09\u7684 Coursera: Deep Learning\uff0c\u8d28\u91cf\u65e0\u9700\u591a\u8a00\uff0cCoursera \u4e0a\u7f55\u89c1\u7684\u6ee1\u5206\u8bfe\u7a0b\u3002\u6b64\u5916\u5982\u679c\u4f60\u89c9\u5f97\u82f1\u6587\u8bfe\u7a0b\u5b66\u4e60\u8d77\u6765\u6709\u96be\u5ea6\uff0c\u63a8\u8350\u674e\u5b8f\u6bc5\u8001\u5e08\u7684 \u56fd\u7acb\u53f0\u6e7e\u5927\u5b66\uff1a\u673a\u5668\u5b66\u4e60 \u8bfe\u7a0b\u3002\u8fd9\u95e8\u8bfe\u6253\u7740\u673a\u5668\u5b66\u4e60\u7684\u540d\u53f7\uff0c\u5374\u56ca\u62ec\u4e86\u6df1\u5ea6\u5b66\u4e60\u9886\u57df\u7684\u51e0\u4e4e\u6240\u6709\u65b9\u5411\uff0c\u975e\u5e38\u5168\u9762\uff0c\u5f88\u9002\u5408\u4f60\u4ece\u5b8f\u89c2\u4e0a\u5bf9\u8fd9\u4e2a\u9886\u57df\u6709\u4e00\u4e2a\u5927\u81f4\u7684\u4e86\u89e3\u3002\u800c\u4e14\u8001\u5e08\u672c\u4eba\u4e5f\u975e\u5e38\u5e7d\u9ed8\uff0c\u8bfe\u5802\u91d1\u53e5\u9891\u51fa\u3002
MIT OpenCourseWare: \u9ebb\u7701\u7406\u5de5\u5b66\u9662\u7684\u8bfe\u7a0b\u8d44\u6e90\u5f00\u653e\u5171\u4eab\u9879\u76ee\uff0c\u6536\u5f55\u4e86\u6570\u4ee5\u5343\u8ba1\u7684\u5404\u79d1\u8bfe\u7a0b\u8d44\u6e90\uff0c\u5176\u4e2d\u8ba1\u7b97\u673a\u7c7b\u7684\u8bfe\u53f7\u662f 6.xxx\u3002
MIT CS Course List: \u9ebb\u7701\u7406\u5de5\u5b66\u9662\u7684 CS \u8bfe\u7a0b\u5217\u8868\u3002
\u5176\u4e00\u5c31\u662f\u4e86\u89e3\u5982\u4f55\u5199\u201c\u4f18\u96c5\u201d\u7684\u4ee3\u7801\u3002\u56fd\u5185\u7684\u5f88\u591a\u5927\u4e00\u7f16\u7a0b\u5165\u95e8\u8bfe\u90fd\u4f1a\u8bb2\u6210\u6781\u5176\u65e0\u804a\u7684\u8bed\u6cd5\u8bfe\uff0c\u5176\u6548\u679c\u8fd8\u4e0d\u5982\u76f4\u63a5\u8ba9\u5b66\u751f\u770b\u5b98\u65b9\u6587\u6863\u3002\u4e8b\u5b9e\u4e0a\uff0c\u5728\u521a\u5f00\u59cb\u63a5\u89e6\u7f16\u7a0b\u7684\u65f6\u5019\uff0c\u8ba9\u5b66\u751f\u8bd5\u7740\u53bb\u4e86\u89e3\u4ec0\u4e48\u6837\u7684\u4ee3\u7801\u662f\u4f18\u96c5\u7684\uff0c\u4ec0\u4e48\u6837\u7684\u4ee3\u7801 \"have bad taste\" \u662f\u5927\u6709\u88e8\u76ca\u7684\u3002\u4e00\u822c\u6765\u8bf4\uff0c\u7f16\u7a0b\u5165\u95e8\u8bfe\u4f1a\u5148\u4ecb\u7ecd\u8fc7\u7a0b\u5f0f\u7f16\u7a0b\uff08\u4f8b\u5982 C \u8bed\u8a00\uff09\u3002\u4f46\u5373\u4fbf\u662f\u9762\u5411\u8fc7\u7a0b\u7f16\u7a0b\uff0c\u6a21\u5757\u5316 \u548c \u5c01\u88c5 \u7684\u601d\u60f3\u4e5f\u6781\u5176\u91cd\u8981\u3002\u5982\u679c\u4f60\u53ea\u60f3\u7740\u4ee3\u7801\u80fd\u5728 OpenJudge \u4e0a\u901a\u8fc7\uff0c\u5199\u7684\u65f6\u5019\u56fe\u7701\u4e8b\uff0c\u7528\u5927\u6bb5\u7684\u590d\u5236\u7c98\u8d34\u548c\u81c3\u80bf\u7684 main \u51fd\u6570\uff0c\u957f\u6b64\u4ee5\u5f80\uff0c\u4f60\u7684\u4ee3\u7801\u8d28\u91cf\u5c06\u4e00\u76f4\u5982\u6b64\u3002\u4e00\u65e6\u63a5\u89e6\u7a0d\u5fae\u5927\u4e00\u70b9\u7684\u9879\u76ee\uff0c\u65e0\u5c3d\u7684 debug \u548c\u6c9f\u901a\u7ef4\u62a4\u6210\u672c\u5c06\u628a\u4f60\u541e\u6ca1\u3002\u56e0\u6b64\uff0c\u5199\u4ee3\u7801\u65f6\u4e0d\u65ad\u95ee\u81ea\u5df1\uff0c\u662f\u5426\u6709\u5927\u91cf\u91cd\u590d\u7684\u4ee3\u7801\uff1f\u5f53\u524d\u51fd\u6570\u662f\u5426\u8fc7\u4e8e\u590d\u6742\uff08Linux \u63d0\u5021\u6bcf\u4e2a\u51fd\u6570\u53ea\u9700\u8981\u505a\u597d\u4e00\u4ef6\u4e8b\uff09\uff1f\u8fd9\u6bb5\u4ee3\u7801\u80fd\u62bd\u8c61\u6210\u4e00\u4e2a\u51fd\u6570\u5417\uff1f\u4e00\u5f00\u59cb\u4f60\u53ef\u80fd\u89c9\u5f97\u5f88\u4e0d\u4e60\u60ef\uff0c\u751a\u81f3\u89c9\u5f97\u8fd9\u4e48\u7b80\u5355\u7684\u9898\u9700\u8981\u5982\u6b64\u5927\u8d39\u5468\u7ae0\u5417\uff1f\u4f46\u8bb0\u4f4f\u597d\u7684\u4e60\u60ef\u662f\u65e0\u4ef7\u7684\uff0cC \u8bed\u8a00\u521d\u4e2d\u751f\u90fd\u80fd\u5b66\u4f1a\uff0c\u51ed\u4ec0\u4e48\u516c\u53f8\u8981\u62db\u4f60\u53bb\u5f53\u7a0b\u5e8f\u5458\u5462\uff1f
\u5b66\u8fc7\u9762\u5411\u8fc7\u7a0b\u7f16\u7a0b\u540e\uff0c\u5927\u4e00\u4e0b\u5b66\u671f\u4e00\u822c\u4f1a\u8bb2\u9762\u5411\u5bf9\u8c61\u7f16\u7a0b\uff08\u4f8b\u5982 C++ \u6216 Java\uff09\u3002\u8fd9\u91cc\u975e\u5e38\u63a8\u8350\u5927\u5bb6\u770b MIT 6.031: Software Construction \u8fd9\u95e8\u8bfe\u7684 Notes\uff0c\u4f1a\u4ee5 Java \u8bed\u8a00\uff0822\u5e74\u6539\u7528\u4e86 TypeScript \u8bed\u8a00\uff09\u4e3a\u4f8b\u975e\u5e38\u8be6\u7ec6\u5730\u8bb2\u89e3\u5982\u4f55\u5199\u51fa\u201c\u4f18\u96c5\u201d\u7684\u4ee3\u7801\u3002\u4f8b\u5982 Test-Driven \u7684\u5f00\u53d1\u3001\u51fd\u6570 Specification \u7684\u8bbe\u8ba1\u3001\u5f02\u5e38\u7684\u5904\u7406\u7b49\u7b49\u7b49\u7b49\u3002\u9664\u6b64\u4e4b\u5916\uff0c\u65e2\u7136\u63a5\u89e6\u4e86\u9762\u5411\u5bf9\u8c61\uff0c\u90a3\u4e48\u4e86\u89e3\u4e00\u4e9b\u5e38\u89c1\u7684\u8bbe\u8ba1\u6a21\u5f0f\u4e5f\u662f\u5f88\u6709\u5fc5\u8981\u7684\u3002\u56e0\u4e3a\u56fd\u5185\u7684\u9762\u5411\u5bf9\u8c61\u8bfe\u7a0b\u540c\u6837\u5f88\u5bb9\u6613\u53d8\u6210\u6781\u5176\u65e0\u804a\u7684\u8bed\u6cd5\u8bfe\uff0c\u8ba9\u5b66\u751f\u7ea0\u7ed3\u4e8e\u5404\u79cd\u7ee7\u627f\u7684\u8bed\u6cd5\uff0c\u751a\u81f3\u51fa\u4e00\u4e9b\u65e0\u804a\u7684\u8111\u7b4b\u6025\u8f6c\u5f2f\u4e00\u6837\u7684\u9898\u76ee\uff0c\u6b8a\u4e0d\u77e5\u8fd9\u4e9b\u4e1c\u897f\u5728\u5730\u7403\u4eba\u7684\u5f00\u53d1\u4e2d\u57fa\u672c\u4e0d\u4f1a\u7528\u5230\u3002\u9762\u5411\u5bf9\u8c61\u7684\u7cbe\u9ad3\u662f\u8ba9\u5b66\u751f\u5b66\u4f1a\u81ea\u5df1\u5c06\u5b9e\u9645\u7684\u95ee\u9898\u62bd\u8c61\u6210\u82e5\u5e72\u7c7b\u548c\u5b83\u4eec\u4e4b\u95f4\u7684\u5173\u7cfb\uff0c\u800c\u8bbe\u8ba1\u6a21\u5f0f\u5219\u662f\u524d\u4eba\u603b\u7ed3\u51fa\u6765\u7684\u4e00\u4e9b\u7cbe\u9ad3\u7684\u62bd\u8c61\u65b9\u6cd5\u3002\u8fd9\u91cc\u63a8\u8350\u5927\u8bdd\u8bbe\u8ba1\u6a21\u5f0f \u8fd9\u672c\u4e66\uff0c\u5199\u5f97\u975e\u5e38\u6d45\u663e\u6613\u61c2\u3002
\u5176\u4e8c\u5c31\u662f\u5c1d\u8bd5\u5b66\u4e60\u4e00\u4e9b\u80fd\u63d0\u9ad8\u751f\u4ea7\u529b\u7684\u5de5\u5177\u548c\u6280\u80fd\uff0c\u4f8b\u5982 Git\u3001Shell\u3001Vim\u3002\u8fd9\u91cc\u5f3a\u70c8\u63a8\u8350\u5b66\u4e60 MIT missing semester \u8fd9\u95e8\u8bfe\uff0c\u4e5f\u8bb8\u4e00\u5f00\u59cb\u63a5\u89e6\u8fd9\u4e9b\u5de5\u5177\u7528\u8d77\u6765\u4f1a\u5f88\u4e0d\u4e60\u60ef\uff0c\u4f46\u5f3a\u8feb\u81ea\u5df1\u7528\uff0c\u719f\u7ec3\u4e4b\u540e\u5f00\u53d1\u6548\u7387\u4f1a\u76f4\u7ebf\u63d0\u9ad8\u3002\u6b64\u5916\uff0c\u8fd8\u6709\u5f88\u591a\u5e94\u7528\u4e5f\u80fd\u6781\u5927\u63d0\u9ad8\u7684\u4f60\u751f\u4ea7\u529b\u3002\u4e00\u6761\u5b9a\u5f8b\u662f\uff1a\u4e00\u5207\u9700\u8981\u8ba9\u624b\u79bb\u5f00\u952e\u76d8\u7684\u64cd\u4f5c\uff0c\u90fd\u5e94\u8be5\u60f3\u529e\u6cd5\u53bb\u9664\u3002\u4f8b\u5982\u5207\u6362\u5e94\u7528\u3001\u6253\u5f00\u6587\u4ef6\u3001\u6d4f\u89c8\u7f51\u9875\u8fd9\u4e9b\u90fd\u6709\u76f8\u5173\u63d2\u4ef6\u53ef\u4ee5\u5b9e\u73b0\u5feb\u6377\u64cd\u4f5c\uff08\u4f8b\u5982 Mac \u4e0a\u7684 Alfred\uff09\u3002\u5982\u679c\u4f60\u53d1\u73b0\u67d0\u4e2a\u64cd\u4f5c\u6bcf\u5929\u90fd\u4f1a\u7528\u5230\uff0c\u5e76\u4e14\u7528\u65f6\u8d85\u8fc71\u79d2\uff0c\u90a3\u5c31\u5e94\u8be5\u60f3\u529e\u6cd5\u628a\u5b83\u7f29\u51cf\u52300.1\u79d2\u3002\u6bd5\u7adf\u4ee5\u540e\u6570\u5341\u5e74\u4f60\u90fd\u8981\u548c\u7535\u8111\u6253\u4ea4\u9053\uff0c\u5f62\u6210\u4e00\u5957\u987a\u6ed1\u7684\u5de5\u4f5c\u6d41\u662f\u4e8b\u534a\u529f\u500d\u7684\u3002\u6700\u540e\uff0c\u5b66\u4f1a\u76f2\u6253\uff01\u5982\u679c\u4f60\u8fd8\u9700\u8981\u770b\u7740\u952e\u76d8\u6253\u5b57\uff0c\u90a3\u4e48\u8d76\u7d27\u4e0a\u7f51\u627e\u4e2a\u6559\u7a0b\u5b66\u4f1a\u76f2\u6253\uff0c\u8fd9\u5c06\u6781\u5927\u63d0\u9ad8\u4f60\u7684\u5f00\u53d1\u6548\u7387\u3002
\u5176\u4e09\u5c31\u662f\u5e73\u8861\u597d\u8bfe\u5185\u548c\u81ea\u5b66\u3002\u6211\u4eec\u8d28\u7591\u73b0\u72b6\uff0c\u4f46\u4e5f\u5f97\u9075\u5b88\u89c4\u5219\uff0c\u6bd5\u7adf\u7ee9\u70b9\u5728\u4fdd\u7814\u4e2d\u8fd8\u662f\u76f8\u5f53\u91cd\u8981\u7684\u3002\u56e0\u6b64\u5728\u5927\u4e00\uff0c\u6211\u8fd8\u662f\u5efa\u8bae\u5927\u5bb6\u5c3d\u91cf\u6309\u7167\u81ea\u5df1\u7684\u8bfe\u8868\u5b66\u4e60\uff0c\u4f46\u8f85\u4ee5\u4e00\u4e9b\u4f18\u8d28\u7684\u8bfe\u5916\u8d44\u6e90\u3002\u4f8b\u5982\u5fae\u79ef\u5206\u7ebf\u4ee3\u53ef\u4ee5\u53c2\u8003 MIT 18.01/18.02 \u548c MIT 18.06 \u7684\u8bfe\u7a0b Notes\u3002\u5047\u671f\u53ef\u4ee5\u901a\u8fc7 UCB CS61A \u6765\u5b66\u4e60 Python\u3002\u540c\u65f6\u505a\u5230\u4e0a\u9762\u7b2c\u4e00\u3001\u7b2c\u4e8c\u70b9\u8bf4\u7684\uff0c\u6ce8\u91cd\u597d\u7684\u7f16\u7a0b\u4e60\u60ef\u548c\u5b9e\u8df5\u80fd\u529b\u7684\u57f9\u517b\u3002\u5c31\u4e2a\u4eba\u7ecf\u9a8c\uff0c\u5927\u4e00\u7684\u6570\u5b66\u8bfe\u5b66\u5206\u5360\u6bd4\u76f8\u5f53\u5927\uff0c\u800c\u4e14\u6570\u5b66\u8003\u8bd5\u7684\u5185\u5bb9\u65b9\u5dee\u662f\u5f88\u5927\u7684\uff0c\u4e0d\u540c\u5b66\u6821\u4e0d\u540c\u8001\u5e08\u98ce\u683c\u8fe5\u5f02\uff0c\u81ea\u5b66\u4e5f\u8bb8\u80fd\u8ba9\u4f60\u9886\u609f\u6570\u5b66\u7684\u672c\u8d28\uff0c\u4f46\u672a\u5fc5\u80fd\u7ed9\u4f60\u4e00\u4e2a\u597d\u6210\u7ee9\u3002\u56e0\u6b64\u8003\u524d\u6700\u597d\u6709\u9488\u5bf9\u6027\u5730\u5237\u5f80\u5e74\u9898\uff0c\u5145\u5206\u5e94\u8bd5\u3002
\u8bfe\u7a0b\u65b9\u5411 \u8bfe\u7a0b\u540d \u79bb\u6563\u6570\u5b66\u548c\u6982\u7387\u8bba UCB CS70 : discrete Math and probability theory \u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5 Coursera: Algorithms I & II \u8f6f\u4ef6\u5de5\u7a0b MIT 6.031: Software Construction \u5168\u6808\u5f00\u53d1 MIT web development course \u8ba1\u7b97\u673a\u7cfb\u7edf\u5bfc\u8bba CMU CS15213: CSAPP \u4f53\u7cfb\u7ed3\u6784\u5165\u95e8 Coursera: Nand2Tetris \u4f53\u7cfb\u7ed3\u6784\u8fdb\u9636 CS61C: Great Ideas in Computer Architecture \u6570\u636e\u5e93\u539f\u7406 CMU 15-445: Introduction to Database System \u8ba1\u7b97\u673a\u7f51\u7edc Computer Networking: A Top-Down Approach \u4eba\u5de5\u667a\u80fd Harvard CS50: Introduction to AI with Python \u6df1\u5ea6\u5b66\u4e60 Coursera: Deep Learning"},{"location":"%E4%BD%BF%E7%94%A8%E6%8C%87%E5%8D%97/#_4","title":"\u5fc3\u6709\u6240\u5c5e","text":"
"},{"location":"Web%E5%BC%80%E5%8F%91/CS142/","title":"Stanford CS142: Web Applications","text":""},{"location":"Web%E5%BC%80%E5%8F%91/CS142/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
"},{"location":"Web%E5%BC%80%E5%8F%91/fullstackopen/","title":"University of Helsinki: Full Stack open 2022","text":""},{"location":"Web%E5%BC%80%E5%8F%91/fullstackopen/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u6240\u5c5e\u5927\u5b66\uff1aUniversity of Helsinki
"},{"location":"Web%E5%BC%80%E5%8F%91/mitweb/","title":"MIT Web Development Crash Course","text":""},{"location":"Web%E5%BC%80%E5%8F%91/mitweb/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
MIT \u5728\u6bcf\u5e74 1 \u6708\u4efd\u4f1a\u6709\u4e00\u4e2a\u4e3a\u671f 4 \u5468\u7684 Independent Activities Period (IAP)\uff0c\u5728\u8fd9\u4e2a\u6708\u91cc\uff0cMIT \u7684\u5b66\u751f\u548c\u8001\u5e08\u53ef\u4ee5\u81ea\u7531\u5730\u5f00\u8bbe\u5f88\u591a\u6709\u8da3\u7684\u8bfe\u7a0b\uff0c\u800c\u8fd9\u95e8\u7f51\u7ad9\u5f00\u53d1\u8bfe\u7a0b\u5c31\u662f\u5176\u4e2d\u4e4b\u4e00\u3002
\u5728\u4e00\u4e2a\u6708\u7684\u65f6\u95f4\u91cc\uff0c\u4f60\u4f1a\u4ece\u96f6\u5f00\u59cb\u638c\u63e1\u4e00\u4e2a\u7f51\u7ad9\u7684\u8bbe\u8ba1\u3001\u642d\u5efa\u3001\u7f8e\u5316\u3001\u4ea4\u4e92\u7b49\u7b49\u6838\u5fc3\u5185\u5bb9\uff0c\u57fa\u672c\u8986\u76d6\u4e86 Web \u5f00\u53d1\u7684\u524d\u540e\u7aef\u5927\u90e8\u5206\u6280\u672f\u6808\u3002\u5982\u679c\u4f60\u4e0d\u9700\u8981\u7cfb\u7edf\u5730\u5b66\u4e60\u7f51\u7edc\u5f00\u53d1\uff0c\u800c\u53ea\u662f\u51fa\u4e8e\u5174\u8da3\u60f3\u628a\u5b83\u52a0\u5165\u81ea\u5df1\u7684\u6280\u80fd\u5305\u91cc\uff0c\u90a3\u4e48\u8fd9\u95e8\u8bfe\u5c06\u975e\u5e38\u9002\u5408\u4f60\u3002
"},{"location":"%E4%BA%BA%E5%B7%A5%E6%99%BA%E8%83%BD/CS188/","title":"CS188: Introduction to Artificial Intelligence","text":""},{"location":"%E4%BA%BA%E5%B7%A5%E6%99%BA%E8%83%BD/CS188/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u4f2f\u514b\u5229\u7684\u4eba\u5de5\u667a\u80fd\u5165\u95e8\u8bfe\uff0c\u8bfe\u7a0b notes \u5199\u5f97\u975e\u5e38\u6df1\u5165\u6d45\u51fa\uff0c\u57fa\u672c\u4e0d\u9700\u8981\u89c2\u770b\u8bfe\u7a0b\u89c6\u9891\u3002\u8bfe\u7a0b\u5185\u5bb9\u7684\u5b89\u6392\u57fa\u672c\u6309\u7167\u4eba\u5de5\u667a\u80fd\u7684\u7ecf\u5178\u6559\u6750 Artificial intelligence: A Modern Approach \u7684\u7ae0\u8282\u987a\u5e8f\uff0c\u8986\u76d6\u4e86\u641c\u7d22\u526a\u679d\u3001\u7ea6\u675f\u6ee1\u8db3\u95ee\u9898\u3001\u9a6c\u5c14\u53ef\u592b\u51b3\u7b56\u8fc7\u7a0b\u3001\u5f3a\u5316\u5b66\u4e60\u3001\u8d1d\u53f6\u65af\u7f51\u7edc\u3001\u9690\u9a6c\u5c14\u53ef\u592b\u6a21\u578b\u4ee5\u53ca\u57fa\u7840\u7684\u673a\u5668\u5b66\u4e60\u548c\u795e\u7ecf\u7f51\u7edc\u7684\u76f8\u5173\u5185\u5bb9\u3002
2018\u5e74\u79cb\u5b63\u5b66\u671f\u7684\u7248\u672c\u514d\u8d39\u5f00\u653e\u4e86 gradescope\uff0c\u5927\u5bb6\u53ef\u4ee5\u5728\u7ebf\u5b8c\u6210\u4e66\u9762\u4f5c\u4e1a\u5e76\u5b9e\u65f6\u5f97\u5230\u6d4b\u8bc4\u7ed3\u679c\u3002\u540c\u65f6\u8bfe\u7a0b\u7684 6 \u4e2a Project \u4e5f\u662f\u8d28\u91cf\u7206\u70b8\uff0c\u590d\u73b0\u4e86\u7ecf\u5178\u7684 Packman\uff08\u5403\u8c46\u4eba\uff09\u5c0f\u6e38\u620f\uff0c\u4f1a\u8ba9\u4f60\u5229\u7528\u5b66\u5230\u7684 AI \u77e5\u8bc6\uff0c\u53bb\u5b9e\u73b0\u76f8\u5173\u7b97\u6cd5\uff0c\u8ba9\u4f60\u7684\u5403\u8c46\u4eba\u5728\u8ff7\u5bab\u91cc\u81ea\u7531\u7a7f\u68ad\uff0c\u8eb2\u907f\u9b3c\u602a\uff0c\u6536\u96c6\u8c46\u5b50\u3002
"},{"location":"%E4%BA%BA%E5%B7%A5%E6%99%BA%E8%83%BD/CS50/","title":"CS50\u2019s Introduction to AI with Python","text":""},{"location":"%E4%BA%BA%E5%B7%A5%E6%99%BA%E8%83%BD/CS50/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u4e00\u95e8\u975e\u5e38\u57fa\u7840\u7684 AI \u5165\u95e8\u8bfe\uff0c\u8ba9\u4eba\u773c\u524d\u4e00\u4eae\u7684\u662f 12 \u4e2a\u8bbe\u8ba1\u7cbe\u5de7\u7684\u7f16\u7a0b\u4f5c\u4e1a\uff0c\u90fd\u4f1a\u7528\u5b66\u5230\u7684 AI \u77e5\u8bc6\u53bb\u5b9e\u73b0\u4e00\u4e2a\u7b80\u6613\u7684\u6e38\u620f AI\uff0c\u6bd4\u5982\u7528\u5f3a\u5316\u5b66\u4e60\u8bad\u7ec3\u4e00\u4e2a Nim \u6e38\u620f\u7684 AI\uff0c\u7528 alpha-beta \u526a\u679d\u53bb\u626b\u96f7\u7b49\u7b49\uff0c\u975e\u5e38\u9002\u5408\u65b0\u624b\u5165\u95e8\u6216\u8005\u5927\u4f6c\u4f11\u95f2\u3002
We will learn the fundamental concepts of the different parts of modern computing systems, as well as the latest major research topics in Industry and Academia. We will extensively cover memory systems (including DRAM and new Non-Volatile Memory technologies, memory controllers, flash memory), new paradigms like processing-in-memory, parallel computing systems (including multicore processors, coherence and consistency, GPUs), heterogeneous computing, interconnection networks, specialized systems for major data-intensive workloads (e.g. graph analytics, bioinformatics, machine learning), etc. We will focus on fundamentals as well as cutting-edge research. Significant attention will be given to real-life examples and tradeoffs, as well as critical analysis of modern computing systems.
\u7f16\u7a0b\u5b9e\u8df5\u91c7\u53d6 Verilog \u8bbe\u8ba1\u548c\u6a21\u62df\u7c7b MIPS \u6d41\u6c34\u7ebf\u5904\u7406\u5668\u7684\u5bc4\u5b58\u5668\u4f20\u8f93\uff08RT\uff09\u5b9e\u73b0\uff0c\u4ee5\u6b64\u52a0\u5f3a\u5bf9\u7406\u8bba\u8bfe\u7a0b\u7684\u7406\u89e3\u3002\u56e0\u6b64\u524d\u51e0\u4e2a\u5b9e\u9a8c\u4f1a\u6709 verilog \u7684 CPU \u6d41\u6c34\u7ebf\u7f16\u7a0b\u3002\u540c\u65f6\u8fd8\u5c06\u4f7f\u7528C\u8bed\u8a00\u5f00\u53d1\u4e00\u4e2a\u5468\u671f\u7cbe\u786e\u7684\u5904\u7406\u5668\u6a21\u62df\u5668\uff0c\u5e76\u4f7f\u7528\u8be5\u6a21\u62df\u5668\u63a2\u7d22\u5904\u7406\u5668\u8bbe\u8ba1\u9009\u9879\u3002
"},{"location":"%E4%BD%93%E7%B3%BB%E7%BB%93%E6%9E%84/CS61C/","title":"CS61C: Great Ideas in Computer Architecture","text":""},{"location":"%E4%BD%93%E7%B3%BB%E7%BB%93%E6%9E%84/CS61C/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u8bfe\u7a0b\u6559\u67501\uff1aPatt and Patel, Introduction to Computing Systems
\u8bfe\u7a0b\u6559\u67502\uff1aHarris and Harris, Digital Design and Computer Architecture (MIPS Edition) \u4e2d\u6587\u8bd1\u672c\u4e3a\u300a\u6570\u5b57\u8bbe\u8ba1\u548c\u8ba1\u7b97\u673a\u4f53\u7cfb\u7ed3\u6784(\u539f\u4e66\u7b2c2\u7248)\u300b
\u542c\u8d77\u6765\u5c31\u5f88\u9177\u5bf9\u4e0d\u5bf9\uff1f\u5b9e\u73b0\u8d77\u6765\u66f4\u9177\uff01\u8fd9\u95e8\u8bfe\u5206\u4e3a\u786c\u4ef6\u548c\u8f6f\u4ef6\u4e24\u4e2a\u90e8\u5206\u3002\u5728\u786c\u4ef6\u90e8\u5206\uff0c\u4f60\u5c06\u8fdb\u5165 01 \u7684\u4e16\u754c\uff0c\u7528\u4e0e\u975e\u95e8\u6784\u9020\u51fa\u903b\u8f91\u7535\u8def\uff0c\u5e76\u9010\u6b65\u642d\u5efa\u51fa\u4e00\u4e2a CPU \u6765\u8fd0\u884c\u4e00\u5957\u8bfe\u7a0b\u4f5c\u8005\u5b9a\u4e49\u7684\u7b80\u6613\u6c47\u7f16\u4ee3\u7801\u3002\u5728\u8f6f\u4ef6\u90e8\u5206\uff0c\u4f60\u5c06\u7f16\u5199\u4e00\u4e2a\u7f16\u8bd1\u5668\uff0c\u5c06\u4f5c\u8005\u5f00\u53d1\u7684\u4e00\u4e2a\u540d\u4e3aJack\u7684\u9ad8\u7ea7\u8bed\u8a00\u7f16\u8bd1\u4e3a\u53ef\u4ee5\u8fd0\u884c\u5728\u865a\u62df\u673a\u4e0a\u7684\u5b57\u8282\u7801\uff0c\u7136\u540e\u8fdb\u4e00\u6b65\u7ffb\u8bd1\u4e3a\u6c47\u7f16\u4ee3\u7801\u3002\u4f60\u8fd8\u5c06\u5f00\u53d1\u4e00\u4e2a\u7b80\u6613\u7684 OS\uff0c\u8ba9\u4f60\u7684\u8ba1\u7b97\u673a\u652f\u6301\u8f93\u5165\u8f93\u51fa\u56fe\u5f62\u754c\u9762\u3002\u81f3\u6b64\uff0c\u4f60\u53ef\u4ee5\u7528 Jack \u5f00\u53d1\u4e00\u4e2a\u4fc4\u7f57\u65af\u65b9\u5757\u7684\u5c0f\u6e38\u620f\uff0c\u5c06\u5b83\u7f16\u8bd1\u4e3a\u6c47\u7f16\u4ee3\u7801\uff0c\u8fd0\u884c\u5728\u4f60\u7528\u4e0e\u975e\u95e8\u642d\u5efa\u51fa\u7684 CPU \u4e0a\uff0c\u901a\u8fc7\u4f60\u5f00\u53d1\u7684 OS \u8fdb\u884c\u4ea4\u4e92\u3002\u5b66\u5b8c\u8fd9\u95e8\u8bfe\u7a0b\uff0c\u4f60\u5c06\u5bf9\u6574\u4e2a\u8ba1\u7b97\u673a\u7684\u4f53\u7cfb\u7ed3\u6784\u6709\u4e00\u4e2a\u5168\u5c40\u4e14\u6df1\u523b\u7684\u7406\u89e3\uff0c\u5bf9\u4e8e\u4f60\u540e\u7eed\u8bfe\u7a0b\u7684\u5b66\u4e60\u6709\u7740\u83ab\u5927\u7684\u5e2e\u52a9\u3002
\u8fd9\u95e8\u8bfe\u548c MIT 6.S081 \u4e00\u6837\uff0c\u51fa\u54c1\u81ea MIT \u5927\u540d\u9f0e\u9f0e\u7684 PDOS \u5b9e\u9a8c\u5ba4\uff0c\u6388\u8bfe\u8001\u5e08 Robert Morris \u6559\u6388\u66fe\u662f\u4e00\u4f4d\u9876\u5c16\u9ed1\u5ba2\uff0c\u4e16\u754c\u4e0a\u7b2c\u4e00\u4e2a\u8815\u866b\u75c5\u6bd2 Morris \u75c5\u6bd2\u5c31\u662f\u51fa\u81ea\u4ed6\u4e4b\u624b\u3002
CMake \u662f\u7c7b\u4f3c\u4e8e GNU make \u7684\u8de8\u5e73\u53f0\u81ea\u52a8\u8f6f\u4ef6\u6784\u5efa\u5de5\u5177\uff0c\u4f7f\u7528 CMakeLists.txt \u5b9a\u4e49\u6784\u5efa\u89c4\u5219\uff0c\u76f8\u6bd4\u4e8e make \u5b83\u63d0\u4f9b\u4e86\u66f4\u591a\u7684\u529f\u80fd\uff0c\u5728\u5404\u79cd\u8f6f\u4ef6\u6784\u5efa\u4e0a\u5e7f\u6cdb\u4f7f\u7528\u3002\u5f3a\u70c8\u5efa\u8bae\u5b66\u4e60\u4f7f\u7528 GNU Make \u548c\u719f\u6089 Makefile \u540e\u518d\u5b66\u4e60 CMake\u3002
Emacs \u662f\u4e00\u4e2a\u4e0e Vim \u9f50\u540d\u7684\u5f3a\u5927\u7f16\u8f91\u5668\uff0c\u4e8b\u5b9e\u4e0a Emacs \u51e0\u4e4e\u5177\u6709 Vim \u7684\u6240\u6709\u597d\u5904\uff0c\u4f8b\u5982\uff1a
Emacs \u5bf9 Vim \u7528\u6237\u4e5f\u5341\u5206\u53cb\u597d\uff0c\u6709\u4e00\u4e2a\u53eb evil \u7684\u63d2\u4ef6\u53ef\u4ee5\u8ba9\u7528\u6237\u5728 Emacs \u4e2d\u4f7f\u7528 Vim \u7684\u57fa\u672c\u64cd\u4f5c\uff0c\u53ea\u9700\u8981\u5f88\u4f4e\u7684\u8fc1\u79fb\u6210\u672c\u5373\u53ef\u4ece Vim \u8f6c\u5230 Emacs\u3002\u66fe\u7ecf\u6709\u7edf\u8ba1\u663e\u793a\u6709\u76f8\u5f53\u4e00\u90e8\u5206\u7528\u6237\u4f1a\u4ece Vim \u8f6c\u5230 Emacs\uff0c\u4f46\u51e0\u4e4e\u6ca1\u6709\u7528\u6237\u4ece Emacs \u8f6c\u5230 Vim\u3002\u4e8b\u5b9e\u4e0a\uff0cEmacs \u76f8\u5bf9 Vim \u6700\u5927\u7684\u4e0d\u8db3\u662f\u7eaf\u6587\u672c\u7f16\u8f91\u65b9\u9762\u4e0d\u5982 Vim \u7684\u591a\u6a21\u6001\u7f16\u8f91\u6548\u7387\u9ad8\uff0c\u4f46\u51ed\u501f\u5176\u5f3a\u5927\u7684\u6269\u5c55\u6027\uff0cEmacs \u53ef\u4ee5\u626c\u957f\u907f\u77ed\uff0c\u628a Vim \u5438\u6536\u8fdb\u6765\uff0c\u7ed3\u5408\u4e86\u4e8c\u8005\u7684\u957f\u5904\u3002
Emacs \u7684\u552f\u4e00\u7f3a\u70b9\u4fbf\u662f\u5bf9 Ctrl \u952e\u7684\u4f7f\u7528\u8fc7\u591a\uff0c\u5bf9\u5c0f\u624b\u6307\u4e0d\u662f\u5f88\u53cb\u597d\uff0c\u5f3a\u70c8\u5efa\u8bae\u66f4\u6539 Ctrl \u952e\u7684\u952e\u76d8\u6620\u5c04\u3002\u66f4\u6539\u6620\u5c04\u7684\u65b9\u5f0f\u4e0e Vim \u6559\u7a0b\u4e2d\u7684\u65b9\u6cd5\u76f8\u540c\uff0c\u8fd9\u91cc\u4e0d\u505a\u8d58\u8ff0\u3002
"},{"location":"%E5%BF%85%E5%AD%A6%E5%B7%A5%E5%85%B7/GNU_Make/","title":"GNU Make","text":""},{"location":"%E5%BF%85%E5%AD%A6%E5%B7%A5%E5%85%B7/GNU_Make/#gnu-make_1","title":"\u4e3a\u4ec0\u4e48\u5b66 GNU Make","text":"
\u5927\u5bb6\u7b2c\u4e00\u6b21\u5199 hello world \u7a0b\u5e8f\u7684\u65f6\u5019\u4e00\u5b9a\u90fd\u8bb0\u5f97\uff0c\u5728\u7f16\u8f91\u5b8c helloworld.c \u4e4b\u540e\uff0c\u9700\u8981\u7528 gcc \u7f16\u8bd1\u751f\u6210\u53ef\u6267\u884c\u6587\u4ef6\uff0c\u7136\u540e\u518d\u6267\u884c\uff08\u5982\u679c\u4f60\u4e0d\u7406\u89e3\u524d\u9762\u8fd9\u6bb5\u8bdd\uff0c\u8bf7\u5148\u81ea\u884c\u8c37\u6b4c gcc \u7f16\u8bd1 \u5e76\u7406\u89e3\u76f8\u5173\u5185\u5bb9\uff09\u3002\u4f46\u5982\u679c\u4f60\u7684\u9879\u76ee\u7531\u6210\u767e\u4e0a\u5343\u4e2a C \u6e90\u6587\u4ef6\u7ec4\u6210\uff0c\u5e76\u4e14\u661f\u7f57\u68cb\u5e03\u5728\u5404\u4e2a\u5b50\u76ee\u5f55\u4e0b\uff0c\u4f60\u8be5\u5982\u4f55\u5c06\u5b83\u4eec\u7f16\u8bd1\u94fe\u63a5\u5230\u4e00\u8d77\u5462\uff1f\u5047\u5982\u4f60\u7684\u9879\u76ee\u7f16\u8bd1\u4e00\u6b21\u9700\u8981\u534a\u4e2a\u5c0f\u65f6\uff08\u5927\u578b\u9879\u76ee\u76f8\u5f53\u5e38\u89c1\uff09\uff0c\u800c\u4f60\u53ea\u4fee\u6539\u4e86\u4e00\u4e2a\u5206\u53f7\uff0c\u662f\u4e0d\u662f\u8fd8\u9700\u8981\u518d\u7b49\u534a\u4e2a\u5c0f\u65f6\u5462\uff1f
\u8fd9\u65f6\u5019 GNU Make \u5c31\u95ea\u4eae\u767b\u573a\u4e86\uff0c\u5b83\u80fd\u8ba9\u4f60\u5728\u4e00\u4e2a\u811a\u672c\u91cc\uff08\u5373\u6240\u8c13\u7684 Makefile\uff09\u5b9a\u4e49\u6574\u4e2a\u7f16\u8bd1\u6d41\u7a0b\u4ee5\u53ca\u5404\u4e2a\u76ee\u6807\u6587\u4ef6\u4e0e\u6e90\u6587\u4ef6\u4e4b\u95f4\u7684\u4f9d\u8d56\u5173\u7cfb\uff0c\u5e76\u4e14\u53ea\u91cd\u65b0\u7f16\u8bd1\u4f60\u7684\u4fee\u6539\u4f1a\u5f71\u54cd\u5230\u7684\u90e8\u5206\uff0c\u4ece\u800c\u964d\u4f4e\u7f16\u8bd1\u7684\u65f6\u95f4\u3002
"},{"location":"%E5%BF%85%E5%AD%A6%E5%B7%A5%E5%85%B7/GNU_Make/#gnu-make_2","title":"\u5982\u4f55\u5b66\u4e60 GNU Make","text":"
GNU Make \u638c\u63e1\u8d77\u6765\u76f8\u5bf9\u5bb9\u6613\uff0c\u4f46\u7528\u597d\u5b83\u9700\u8981\u4e0d\u65ad\u7684\u7ec3\u4e60\u3002\u5c06\u5b83\u878d\u5165\u5230\u81ea\u5df1\u7684\u65e5\u5e38\u5f00\u53d1\u4e2d\uff0c\u52e4\u4e8e\u5b66\u4e60\u548c\u6a21\u4eff\u5176\u4ed6\u4f18\u79c0\u5f00\u6e90\u9879\u76ee\u91cc\u7684 Makefile \u7684\u5199\u6cd5\uff0c\u603b\u7ed3\u51fa\u9002\u5408\u81ea\u5df1\u7684 template\uff0c\u4e45\u800c\u4e45\u4e4b\uff0c\u4f60\u5bf9 GNU Make \u7684\u4f7f\u7528\u4f1a\u6108\u52a0\u7eaf\u719f\u3002
\u4f46\u76f8\u4fe1\u6211\uff0c\u548c Vim \u4e00\u6837\uff0cGit \u662f\u4e00\u6b3e\u4f60\u6700\u7ec8\u638c\u63e1\u4e4b\u540e\u4f1a\u611f\u53f9\u201c\u5b83\u503c\u5f97\uff01\u201d\u7684\u795e\u5668\u3002
\u548c Vim \u4e0d\u540c\uff0c\u6211\u4e0d\u5efa\u8bae\u521d\u5b66\u8005\u5728\u4e00\u77e5\u534a\u89e3\u7684\u60c5\u51b5\u4e0b\u8d38\u7136\u4f7f\u7528 Git\uff0c\u56e0\u4e3a\u5b83\u7684\u5185\u90e8\u903b\u8f91\u5e76\u4e0d\u80fd\u719f\u80fd\u751f\u5de7\uff0c\u800c\u662f\u9700\u8981\u82b1\u65f6\u95f4\u53bb\u7406\u89e3\u3002\u6211\u63a8\u8350\u7684\u5b66\u4e60\u8def\u7ebf\u5982\u4e0b\uff1a
GitHub \u4e4b\u6240\u4ee5\u6210\u529f\uff0c\u6211\u60f3\u662f\u5f97\u76ca\u4e8e\u201c\u6211\u4e3a\u4eba\u4eba\uff0c\u4eba\u4eba\u4e3a\u6211\u201d\u7684\u5f00\u6e90\u7cbe\u795e\uff0c\u5f97\u76ca\u4e8e\u77e5\u8bc6\u5206\u4eab\u7684\u5feb\u4e50\u3002\u5982\u679c\u4f60\u4e5f\u60f3\u6210\u4e3a\u4e0b\u4e00\u4e2a\u4e07\u4eba\u656c\u4ef0\u7684\u5f00\u6e90\u5927\u4f6c\uff0c\u6216\u8005\u4e0b\u4e00\u4e2a star \u7834\u4e07\u7684\u9879\u76ee\u4f5c\u8005\u3002\u90a3\u5c31\u628a\u4f60\u5728\u5f00\u53d1\u8fc7\u7a0b\u4e2d\u7075\u611f\u4e00\u73b0\u7684 idea \u5316\u4f5c\u4ee3\u7801\uff0c\u5c55\u793a\u5728 GitHub \u4e0a\u5427\uff5e
\u5728 Windows \u4e0b\uff0c\u642d\u5efa\u5f00\u53d1\u73af\u5883\u4e00\u76f4\u662f\u4e00\u4e2a\u590d\u6742\u4e14\u56f0\u96be\u7684\u95ee\u9898\u3002\u7531\u4e8e\u6ca1\u6709\u4e00\u4e2a\u7edf\u4e00\u7684\u6807\u51c6\uff0c\u5bfc\u81f4\u5404\u79cd\u5f00\u53d1\u73af\u5883\u7684\u5b89\u88c5\u65b9\u5f0f\u5dee\u5f02\u5de8\u5927\uff0c\u9700\u8981\u4ed8\u51fa\u5f88\u591a\u4e0d\u5fc5\u8981\u7684\u65f6\u95f4\u6210\u672c\u3002\u800c Scoop \u53ef\u4ee5\u5e2e\u52a9\u4f60\u7edf\u4e00\u5b89\u88c5\u5e76\u7ba1\u7406\u5e38\u89c1\u7684\u5f00\u53d1\u8f6f\u4ef6\uff0c\u7701\u53bb\u4e86\u624b\u52a8\u4e0b\u8f7d\u5b89\u88c5\uff0c\u914d\u7f6e\u73af\u5883\u53d8\u91cf\u7b49\u7e41\u7410\u6b65\u9aa4\u3002
Scoop \u9700\u8981 Windows PowerShell 5.1 \u6216\u8005 PowerShell \u4f5c\u4e3a\u8fd0\u884c\u73af\u5883\uff0c\u5982\u679c\u4f60\u4f7f\u7528\u7684\u662f Windows 10 \u53ca\u4ee5\u4e0a\u7248\u672c\uff0cWindows PowerShell \u662f\u5185\u7f6e\u5728\u7cfb\u7edf\u4e2d\u7684\u3002\u800c Windows 7 \u5185\u7f6e\u7684 Windows PowerShell \u7248\u672c\u8fc7\u4e8e\u9648\u65e7\uff0c\u4f60\u9700\u8981\u624b\u52a8\u5b89\u88c5\u65b0\u7248\u672c\u7684 PowerShell\u3002
\u7531\u4e8e\u53d1\u73b0\u5f88\u591a\u540c\u5b66\u5728\u8bbe\u7f6e Windows \u7528\u6237\u65f6\u4f7f\u7528\u4e86\u4e2d\u6587\u7528\u6237\u540d\uff0c\u5bfc\u81f4\u4e86\u7528\u6237\u76ee\u5f55\u4e5f\u53d8\u6210\u4e86\u4e2d\u6587\u540d\u3002\u5982\u679c\u6309\u7167 Scoop \u7684\u9ed8\u8ba4\u65b9\u5f0f\u5c06\u8f6f\u4ef6\u5b89\u88c5\u5230\u7528\u6237\u76ee\u5f55\u4e0b\uff0c\u53ef\u80fd\u4f1a\u9020\u6210\u90e8\u5206\u8f6f\u4ef6\u6267\u884c\u9519\u8bef\u3002\u6240\u4ee5\u8fd9\u91cc\u63a8\u8350\u5b89\u88c5\u5230\u81ea\u5b9a\u4e49\u76ee\u5f55\uff0c\u5982\u679c\u9700\u8981\u5176\u4ed6\u5b89\u88c5\u65b9\u5f0f\u8bf7\u53c2\u8003\uff1a ScoopInstaller/Install
Vim \u7684\u5b8f\u64cd\u4f5c\u53ef\u4ee5\u6279\u91cf\u5316\u5904\u7406\u91cd\u590d\u64cd\u4f5c\uff08\u4f8b\u5982\u591a\u884c tab\uff0c\u6279\u91cf\u52a0\u53cc\u5f15\u53f7\u7b49\u7b49\uff09
Vim \u662f\u5f88\u591a\u670d\u52a1\u5668\u81ea\u5e26\u7684\u547d\u4ee4\u884c\u7f16\u8f91\u5668\uff0c\u5f53\u4f60\u901a\u8fc7 ssh \u8fde\u63a5\u8fdc\u7a0b\u670d\u52a1\u5668\u4e4b\u540e\uff0c\u7531\u4e8e\u6ca1\u6709\u56fe\u5f62\u754c\u9762\uff0c\u53ea\u80fd\u5728\u547d\u4ee4\u884c\u91cc\u8fdb\u884c\u5f00\u53d1\uff08\u5f53\u7136\u73b0\u5728\u5f88\u591a IDE \u5982 PyCharm \u63d0\u4f9b\u4e86 ssh \u63d2\u4ef6\u53ef\u4ee5\u89e3\u51b3\u8fd9\u4e2a\u95ee\u9898\uff09\u3002
\u4e0d\u5e78\u7684\u662f Vim \u7684\u5b66\u4e60\u66f2\u7ebf\u786e\u5b9e\u76f8\u5f53\u9661\u5ced\uff0c\u6211\u82b1\u4e86\u597d\u51e0\u4e2a\u661f\u671f\u624d\u6162\u6162\u9002\u5e94\u4e86\u7528 Vim \u8fdb\u884c\u5f00\u53d1\u7684\u8fc7\u7a0b\u3002\u6700\u5f00\u59cb\u4f60\u4f1a\u89c9\u5f97\u975e\u5e38\u4e0d\u9002\u5e94\uff0c\u4f46\u4e00\u65e6\u71ac\u8fc7\u4e86\u521d\u59cb\u9636\u6bb5\uff0c\u76f8\u4fe1\u6211\uff0c\u4f60\u4f1a\u7231\u4e0a Vim\u3002
Vim \u7684\u5b66\u4e60\u8d44\u6599\u6d69\u5982\u70df\u6d77\uff0c\u4f46\u638c\u63e1\u5b83\u6700\u597d\u7684\u65b9\u5f0f\u8fd8\u662f\u5c06\u5b83\u7528\u5728\u65e5\u5e38\u7684\u5f00\u53d1\u8fc7\u7a0b\u4e2d\uff0c\u800c\u4e0d\u662f\u4e00\u4e0a\u6765\u5c31\u53bb\u5b66\u5404\u79cd\u82b1\u91cc\u80e1\u54e8\u7684\u9ad8\u7ea7 Vim \u6280\u5de7\u3002\u4e2a\u4eba\u63a8\u8350\u7684\u5b66\u4e60\u8def\u7ebf\u5982\u4e0b\uff1a
\u5148\u9605\u8bfb\u8fd9\u7bc7 tutorial\uff0c\u638c\u63e1\u57fa\u672c\u7684 Vim \u6982\u5ff5\u548c\u4f7f\u7528\u65b9\u5f0f\uff0c\u4e0d\u60f3\u770b\u82f1\u6587\u7684\u53ef\u4ee5\u9605\u8bfb\u8fd9\u7bc7\u6559\u7a0b\u3002
\u7528 Vim \u81ea\u5e26\u7684 vimtutor \u8fdb\u884c\u7ec3\u4e60\uff0c\u5b89\u88c5\u5b8c Vim \u4e4b\u540e\u76f4\u63a5\u5728\u547d\u4ee4\u884c\u91cc\u8f93\u5165 vimtutor \u5373\u53ef\u8fdb\u5165\u7ec3\u4e60\u7a0b\u5e8f\u3002
\u6700\u540e\u5c31\u662f\u5f3a\u8feb\u81ea\u5df1\u4f7f\u7528 Vim \u8fdb\u884c\u5f00\u53d1\uff0cIDE \u91cc\u53ef\u4ee5\u5b89\u88c5 Vim \u63d2\u4ef6\u3002
\u7b49\u4f60\u5b8c\u5168\u9002\u5e94 Vim \u4e4b\u540e\u65b0\u7684\u4e16\u754c\u4fbf\u5411\u4f60\u655e\u5f00\u4e86\u5927\u95e8\uff0c\u4f60\u53ef\u4ee5\u6309\u9700\u914d\u7f6e\u81ea\u5df1\u7684 Vim\uff08\u4fee\u6539 .vimrc \u6587\u4ef6\uff09\uff0c\u7f51\u4e0a\u6709\u6570\u4e0d\u80dc\u6570\u7684\u8d44\u6e90\u53ef\u4ee5\u501f\u9274\u3002
\u5982\u679c\u4f60\u60f3\u5bf9\u914d\u7f6e Vim \u6709\u66f4\u52a0\u6df1\u5165\u7684\u4e86\u89e3\uff0cLearn Vim Script the Hard Way \u662f\u4e00\u4e2a\u5f88\u597d\u7684\u8d44\u6e90\u3002
2022\u5e74\uff0c\u6211\u672c\u79d1\u6bd5\u4e1a\u4e86\u3002\u5728\u5f00\u59cb\u52a8\u624b\u5199\u6bd5\u4e1a\u8bba\u6587\u7684\u65f6\u5019\uff0c\u6211\u5c34\u5c2c\u5730\u53d1\u73b0\uff0c\u6211\u5bf9 Word \u7684\u638c\u63e1\u7a0b\u5ea6\u4ec5\u9650\u4e8e\u8c03\u8282\u5b57\u4f53\u3001\u4fdd\u5b58\u5bfc\u51fa\u8fd9\u4e9b\u50bb\u74dc\u529f\u80fd\u3002\u66fe\u60f3\u8f6c\u6218 Latex\uff0c\u4f46\u8bba\u6587\u7684\u6bb5\u843d\u683c\u5f0f\u8981\u6c42\u8c03\u6574\u8d77\u6765\u8fd8\u662f\u7528 Word \u66f4\u4e3a\u65b9\u4fbf\uff0c\u7ecf\u8fc7\u4e00\u756a\u75db\u82e6\u7f20\u6597\u4e4b\u540e\uff0c\u603b\u7b97\u662f\u6709\u60ca\u65e0\u9669\u5730\u5b8c\u6210\u4e86\u8bba\u6587\u7684\u5199\u4f5c\u548c\u7b54\u8fa9\u3002\u4e3a\u4e86\u4e0d\u8ba9\u540e\u6765\u8005\u91cd\u8e48\u8986\u8f99\uff0c\u9042\u628a\u76f8\u5173\u8d44\u6e90\u6574\u7406\u6210\u4e00\u4efd\u5f00\u7bb1\u5373\u7528\u7684\u6587\u6863\uff0c\u4f9b\u5927\u5bb6\u53c2\u8003\u3002
"},{"location":"%E5%BF%85%E5%AD%A6%E5%B7%A5%E5%85%B7/thesis/#word","title":"\u5982\u4f55\u7528 Word \u5199\u6bd5\u4e1a\u8bba\u6587","text":"
\u6b63\u5982\u5c06\u5927\u8c61\u88c5\u8fdb\u51b0\u7bb1\u9700\u8981\u4e09\u6b65\uff0c\u7528 Word \u5199\u6bd5\u4e1a\u8bba\u6587\u4e5f\u53ea\u9700\u8981\u7b80\u5355\u4e09\u6b65\uff1a
\u5b66\u4e60 Word \u6392\u7248\uff1a\u5230\u8fbe\u8fd9\u4e00\u6b65\u7684\u7ae5\u978b\u5206\u4e3a\u4e24\u7c7b\uff0c\u4e00\u662f\u5df2\u7ecf\u62e5\u6709\u4e86\u5b66\u9662\u63d0\u4f9b\u7684\u6807\u51c6\u6a21\u7248\uff0c\u4e8c\u662f\u53ea\u6709\u4e00\u4efd\u865a\u65e0\u7f25\u7f08\u7684\u683c\u5f0f\u8981\u6c42\u3002\u90a3\u73b0\u5728\u5f53\u52a1\u4e4b\u6025\u5c31\u662f\u5b66\u4e60\u57fa\u7840\u7684 Word \u6392\u7248\u6280\u672f\uff0c\u5bf9\u4e8e\u524d\u8005\u53ef\u4ee5\u5b66\u4f1a\u4f7f\u7528\u6a21\u7248\uff0c\u5bf9\u4e8e\u540e\u8005\u5219\u53ef\u4ee5\u5b66\u4f1a\u5236\u4f5c\u6a21\u7248\u3002\u6b64\u65f6\u5207\u8bb0\u4e0d\u8981\u96c4\u5fc3\u52c3\u52c3\u5730\u9009\u62e9\u4e00\u4e2a\u5341\u51e0\u4e2a\u5c0f\u65f6\u7684 Word \u6559\u5b66\u89c6\u9891\u5f00\u59cb\u5934\u60ac\u6881\u9525\u523a\u80a1\uff0c\u56e0\u4e3a\u751f\u4ea7\u4e00\u4efd\u5e94\u4ed8\u6bd5\u4e1a\u7684\u5b66\u672f\u5783\u573e\u53ea\u8981\u5b66\u534a\u5c0f\u65f6\u80fd\u4e0a\u624b\u5c31\u591f\u4e86\u3002\u6211\u5f53\u65f6\u770b\u7684\u4e00\u4e2a B \u7ad9\u7684\u6559\u5b66\u89c6\u9891\uff0c\u77ed\u5c0f\u7cbe\u608d\u975e\u5e38\u5b9e\u7528\uff0c\u5168\u957f\u534a\u5c0f\u65f6\u6781\u901f\u5165\u95e8\u3002
MSDN,\u6211\u544a\u8bc9\u4f60: Windows \u64cd\u4f5c\u7cfb\u7edf\u955c\u50cf\u4e0b\u8f7d\u7ad9\uff0c\u4e5f\u6709\u8bb8\u591a\u5176\u4ed6\u8f6f\u4ef6\u7684\u4e0b\u8f7d\u3002
OI Wiki: \u7f16\u7a0b\u7ade\u8d5b\u77e5\u8bc6\u6574\u5408\u7ad9\u70b9\u3002
Microsoft Learn: \u5fae\u8f6f\u5b98\u65b9\u7684\u5b66\u4e60\u5e73\u53f0\uff0c\u5305\u542b\u4e86\u7edd\u5927\u591a\u6570\u5fae\u8f6f\u4ea7\u54c1\u7684\u6587\u6863\u3002
Arch Wiki: \u4e13\u4e3a Arch Linux \u800c\u5199\u7684 Wiki\uff0c\u5305\u542b\u4e86\u5927\u91cf Linux \u76f8\u5173\u7684\u77e5\u8bc6\u3002
\u867d\u7136\u4e00\u624b\u4fe1\u606f\u5f88\u91cd\u8981\uff0c\u4f46\u540e\u9762\u7684 N \u624b\u4fe1\u606f\u5e76\u975e\u4e00\u65e0\u662f\u5904\uff0c\u56e0\u4e3a\u8fd9 N \u624b\u8d44\u6599\u91cc\u5305\u542b\u4e86\u4f5c\u8005\u5bf9\u6e90\u77e5\u8bc6\u7684\u8f6c\u5316\u2014\u2014\u4f8b\u5982\u57fa\u4e8e\u67d0\u79cd\u903b\u8f91\u7684\u68b3\u7406\uff08\u6d41\u7a0b\u56fe\u3001\u601d\u7ef4\u5bfc\u56fe\u7b49\uff09\u6216\u662f\u4e00\u4e9b\u81ea\u5df1\u7684\u7406\u89e3\uff08\u5bf9\u6e90\u77e5\u8bc6\u7684\u62bd\u8c61\u3001\u7c7b\u6bd4\u3001\u5ef6\u4f38\u5230\u5176\u4ed6\u77e5\u8bc6\u70b9\uff09\uff0c\u8fd9\u4e9b\u8f6c\u5316\u53ef\u4ee5\u5e2e\u52a9\u6211\u4eec\u66f4\u5feb\u5730\u638c\u63e1\u548c\u5de9\u56fa\u77e5\u8bc6\u7684\u6838\u5fc3\u5185\u5bb9\uff0c\u5c31\u5982\u540c\u521d\u9ad8\u4e2d\u5b66\u4e60\u65f6\u4f7f\u7528\u7684\u8f85\u5bfc\u4e66\u3002 \u6b64\u5916\uff0c\u5b66\u4e60\u7684\u8fc7\u7a0b\u4e2d\u548c\u522b\u4eba\u7684\u4ea4\u6d41\u5341\u5206\u91cd\u8981\uff0c\u8fd9\u4e9b N \u624b\u4fe1\u606f\u540c\u65f6\u8d77\u4e86\u548c\u5176\u4ed6\u4f5c\u8005\u4ea4\u6d41\u7684\u4f5c\u7528\uff0c\u8ba9\u6211\u4eec\u80fd\u91c7\u767e\u5bb6\u4e4b\u957f\u3002\u6240\u4ee5\u8fd9\u63d0\u793a\u6211\u4eec\u5b66\u4e60\u4e00\u4e2a\u77e5\u8bc6\u70b9\u65f6\u5148\u5c3d\u91cf\u9009\u62e9\u8d28\u91cf\u66f4\u9ad8\u7684\uff0c\u4fe1\u606f\u635f\u5931\u8f83\u5c11\u7684\u4fe1\u606f\u6e90\uff0c\u540c\u65f6\u4e0d\u59a8\u53c2\u8003\u591a\u4e2a\u4fe1\u606f\u6e90\uff0c\u8ba9\u81ea\u5df1\u7684\u7406\u89e3\u66f4\u52a0\u5168\u9762\u51c6\u786e\u3002
Obsidian \u6709\u4e30\u5bcc\u7684\u63d2\u4ef6\u751f\u6001\uff0c\u5e76\u4e14\u8fd9\u4e2a\u751f\u6001\u65e2\u5927\u53c8\u6d3b\u8dc3\uff0c\u5373\u63d2\u4ef6\u6570\u91cf\u591a\uff0c\u4e14\u70ed\u95e8\u63d2\u4ef6\u7684 star \u591a\uff0c\u5f00\u53d1\u8005\u4f1a\u53cd\u9988\u7528\u6237 issue\uff0c\u7248\u672c\u4f1a\u6301\u7eed\u8fed\u4ee3\u3002\u501f\u52a9\u8fd9\u4e9b\u63d2\u4ef6\uff0c\u53ef\u4ee5\u4f7f Obsidian \u8fbe\u5230 all in one \u7684\u6548\u679c\uff0c\u5373\u5404\u7c7b\u77e5\u8bc6\u6765\u6e90\u53ef\u4ee5\u7edf\u4e00\u6574\u5408\u4e8e\u4e00\u5904
Obsidian \u7684\u63d2\u4ef6\u4f7f\u5176\u53ef\u4ee5\u652f\u6301 pdf \u683c\u5f0f\uff0c\u800c\u5176\u672c\u8eab\u53c8\u652f\u6301 Markdown \u683c\u5f0f\u3002\u5982\u679c\u60f3\u8981 all in one\uff0c\u90a3\u4e48\u53ef\u4ee5\u57fa\u4e8e\u8fd9\u4e24\u4e2a\u683c\u5f0f\uff0c\u5c06\u5176\u4ed6\u683c\u5f0f\u6587\u4ef6\u8f6c\u6362\u4e3a pdf \u6216\u8005 Markdown\u3002 \u90a3\u4e48\u73b0\u5728\u5c31\u9762\u4e34\u7740\u4e24\u4e2a\u95ee\u9898\uff1a
\u6709\u4ec0\u4e48\u683c\u5f0f
\u600e\u4e48\u8f6c\u6362\u4e3a pdf \u6216 Markdown
\u5bf9\u4e8e\u8bba\u6587\u548c\u7535\u5b50\u4e66\u800c\u8a00\u5982\u679c\u683c\u5f0f\u672c\u8eab\u5c31\u662f pdf \u5219\u4e07\u4e8b\u5927\u5409\uff0c\u4f46\u5982\u679c\u662f\u5176\u4ed6\u683c\u5f0f\u5219\u53ef\u4ee5\u4f7f\u7528 calibre \u8fdb\u884c\u8f6c\u6362\uff1a
\u73b0\u5728\u5229\u7528 Obsidian \u7684 pdf \u63d2\u4ef6\u548c\u5176\u539f\u751f\u7684 markdown \u652f\u6301\u5c31\u53ef\u4ee5\u7545\u5feb\u65e0\u6bd4\u5730\u505a\u7b14\u8bb0\u5e76\u4e14\u5728\u8fd9\u4e9b\u6587\u7ae0\u7684\u5bf9\u5e94\u7ae0\u8282\u8fdb\u884c\u65e0\u7f1d\u8854\u63a5\u5730\u5f15\u7528\u8df3\u8f6c\u5566\uff08\u5177\u4f53\u64cd\u4f5c\u53c2\u8003\u4e0b\u6587\u7684\u201c\u4fe1\u606f\u7684\u5904\u7406\u201d\u6a21\u5757\uff09\u3002
\u5904\u7406\u5b8c\u6587\u672c\u7c7b\u7684\u4fe1\u606f\u540e\uff0c\u6211\u4eec\u8fd8\u5f97\u601d\u8003\u4e00\u4e0b\u600e\u4e48\u5904\u7406\u591a\u5a92\u4f53\u7c7b\u7684\u4fe1\u606f\u3002\u6b64\u5904\u7684\u591a\u5a92\u4f53\u6211\u7279\u6307\u82f1\u6587\u89c6\u9891\uff0c\u56e0\u4e3a\u6211\u6ca1\u6709\u7528\u64ad\u5ba2\u6216\u5f55\u97f3\u5b66\u4e60\u7684\u4e60\u60ef\uff0c\u800c\u4e14\u6211\u5df2\u7ecf\u57fa\u672c\u4e0d\u770b\u4e2d\u6587\u6559\u7a0b\u4e86\u3002\u73b0\u5728\u5f88\u591a\u56fd\u5916\u540d\u6821\u516c\u5f00\u8bfe\u90fd\u662f\u4ee5\u89c6\u9891\u7684\u5f62\u5f0f\uff0c\u5982\u679c\u80fd\u5bf9\u89c6\u9891\u8fdb\u884c\u505a\u7b14\u8bb0\u4f1a\u4e0d\u4f1a\u6709\u5e2e\u52a9\u5462\uff1f\u4e0d\u77e5\u9053\u5927\u5bb6\u6709\u6ca1\u8fd9\u6837\u7684\u60f3\u6cd5\uff0c\u5c31\u662f\u5982\u679c\u80fd\u628a\u8001\u5e08\u4e0a\u8bfe\u8bb2\u7684\u5185\u5bb9\u8f6c\u6362\u6210\u6587\u672c\u5c31\u597d\u4e86\uff0c\u56e0\u4e3a\u5e73\u65f6\u5b66\u4e60\u65f6\u6211\u4eec\u770b\u4e66\u7684\u901f\u5ea6\u5f80\u5f80\u4f1a\u6bd4\u8001\u5e08\u8bb2\u8bfe\u7684\u901f\u5ea6\u5feb\u3002\u521a\u597d Language Reactor \u8fd9\u4e2a\u8f6f\u4ef6\u53ef\u4ee5\u5c06\u6cb9\u7ba1\u548c\u7f51\u98de\u5185\u89c6\u9891\u7684\u5b57\u5e55\u5bfc\u51fa\u6765\uff0c\u540c\u65f6\u9644\u4e0a\u4e2d\u6587\u7ffb\u8bd1\u3002
\u6211\u4eec\u53ef\u4ee5\u628a Language Reactor \u5bfc\u51fa\u7684\u5b57\u5e55\u590d\u5236\u5230 Obsidian \u91cc\u9762\u4f5c\u4e3a\u6587\u7ae0\u6765\u8bfb\u3002\u9664\u4e86\u51fa\u4e8e\u5b66\u4e60\u7684\u9700\u6c42\uff0c\u4e5f\u53ef\u4ee5\u5728\u5e73\u65f6\u770b\u6cb9\u7ba1\u7684\u89c6\u9891\u65f6\u6253\u5f00\u8fd9\u4e2a\u63d2\u4ef6\uff0c\u8fd9\u4e2a\u63d2\u4ef6\u53ef\u4ee5\u540c\u65f6\u663e\u793a\u4e2d\u82f1\u6587\u5b57\u5e55\uff0c\u5e76\u4e14\u53ef\u4ee5\u5355\u51fb\u9009\u4e2d\u82f1\u6587\u5b57\u5e55\u4e2d\u4f60\u8ba4\u4e3a\u751f\u50fb\u7684\u5355\u8bcd\u540e\u663e\u793a\u5355\u8bcd\u91ca\u4e49\u3002
\u4f46\u9605\u8bfb\u6587\u672c\u5bf9\u4e8e\u4e00\u4e9b\u62bd\u8c61\u7684\u77e5\u8bc6\u70b9\u6765\u8bf4\u5e76\u4e0d\u662f\u6548\u7387\u6700\u9ad8\u7684\u5b66\u4e60\u65b9\u5f0f\u3002\u4fd7\u8bdd\u8bf4\uff0c\u4e00\u56fe\u80dc\u5343\u8a00\uff0c\u80fd\u4e0d\u80fd\u5c06\u67d0\u4e00\u6bb5\u77e5\u8bc6\u70b9\u7684\u6587\u672c\u548c\u5bf9\u5e94\u7684\u56fe\u7247\u751a\u81f3\u89c6\u9891\u753b\u9762\u64cd\u4f5c\u8054\u7cfb\u8d77\u6765\u5462\uff1f\u6211\u5728\u6d4f\u89c8 Obsidian \u7684\u63d2\u4ef6\u5e02\u573a\u65f6\uff0c\u53d1\u73b0\u4e86\u4e00\u4e2a\u53eb Media Extended \u7684\u63d2\u4ef6\uff0c\u8fd9\u4e2a\u63d2\u4ef6\u53ef\u4ee5\u5728\u4f60\u7684\u7b14\u8bb0\u91cc\u6dfb\u52a0\u8df3\u8f6c\u5230\u89c6\u9891\u6307\u5b9a\u65f6\u95f4\u8fdb\u5ea6\u7684\u94fe\u63a5\uff0c\u76f8\u5f53\u4e8e\u628a\u4f60\u7684\u7b14\u8bb0\u548c\u89c6\u9891\u8fde\u63a5\u8d77\u6765\u4e86\uff01\u8fd9\u521a\u597d\u53ef\u4ee5\u548c\u6211\u4e0a\u6587\u63d0\u5230\u7684\u751f\u6210\u89c6\u9891\u4e2d\u82f1\u6587\u5b57\u5e55\u642d\u914d\u8d77\u6765\uff0c\u5373\u6bcf\u4e00\u53e5\u5b57\u5e55\u5bf9\u5e94\u4e00\u4e2a\u65f6\u95f4\uff0c\u5e76\u4e14\u80fd\u6839\u636e\u65f6\u95f4\u70b9\u8df3\u8f6c\u5230\u89c6\u9891\u7684\u6307\u5b9a\u8fdb\u5ea6\uff0c\u5982\u6b64\u4e00\u6765\u5982\u679c\u9700\u8981\u5728\u6587\u7ae0\u4e2d\u5c55\u793a\u8bb0\u5f55\u4e86\u64cd\u4f5c\u8fc7\u7a0b\u7684\u89c6\u9891\u7684\u8bdd\uff0c\u5c31\u4e0d\u9700\u8981\u81ea\u5df1\u53bb\u622a\u53d6\u5bf9\u5e94\u7684\u89c6\u9891\u7247\u6bb5\uff0c\u800c\u662f\u76f4\u63a5\u5728\u6587\u7ae0\u5185\u5c31\u80fd\u8df3\u8f6c\uff01
Obsidian \u91cc\u8fd8\u6709\u4e00\u4e2a\u5f88\u5f3a\u5927\u7684\u63d2\u4ef6\uff0c\u53eb Annotator\uff0c\u5b83\u53ef\u4ee5\u5b9e\u73b0\u7b14\u8bb0\u5185\u8df3\u8f6c\u5230 pdf \u539f\u6587
Obsidian \u5185\u5df2\u7ecf\u6709\u4e00\u4e2a\u8fde\u63a5 Anki \u7684\u63d2\u4ef6\uff0cAnki \u5c31\u662f\u5927\u540d\u9f0e\u9f0e\u7684\u3001\u57fa\u4e8e\u95f4\u9694\u91cd\u590d\u7684\u8bb0\u5fc6\u8f6f\u4ef6\u3002\u4f7f\u7528\u8be5\u63d2\u4ef6\u53ef\u4ee5\u622a\u53d6\u7b14\u8bb0\u7684\u7247\u6bb5\u5bfc\u51fa\u5230 Anki \u5e76\u53d8\u6210\u4e00\u5f20\u5361\u7247\uff0c\u5361\u7247\u5185\u4e5f\u6709\u8df3\u8f6c\u56de\u7b14\u8bb0\u539f\u6587\u7684\u94fe\u63a5
\u722c\u884c\u548c\u6293\u53d6\uff1a\u641c\u7d22\u5f15\u64ce\u8718\u86db\u901a\u8fc7\u8ddf\u8e2a\u94fe\u63a5\u8bbf\u95ee\u7f51\u9875\uff0c\u83b7\u53d6\u7f51\u9875 HTML \u4ee3\u7801\u5b58\u5165\u6570\u636e\u5e93\u3002
\u7b2c\u4e09\u6b65\u8ddf\u6211\u4eec\u606f\u606f\u76f8\u5173\uff0c\u4e0d\u7ba1\u662f\u4ec0\u4e48\u641c\u7d22\u7f51\u7ad9\uff0c google \u3001\u767e\u5ea6\u3001 Bing \uff0c\u90fd\u4e00\u6837\uff0c\u8f93\u5165\u5173\u952e\u5b57\u6216\u8005\u9700\u8981\u67e5\u8be2\u7684\u5185\u5bb9\uff0c\u641c\u7d22\u5f15\u64ce\u4f1a\u7ed9\u4f60\u8fd4\u56de\u7ed3\u679c\u3002\u672c\u6587\u5c31\u662f\u6559\u4f60\u5982\u4f55\u83b7\u53d6\u66f4\u597d\u7684\u7ed3\u679c\u3002
\u4e2d\u6587\u641c\u7d22\u4e2d\uff0c\u5206\u8bcd\u7cfb\u7edf\u4e0d\u51c6\u4f1a\u5bfc\u81f4\u6b67\u4e49\uff0c\u6bd4\u5982 Google \u641c\u4e2d\u6587\u53ef\u80fd\u4f1a\u641c\u4e0d\u51fa\u51e0\u6761\u6709\u7528\u7ed3\u679c
\u6b64\u94fe\u63a5\u51fa\u73b0\u5728\u8fd9\u91cc\u7eaf\u5c5e\u4e8c\u8fdb\u5236 bit \u7684\u968f\u610f\u7ec4\u5408\uff0c\u4e0e\u672c\u4eba\u6beb\u65e0\u5173\u7cfb\u3002
\u8fd9\u95e8\u8bfe\u5584\u4e8e\u7ad9\u5728\u5b66\u751f\u89d2\u5ea6\u5faa\u5faa\u5584\u8bf1\u3002\u4f8b\u5982\uff0c\u8bfe\u7a0b\u4ece\u201c\u5f31\u5f31\u5730\u95ee\uff0c\u4ec0\u4e48\u662f\u64cd\u4f5c\u7cfb\u7edf\u201d\u6765\u201c\u63ed\u5f00\u64cd\u4f5c\u7cfb\u7edf\u94a2\u7434\u7684\u76d6\u5b50\u201d\uff0c\u4ece CPU \u7684\u76f4\u89c2\u7ba1\u7406\u5f15\u51fa\u8fdb\u7a0b\u6982\u5ff5\uff0c\u4ece\u201c\u90a3\u5c31\u9996\u5148\u8ba9\u7a0b\u5e8f\u8fdb\u5165\u5185\u5b58\u201d\u5f15\u51fa\u5185\u5b58\u7ba1\u7406\u3002
\u8fd9\u95e8\u8bfe\u6ce8\u91cd\u7406\u8bba\u548c\u5b9e\u8df5\u76f8\u7ed3\u5408\u3002\u64cd\u4f5c\u7cfb\u7edf\u662f\u770b\u5f97\u89c1\u6478\u5f97\u7740\u7684\u4e1c\u897f\uff0c\u674e\u8001\u5e08\u53cd\u590d\u5f3a\u8c03\u4e00\u5b9a\u8981\u505a\u5b9e\u9a8c\uff0c\u5982\u679c\u53ea\u770b\u89c6\u9891\u7eb8\u4e0a\u8c08\u5175\uff0c\u662f\u5b66\u4e0d\u597d\u64cd\u4f5c\u7cfb\u7edf\u7684\u3002\u8bfe\u7a0b\u57fa\u4e8e\u5b9e\u9645\u7684 Linux 0.11 \u6e90\u7801\uff08\u603b\u4ee3\u7801\u91cf\u7ea6\u4e24\u4e07\u884c\uff09\u8fdb\u884c\u8bb2\u89e3\u548c\u5b9e\u9a8c\uff0c\u5171\u6709\u516b\u4e2a\u5c0f\u5b9e\u9a8c\uff0c\u56db\u4e2a\u5927\u5b9e\u9a8c\u3002
"},{"location":"%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F/MIT6.S081/","title":"MIT 6.S081: Operating System Engineering","text":""},{"location":"%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F/MIT6.S081/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
"},{"location":"%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F/NJUOS/","title":"NJU OS: Operating System Design and Implementation","text":""},{"location":"%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F/NJUOS/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u4e4b\u524d\u4e00\u76f4\u542c\u8bf4\u5357\u5927\u7684\u848b\u708e\u5ca9\u8001\u5e08\u5f00\u8bbe\u7684\u64cd\u4f5c\u7cfb\u7edf\u8bfe\u7a0b\u8bb2\u5f97\u5f88\u597d\uff0c\u4e45\u95fb\u4e0d\u5982\u4e00\u89c1\uff0c\u8fd9\u5b66\u671f\u6709\u5e78\u5728 B \u7ad9\u89c2\u770b\u4e86\u848b\u8001\u5e08\u7684\u8bfe\u7a0b\u89c6\u9891\uff0c\u786e\u5b9e\u6536\u83b7\u826f\u591a\u3002\u848b\u8001\u5e08\u4f5c\u4e3a\u975e\u5e38\u5e74\u8f7b\u7684\u8001\u5e08\uff0c\u6709\u7740\u4e30\u5bcc\u7684\u4e00\u7ebf\u4ee3\u7801\u7684\u7ecf\u9a8c\uff0c\u56e0\u6b64\u8bfe\u7a0b\u8bb2\u6388\u6709\u7740\u6ee1\u6ee1\u7684 Hacker \u98ce\u683c\uff0c\u8bfe\u4e0a\u7ecf\u5e38\u201c\u4e00\u8a00\u4e0d\u5408\u201d\u5c31\u5728\u547d\u4ee4\u884c\u91cc\u5f00\u59cb\u5199\u4ee3\u7801\uff0c\u5f88\u591a\u91cd\u8981\u77e5\u8bc6\u70b9\u4e5f\u90fd\u914d\u6709\u751f\u52a8\u76f4\u767d\u7684\u4ee3\u7801\u793a\u4f8b\u3002\u8ba9\u6211\u5370\u8c61\u6700\u4e3a\u6df1\u523b\u7684\u5c31\u662f\u8001\u5e08\u4e3a\u4e86\u8ba9\u5b66\u751f\u66f4\u597d\u5730\u7406\u89e3\u52a8\u6001\u94fe\u63a5\u5e93\u7684\u8bbe\u8ba1\u601d\u60f3\uff0c\u751a\u81f3\u4e13\u95e8\u5b9e\u73b0\u4e86\u4e00\u4e2a\u8ff7\u4f60\u7684\u53ef\u6267\u884c\u6587\u4ef6\u4e0e\u4e00\u7cfb\u5217\u7684\u4e8c\u8fdb\u5236\u5de5\u5177\uff0c\u8ba9\u5f88\u591a\u56f0\u6270\u6211\u591a\u5e74\u7684\u95ee\u9898\u90fd\u5f97\u5230\u4e86\u89e3\u7b54\u3002
\u8fd9\u95e8\u8bfe\u7684\u8bb2\u6388\u601d\u8def\u4e5f\u975e\u5e38\u6709\u8da3\uff0c\u848b\u8001\u5e08\u5148\u4ece\u201c\u7a0b\u5e8f\u5c31\u662f\u72b6\u6001\u673a\u201d\u8fd9\u4e00\u89c6\u89d2\u5165\u624b\uff0c\u4e3a\u201c\u4e07\u6076\u4e4b\u6e90\u201d\u5e76\u53d1\u7a0b\u5e8f\u5efa\u7acb\u4e86\u72b6\u6001\u673a\u7684\u8f6c\u5316\u6a21\u578b\uff0c\u5e76\u5728\u6b64\u57fa\u7840\u4e0a\u8bb2\u6388\u4e86\u5e76\u53d1\u63a7\u5236\u7684\u5e38\u89c1\u624b\u6bb5\u4ee5\u53ca\u5e76\u53d1 bug \u7684\u5e94\u5bf9\u65b9\u6cd5\u3002\u63a5\u7740\u848b\u8001\u5e08\u5c06\u64cd\u4f5c\u7cfb\u7edf\u770b\u4f5c\u4e00\u7cfb\u5217\u5bf9\u8c61\uff08\u8fdb\u7a0b/\u7ebf\u7a0b\u3001\u5730\u5740\u7a7a\u95f4\u3001\u6587\u4ef6\u3001\u8bbe\u5907\u7b49\u7b49\uff09\u4ee5\u53ca\u64cd\u4f5c\u5b83\u4eec\u7684 API \uff08\u7cfb\u7edf\u8c03\u7528\uff09\u5e76\u7ed3\u5408\u4e30\u5bcc\u7684\u5b9e\u9645\u4f8b\u5b50\u4ecb\u7ecd\u4e86\u64cd\u4f5c\u7cfb\u7edf\u662f\u5982\u4f55\u5229\u7528\u8fd9\u7cfb\u5217\u5bf9\u8c61\u865a\u62df\u5316\u786c\u4ef6\u8d44\u6e90\u5e76\u7ed9\u5e94\u7528\u8f6f\u4ef6\u63d0\u4f9b\u5404\u7c7b\u670d\u52a1\u7684\u3002\u6700\u540e\u7684\u53ef\u6301\u4e45\u5316\u90e8\u5206\uff0c\u848b\u8001\u5e08\u4ece 1-bit \u7684\u5b58\u50a8\u4ecb\u8d28\u8bb2\u8d77\uff0c\u4e00\u6b65\u6b65\u6784\u5efa\u8d77\u5404\u7c7b\u5b58\u50a8\u8bbe\u5907\uff0c\u5e76\u901a\u8fc7\u8bbe\u5907\u9a71\u52a8\u62bd\u8c61\u51fa\u4e00\u7ec4\u63a5\u53e3\u6765\u65b9\u4fbf\u5730\u8bbe\u8ba1\u4e0e\u5b9e\u73b0\u6587\u4ef6\u7cfb\u7edf\u3002\u6211\u4e4b\u524d\u867d\u7136\u4e0a\u8fc7\u8bb8\u591a\u95e8\u64cd\u4f5c\u7cfb\u7edf\u7684\u8bfe\u7a0b\uff0c\u4f46\u8fd9\u79cd\u8bb2\u6cd5\u786e\u5b9e\u72ec\u6b64\u4e00\u5bb6\uff0c\u8ba9\u6211\u6536\u83b7\u4e86\u5f88\u591a\u72ec\u5230\u7684\u89c6\u89d2\u6765\u770b\u5f85\u7cfb\u7edf\u8f6f\u4ef6\u3002
"},{"location":"%E6%95%B0%E5%AD%A6%E5%9F%BA%E7%A1%80/MITLA/","title":"MIT18.06: Linear Algebra","text":""},{"location":"%E6%95%B0%E5%AD%A6%E5%9F%BA%E7%A1%80/MITLA/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u6570\u5b66\u5927\u725b Gilbert Strang \u8001\u5148\u751f\u5e74\u903e\u53e4\u7a00\u4ecd\u575a\u6301\u6388\u8bfe\uff0c\u5176\u7ecf\u5178\u6559\u6750 Introduction to Linear Algebra \u5df2\u88ab\u6e05\u534e\u91c7\u7528\u4e3a\u5b98\u65b9\u6559\u6750\u3002\u6211\u5f53\u65f6\u770b\u5b8c\u76d7\u7248 PDF \u4e4b\u540e\u6df1\u611f\u6127\u759a\uff0c\u542b\u6cea\u82b1\u4e86\u4e24\u767e\u591a\u4e70\u4e86\u4e00\u672c\u82f1\u6587\u6b63\u7248\u6536\u85cf\u3002\u4e0b\u9762\u9644\u4e0a\u6b64\u4e66\u5c01\u9762\uff0c\u5982\u679c\u4f60\u80fd\u5b8c\u5168\u7406\u89e3\u5c01\u9762\u56fe\u7684\u6570\u5b66\u542b\u4e49\uff0c\u90a3\u4f60\u5bf9\u7ebf\u6027\u4ee3\u6570\u7684\u7406\u89e3\u4e00\u5b9a\u4f1a\u8fbe\u5230\u65b0\u7684\u9ad8\u5ea6\u3002
"},{"location":"%E6%95%B0%E5%AD%A6%E5%9F%BA%E7%A1%80/information/","title":"MIT6.050J: Information theory and Entropy","text":""},{"location":"%E6%95%B0%E5%AD%A6%E5%9F%BA%E7%A1%80/information/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
MIT \u9762\u5411\u5927\u4e00\u65b0\u751f\u7684\u4fe1\u606f\u8bba\u5165\u95e8\u8bfe\u7a0b\uff0cPenfield \u6559\u6388\u4e13\u95e8\u4e3a\u8fd9\u95e8\u8bfe\u5199\u4e86\u4e00\u672c\u6559\u6750\u4f5c\u4e3a\u8bfe\u7a0b notes\uff0c\u5185\u5bb9\u6df1\u5165\u6d45\u51fa\uff0c\u751f\u52a8\u6709\u8da3\u3002
MIT \u7684\u79bb\u6563\u6570\u5b66\u4ee5\u53ca\u6982\u7387\u7efc\u5408\u8bfe\u7a0b\uff0c\u5bfc\u5e08\u662f\u5927\u540d\u9f0e\u9f0e\u7684 Tom Leighton ( Akamai \u7684\u8054\u5408\u521b\u59cb\u4eba\u4e4b\u4e00)\u3002\u5b66\u5b8c\u4e4b\u540e\u5bf9\u4e8e\u540e\u7eed\u7684\u7b97\u6cd5\u5b66\u4e60\u5927\u6709\u88e8\u76ca\u3002
"},{"location":"%E6%95%B0%E5%AD%A6%E8%BF%9B%E9%98%B6/CS126/","title":"UCB CS126 : Probability theory","text":""},{"location":"%E6%95%B0%E5%AD%A6%E8%BF%9B%E9%98%B6/CS126/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u540c\u65f6\u8fd9\u95e8\u8bfe\u975e\u5e38\u5f3a\u8c03\u7406\u8bba\u4e0e\u5b9e\u8df5\u7684\u7ed3\u5408\uff0c\u8bfe\u7a0b\u8bbe\u8ba1\u8005 Jean Walrand \u6559\u6388\u4e13\u95e8\u5199\u4e86\u4e00\u672c\u914d\u5957\u7684\u6559\u6750Probability in Electrical Engineering and Computer Science\uff0c\u4e66\u4e2d\u6bcf\u4e2a\u7ae0\u8282\u90fd\u4f1a\u4ee5\u4e00\u4e2a\u5177\u4f53\u7684\u7b97\u6cd5\u5b9e\u8df5\u4f5c\u4e3a\u4f8b\u5b50\u6765\u5c55\u793a\u7406\u8bba\u5728\u5b9e\u9645\u5f53\u4e2d\u7684\u8fd0\u7528\uff0c\u4f8b\u5982 PageRank, Route Planing, Speech Recognition \u7b49\u7b49\uff0c\u5e76\u4e14\u5168\u4e66\u5f00\u6e90\uff0c\u53ef\u4ee5\u514d\u8d39\u4e0b\u8f7d PDF \u6216\u8005 Epub \u7248\u3002
"},{"location":"%E6%95%B0%E5%AD%A6%E8%BF%9B%E9%98%B6/CS70/","title":"UCB CS70 : discrete Math and probability theory","text":""},{"location":"%E6%95%B0%E5%AD%A6%E8%BF%9B%E9%98%B6/CS70/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
"},{"location":"%E6%95%B0%E5%AD%A6%E8%BF%9B%E9%98%B6/The_Information_Theory_Pattern_Recognition_and_Neural_Networks/","title":"The Information Theory, Pattern Recognition, and Neural Networks","text":""},{"location":"%E6%95%B0%E5%AD%A6%E8%BF%9B%E9%98%B6/The_Information_Theory_Pattern_Recognition_and_Neural_Networks/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u6240\u5c5e\u5927\u5b66\uff1aCambridge
\u5148\u4fee\u8981\u6c42\uff1aCalculus, Linear Algebra, Probabilities and Statistics
\u7f16\u7a0b\u8bed\u8a00\uff1aAnything would be OK, Python preferred
\u5251\u6865\u5927\u5b66 Sir David MacKay \u6559\u6388\u7684\u4fe1\u606f\u8bba\u8bfe\u7a0b\u3002\u6559\u6388\u662f\u4e00\u4f4d\u5341\u5206\u7cbe\u901a\u4fe1\u606f\u8bba\u4e0e\u795e\u7ecf\u7f51\u7edc\u7684\u5b66\u8005\uff0c\u8bfe\u7a0b\u5bf9\u5e94\u6559\u6750\u4e5f\u662f\u4fe1\u606f\u8bba\u9886\u57df\u7684\u4e00\u90e8\u7ecf\u5178\u8457\u4f5c\u3002\u53ef\u60dc\u5929\u5992\u82f1\u624d...
"},{"location":"%E6%95%B0%E5%AD%A6%E8%BF%9B%E9%98%B6/The_Information_Theory_Pattern_Recognition_and_Neural_Networks/#rip-prof-david-mackay","title":"R.I.P Prof. David MacKay","text":""},{"location":"%E6%95%B0%E5%AD%A6%E8%BF%9B%E9%98%B6/convex/","title":"Stanford EE364A: Convex Optimization","text":""},{"location":"%E6%95%B0%E5%AD%A6%E8%BF%9B%E9%98%B6/convex/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
Stephen Boyd \u6559\u6388\u662f\u51f8\u4f18\u5316\u9886\u57df\u7684\u5927\u725b\uff0c\u5176\u7f16\u5199\u7684 Convex Optimization \u8fd9\u672c\u6559\u6750\u88ab\u4f17\u591a\u540d\u6821\u91c7\u7528\u3002\u53e6\u5916\u5176\u7814\u7a76\u56e2\u961f\u8fd8\u4e13\u95e8\u5f00\u53d1\u4e86\u4e00\u4e2a\u7528\u4e8e\u6c42\u89e3\u5e38\u89c1\u51f8\u4f18\u5316\u95ee\u9898\u7684\u7f16\u7a0b\u6846\u67b6\uff0c\u652f\u6301 Python, Julia \u7b49\u4e3b\u6d41\u7f16\u7a0b\u8bed\u8a00\uff0c\u5176\u8bfe\u7a0b\u4f5c\u4e1a\u4e5f\u662f\u91c7\u7528\u8fd9\u4e2a\u7f16\u7a0b\u6846\u67b6\u53bb\u89e3\u51b3\u5b9e\u9645\u751f\u6d3b\u5f53\u4e2d\u7684\u51f8\u4f18\u5316\u95ee\u9898\u3002
\u8fd9\u95e8\u8bfe\u4f1a\u5728\u6d6e\u70b9\u8868\u793a\u3001\u65b9\u7a0b\u6c42\u89e3\u3001\u7ebf\u6027\u4ee3\u6570\u3001\u5fae\u79ef\u5206\u3001\u5fae\u5206\u65b9\u7a0b\u7b49\u9886\u57df\u63a2\u8ba8\u5404\u7c7b\u6570\u503c\u5206\u6790\u65b9\u6cd5\uff0c\u8ba9\u4f60\u5728 Julia \u7684\u7f16\u7a0b\u5b9e\u8df5\u4e2d\u53cd\u590d\u4f53\u609f\uff081\uff09\u5982\u4f55\u5efa\u7acb\u4f30\u8ba1\uff082\uff09\u5982\u4f55\u4f30\u8ba1\u8bef\u5dee\uff083\uff09\u5982\u4f55\u7528\u7b97\u6cd5\u5b9e\u73b0\u4f30\u8ba1 \u8fd9\u4e00\u7cfb\u5217\u6b65\u9aa4\u3002
\u8fd9\u95e8\u8bfe\u7684\u8bbe\u8ba1\u8005\u8fd8\u7f16\u5199\u4e86\u914d\u5957\u7684\u5f00\u6e90\u6559\u6750\uff08\u53c2\u89c1\u4e0b\u65b9\u94fe\u63a5\uff09\uff0c\u91cc\u9762\u6709\u4e30\u5bcc\u7684 Julia \u5b9e\u4f8b\u3002
\u5305\u62ec Buffer Pool Manager (\u5185\u5b58\u7ba1\u7406), B Plus Tree (\u5b58\u50a8\u5f15\u64ce), Query Executors & Query Optimizer (\u7b97\u5b50\u4eec & \u4f18\u5316\u5668), Concurrency Control (\u5e76\u53d1\u63a7\u5236)\uff0c\u5206\u522b\u5bf9\u5e94 Project #1 \u5230 Project #4\u3002
\u6b64\u5916 bustub \u4f5c\u4e3a\u4e00\u4e2a C++ \u7f16\u5199\u7684\u4e2d\u5c0f\u578b\u9879\u76ee\u6db5\u76d6\u4e86\u7a0b\u5e8f\u6784\u5efa\u3001\u4ee3\u7801\u89c4\u8303\u3001\u5355\u5143\u6d4b\u8bd5\u7b49\u4f17\u591a\u8981\u6c42\uff0c\u53ef\u4ee5\u4f5c\u4e3a\u4e00\u4e2a\u4f18\u79c0\u7684\u5f00\u6e90\u9879\u76ee\u5b66\u4e60\u3002
\u5728 Fall 2019 \u4e2d\uff0cProject #2 \u662f\u505a\u54c8\u5e0c\u7d22\u5f15\uff0cProject #4 \u662f\u505a\u65e5\u5fd7\u4e0e\u6062\u590d\u3002
\u5728 Fall 2020 \u4e2d\uff0cProject #2 \u662f\u505a B \u6811\uff0cProject #4 \u662f\u505a\u5e76\u53d1\u63a7\u5236\u3002
\u5728 Fall 2021 \u4e2d\uff0cProject #1 \u662f\u505a\u7f13\u5b58\u6c60\u7ba1\u7406\uff0cProject #2 \u662f\u505a\u54c8\u5e0c\u7d22\u5f15\uff0cProject #4 \u662f\u505a\u5e76\u53d1\u63a7\u5236\u3002
\u5728 Fall 2022 \u4e2d\uff0c\u4e0e Fall 2021 \u76f8\u6bd4\u53ea\u6709\u54c8\u5e0c\u7d22\u5f15\u6362\u6210\u4e86 B+ \u6811\u7d22\u5f15\uff0c\u5176\u4f59\u90fd\u4e00\u6837\u3002
\u5728 Spring 2023 \u4e2d\uff0c\u5927\u4f53\u5185\u5bb9\u548c Fall 2022 \u4e00\u6837\uff08\u7f13\u5b58\u6c60\uff0cB+ \u6811\u7d22\u5f15\uff0c\u7b97\u5b50\uff0c\u5e76\u53d1\u63a7\u5236\uff09\uff0c\u53ea\u4e0d\u8fc7 Project #0 \u6362\u6210\u4e86 Copy-On-Write Trie\uff0c\u540c\u65f6\u589e\u52a0\u4e86\u5f88\u597d\u73a9\u7684\u6ce8\u518c\u5927\u5c0f\u5199\u51fd\u6570\u7684 Task\uff0c\u53ef\u4ee5\u76f4\u63a5\u5728\u7f16\u8bd1\u51fa\u7684 bustub-shell \u4e2d\u770b\u5230\u81ea\u5df1\u5199\u7684\u51fd\u6570\u7684\u5b9e\u9645\u6548\u679c\uff0c\u975e\u5e38\u6709\u6210\u5c31\u611f\u3002
\u503c\u5f97\u6ce8\u610f\u7684\u662f\uff0c\u73b0\u5728 bustub \u5728 2020 \u5e74\u4ee5\u524d\u7684 version \u90fd\u5df2\u7ecf\u505c\u6b62\u7ef4\u62a4\u3002
Fall 2019 \u7684\u6700\u540e\u4e00\u4e2a Logging & Recovery \u7684 Project \u5df2\u7ecf broken \u4e86\uff08\u572819\u5e74\u7684 git head \u4e0a\u4e5f\u8bb8\u8fd8\u53ef\u4ee5\u8dd1\uff0c\u4f46\u5c3d\u7ba1\u5982\u6b64 Gradescope \u5e94\u8be5\u4e5f\u6ca1\u6709\u63d0\u4f9b\u516c\u5171\u7684\u7248\u672c\uff0c\u6240\u4ee5\u5e76\u4e0d\u63a8\u8350\u5927\u5bb6\u53bb\u505a\uff0c\u53ea\u770b\u770b\u4ee3\u7801\u548c Handout \u5c31\u53ef\u4ee5\u4e86\uff09\u3002
\u6216\u8bb8\u5728 Fall 2023 \u7684\u7248\u672c Recovery \u76f8\u5173\u7684\u529f\u80fd\u4f1a\u88ab\u4fee\u590d\uff0c\u5c4a\u65f6\u4e5f\u53ef\u80fd\u6709\u5168\u65b0\u7684 Recovery Project\uff0c\u8ba9\u6211\u4eec\u8bd5\u76ee\u4ee5\u5f85\u5427\ud83e\udd2a
\u53e6\u5916\u5728\u8bfe\u7a0b\u7ed3\u675f\u540e\uff0c\u63a8\u8350\u9605\u8bfb\u4e00\u7bc7\u8bba\u6587 Architecture Of a Database System\uff0c\u5bf9\u5e94\u7684\u4e2d\u6587\u7248\u4e5f\u5728\u4e0a\u8ff0\u4ed3\u5e93\u4e2d\u3002\u8bba\u6587\u91cc\u7efc\u8ff0\u4e86\u6570\u636e\u5e93\u7cfb\u7edf\u7684\u6574\u4f53\u67b6\u6784\uff0c\u8ba9\u5927\u5bb6\u53ef\u4ee5\u5bf9\u6570\u636e\u5e93\u6709\u4e00\u4e2a\u66f4\u52a0\u5168\u9762\u7684\u89c6\u91ce\u3002
CMU15-721 \u4e3b\u8981\u8bb2\u4e3b\u5b58\u6570\u636e\u5e93\u6709\u5173\u7684\u5185\u5bb9\uff0c\u6bcf\u8282\u8bfe\u90fd\u6709\u5bf9\u5e94\u7684 paper \u8981\u8bfb\uff0c\u63a8\u8350\u7ed9\u5e0c\u671b\u8fdb\u9636\u6570\u636e\u5e93\u7684\u5c0f\u4f19\u4f34\u3002@ysj1173886760 \u76ee\u524d\u4e5f\u5728\u8ddf\u8fdb\u8fd9\u95e8\u8bfe\uff0c\u5b8c\u6210\u540e\u4f1a\u5728\u8fd9\u91cc\u63d0 PR \u4ee5\u63d0\u4f9b\u8fdb\u9636\u7684\u6307\u5bfc\u3002
"},{"location":"%E6%95%B0%E6%8D%AE%E5%BA%93%E7%B3%BB%E7%BB%9F/15799/","title":"CMU 15-799: Special Topics in Database Systems","text":""},{"location":"%E6%95%B0%E6%8D%AE%E5%BA%93%E7%B3%BB%E7%BB%9F/15799/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
The record management component\uff1a\u8bb0\u5f55\u7ba1\u7406\u7ec4\u4ef6\u3002
The index component\uff1aB+ \u7d22\u5f15\u7ba1\u7406\u3002
The System Management Component\uff1addl\u8bed\u53e5\u3001\u547d\u4ee4\u884c\u5de5\u5177\u3001\u6570\u636e\u52a0\u8f7d\u547d\u4ee4\u3001\u5143\u6570\u636e\u7ba1\u7406\u3002
The Query Language Component\uff1a\u5728\u8fd9\u4e2a\u90e8\u5206\u9700\u8981\u5b9e\u73b0 RQL Redbase \u67e5\u8be2\u8bed\u8a00\u3002RQL \u8981\u5b9e\u73b0 select\u3001insert\u3001delete\u3001update \u8bed\u53e5\u3002
RedBase \u9002\u5408\u5728\u5b66\u5b8c CMU 15-445 \u540e\u7ee7\u7eed\u5b66\u4e60\u6570\u636e\u5e93\u7cfb\u7edf\u4e2d\u7684\u5176\u4ed6\u7ec4\u4ef6\uff0c\u56e0\u4e3a\u5176\u4ee3\u7801\u91cf\u4e0d\u591a\uff0c\u53ef\u4ee5\u65b9\u4fbf\u7684\u6839\u636e\u9700\u8981\u6269\u5c55\u4ee3\u7801\u3002\u540c\u65f6\u4ee3\u7801\u5b8c\u5168\u7531 C++ \u7f16\u5199\uff0c\u4e5f\u53ef\u4ee5\u7528\u4e8e\u7ec3\u4e60 C++ \u7f16\u7a0b\u6280\u5de7\u3002
"},{"location":"%E6%95%B0%E6%8D%AE%E7%A7%91%E5%AD%A6/Data100/","title":"UCB Data100: Principles and Techniques of Data Science","text":""},{"location":"%E6%95%B0%E6%8D%AE%E7%A7%91%E5%AD%A6/Data100/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
"},{"location":"%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E4%B8%8E%E7%AE%97%E6%B3%95/6.006/","title":"MIT 6.006: Introduction to Algorithms","text":""},{"location":"%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E4%B8%8E%E7%AE%97%E6%B3%95/6.006/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u6240\u5c5e\u5927\u5b66\uff1aMIT
\u5148\u4fee\u8981\u6c42\uff1a\u8ba1\u7b97\u673a\u5bfc\u8bba(CS50/CS61A or equivalent)
\u8bfe\u7a0b\u6559\u6750\uff1aIntroduction to Algorithms (CLRS)
\u8bfe\u7a0b\u4f5c\u4e1a\uff1aFall 2011
"},{"location":"%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E4%B8%8E%E7%AE%97%E6%B3%95/6.046/","title":"MIT 6.046: Design and Analysis of Algorithms","text":""},{"location":"%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E4%B8%8E%E7%AE%97%E6%B3%95/6.046/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u6240\u5c5e\u5927\u5b66\uff1aMIT
\u5148\u4fee\u8981\u6c42\uff1a\u7b97\u6cd5\u5165\u95e8(6.006/CS61B/CS106B/CS106X or equivalent)
\u8bfe\u7a0b\u6559\u6750\uff1aIntroduction to Algorithms (CLRS)
\u8bfe\u7a0b\u4f5c\u4e1a\uff1aSpring 2015
"},{"location":"%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E4%B8%8E%E7%AE%97%E6%B3%95/Algo/","title":"Coursera: Algorithms I & II","text":""},{"location":"%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E4%B8%8E%E7%AE%97%E6%B3%95/Algo/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
"},{"location":"%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E4%B8%8E%E7%AE%97%E6%B3%95/CS61B/","title":"CS61B: Data Structures and Algorithms","text":""},{"location":"%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E4%B8%8E%E7%AE%97%E6%B3%95/CS61B/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
"},{"location":"%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/CS189/","title":"CS189: Introduction to Machine Learning","text":""},{"location":"%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/CS189/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u4e2a\u4eba\u4f53\u4f1a\u662f\u7b2c\u4e09\u7ae0\u5b9e\u73b0\u7b97\u5b50\u7684\u5b9e\u9a8c\u8ba9\u6211\u5bf9\u6df1\u5ea6\u5b66\u4e60\u6846\u67b6\u7684\u4e86\u89e3\u52a0\u6df1\u4e86\u5f88\u591a\u3002\u7b2c\u4e94\u7ae0\u7684\u5b9e\u9a8cBCL\u8bed\u8a00\u7f16\u5199\u7b97\u5b50\u5982\u679c\u4e86\u89e3 CUDA \u7684\u8bdd\u4f1a\u611f\u89c9\u5f88\u719f\u6089\u3002
"},{"location":"%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%E7%B3%BB%E7%BB%9F/CMU10-414/","title":"CMU 10-414/714: Deep Learning Systems","text":""},{"location":"%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%E7%B3%BB%E7%BB%9F/CMU10-414/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u8bfe\u7a0b\u7f51\u7ad9\u5305\u542b\u4e86\u6240\u6709\u7684\u8d44\u6e90\uff1aslides, notes, video, homework, and project
\u8fd9\u95e8\u8bfe\u7a0b\u662f CMU \u7684\u56fe\u6a21\u578b\u57fa\u7840 + \u8fdb\u9636\u8bfe\uff0c\u6388\u8bfe\u8001\u5e08\u4e3a Eric P. Xing\uff0c\u6db5\u76d6\u4e86\u56fe\u6a21\u578b\u57fa\u7840\uff0c\u4e0e\u795e\u7ecf\u7f51\u7edc\u7684\u7ed3\u5408\uff0c\u5728\u5f3a\u5316\u5b66\u4e60\u4e2d\u7684\u5e94\u7528\uff0c\u4ee5\u53ca\u975e\u53c2\u6570\u65b9\u6cd5\uff0c\u76f8\u5f53\u786c\u6838\u3002
\u8fd9\u662f\u4e00\u95e8\u8f83\u4e3a\u8fdb\u9636\u7684 Ph.D. \u7814\u7a76\u8bfe\u7a0b\uff0c\u6838\u5fc3\u5185\u5bb9\u662f inference \u548c control \u4e4b\u95f4\u7684\u5173\u7cfb\u3002\u6388\u8bfe\u8001\u5e08\u4e3a Chris Maddison (AlphaGo founding member, NeurIPS 14 best paper)\u3002
"},{"location":"%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%E8%BF%9B%E9%98%B6/STAT8201/","title":"Columbia STAT 8201: Deep Generative Models","text":""},{"location":"%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%E8%BF%9B%E9%98%B6/STAT8201/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u6240\u5c5e\u5927\u5b66\uff1aColumbia University
\u5148\u4fee\u8981\u6c42\uff1aMachine Learning, Deep Learning, Graphical Models
\u673a\u5668\u5b66\u4e60\u8fdb\u9636\u53ef\u80fd\u5b58\u5728\u591a\u79cd\u4e0d\u540c\u7684\u5b66\u4e60\u8def\u7ebf\uff0c\u6b64\u8def\u7ebf\u53ea\u80fd\u4ee3\u8868\u4f5c\u8005 Yao Fu \u6240\u7406\u89e3\u7684\u6700\u4f73\u8def\u5f84\uff0c\u4fa7\u91cd\u4e8e\u8d1d\u53f6\u65af\u5b66\u6d3e\u4e0b\u7684\u6982\u7387\u5efa\u6a21\u65b9\u6cd5\uff0c\u4e5f\u4f1a\u6d89\u53ca\u5230\u5404\u9879\u76f8\u5173\u5b66\u79d1\u7684\u4ea4\u53c9\u77e5\u8bc6\u3002
\u8fdb\u9636\u4e66\u7c4d\u5148\u4e0d\u8bfb\uff0c\u5148\u8bfb\u5b8c\u5fc5\u8bfb\u4e66\u7c4d\u3002\u5fc5\u8bfb\u4e66\u7c4d\u4e00\u822c\u90fd\u662f\u8981\u524d\u524d\u540e\u540e\u53cd\u590d\u770b\u8fc7 N \u904d\u624d\u7b97\u8bfb\u5b8c
\u5148\u8bfb AoS \u7b2c\u516d\u7ae0: Models, Statistical Inference and Learning\uff0c\u8fd9\u4e00\u90e8\u5206\u662f\u6700\u57fa\u7840\u7684\u79d1\u666e
\u4e8e\u662f\u6211\u5f80\u524d\u7ffb\uff0c\u7ffb\u5230\u4e86\u7b2c 3 \u7ae0 (Linear Model for Regression)\uff0c\u770b\u5230\u4e86\u6700\u7b80\u5355\u7684 posterior
"},{"location":"%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/CS224n/","title":"CS224n: Natural Language Processing","text":""},{"location":"%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/CS224n/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
"},{"location":"%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/CS224w/","title":"CS224w: Machine Learning with Graphs","text":""},{"location":"%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/CS224w/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
"},{"location":"%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/CS230/","title":"Coursera: Deep Learning","text":""},{"location":"%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/CS230/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
"},{"location":"%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/CS231/","title":"CS231n: CNN for Visual Recognition","text":""},{"location":"%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/CS231/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
"},{"location":"%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/CS285/","title":"CS285: Deep Reinforcement Learning","text":""},{"location":"%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/CS285/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
"},{"location":"%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/EECS498-007/","title":"UMich EECS 498-007 / 598-005: Deep Learning for Computer Vision","text":""},{"location":"%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/EECS498-007/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
"},{"location":"%E7%94%B5%E5%AD%90%E5%9F%BA%E7%A1%80/EE16/","title":"UCB EE16A&B: Designing Information Devices and Systems I&II","text":""},{"location":"%E7%94%B5%E5%AD%90%E5%9F%BA%E7%A1%80/EE16/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
"},{"location":"%E7%94%B5%E5%AD%90%E5%9F%BA%E7%A1%80/Signals_and_Systems_AVO/","title":"MIT 6.007 Signals and Systems","text":""},{"location":"%E7%94%B5%E5%AD%90%E5%9F%BA%E7%A1%80/Signals_and_Systems_AVO/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u6240\u5c5e\u5927\u5b66\uff1aMIT
\u5148\u4fee\u8981\u6c42\uff1aCalculus, Linear Algebra
"},{"location":"%E7%94%B5%E5%AD%90%E5%9F%BA%E7%A1%80/signal/","title":"UCB EE120: Signal and Systems","text":""},{"location":"%E7%94%B5%E5%AD%90%E5%9F%BA%E7%A1%80/signal/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
"},{"location":"%E7%B3%BB%E7%BB%9F%E5%AE%89%E5%85%A8/CSE365/","title":"ASU CSE365: Introduction to Cybersecurity","text":""},{"location":"%E7%B3%BB%E7%BB%9F%E5%AE%89%E5%85%A8/CSE365/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u6240\u5c5e\u5927\u5b66\uff1aArizona State University
\u5148\u4fee\u8981\u6c42\uff1a\u65e0
\u7f16\u7a0b\u8bed\u8a00\uff1aC, Python, x86 assembly
\u4e9a\u5229\u6851\u90a3\u5dde\u7acb\u5927\u5b66 Web \u5b89\u5168\u7684\u5bfc\u8bba\u8bfe\uff0c\u8bfe\u7a0b\u4ee5\u6a21\u5757\u5316\u7684\u5f62\u5f0f\u6784\u6210\uff0c\u4e3b\u8981\u5305\u542b\u4ee5\u4e0b\u65b9\u9762\uff1a
Program Misuse: Linux commandline, privilege escalation
"},{"location":"%E7%B3%BB%E7%BB%9F%E5%AE%89%E5%85%A8/CSE466/","title":"ASU CSE466: Computer Systems Security","text":""},{"location":"%E7%B3%BB%E7%BB%9F%E5%AE%89%E5%85%A8/CSE466/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u6240\u5c5e\u5927\u5b66\uff1aArizona State University
\u5148\u4fee\u8981\u6c42\uff1a\u65e0
\u7f16\u7a0b\u8bed\u8a00\uff1aC, Python, x86 assembly
"},{"location":"%E7%B3%BB%E7%BB%9F%E5%AE%89%E5%85%A8/MIT6.1600/","title":"MIT6.1600: Foundations of Computer Security","text":""},{"location":"%E7%B3%BB%E7%BB%9F%E5%AE%89%E5%85%A8/MIT6.1600/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
"},{"location":"%E7%B3%BB%E7%BB%9F%E5%AE%89%E5%85%A8/MIT6.858/","title":"MIT 6.858: Computer System Security","text":""},{"location":"%E7%B3%BB%E7%BB%9F%E5%AE%89%E5%85%A8/MIT6.858/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
MIT \u7684\u8ba1\u7b97\u673a\u7cfb\u7edf\u5b89\u5168\u8bfe\u7a0b\uff0c\u5b9e\u9a8c\u73af\u5883\u662f\u4e00\u4e2a Web Application Zoobar\u3002\u5b66\u751f\u5b66\u4e60\u653b\u9632\u6280\u672f\u5e76\u5e94\u7528\u4e8e\u8be5 Web Application\u3002
Lab 1: you will explore the zoobar web application, and use buffer overflow attacks to break its security properties.
Lab 2: you will improve the zoobar web application by using privilege separation, so that if one component is compromised, the adversary doesn't get control over the whole web application.
Lab 3: you will build a program analysis tool based on symbolic execution to find bugs in Python code such as the zoobar web application.
Lab 4: you will improve the zoobar application against browser attacks.
\u9664\u4e86 MIT \u5b98\u65b9\u7684\u5b66\u4e60\u8d44\u6599\u5916\uff0c\u5317\u4eac\u5927\u5b66\u56fe\u7075\u73ed\u5f00\u8bbe\u7684\u524d\u6cbf\u8ba1\u7b97\u5b9e\u8df5\u4e2d\u4e5f\u5f00\u8bbe\u4e86\u76f8\u5173\u8bfe\u7a0b\uff0c\u8d44\u6599\u4f4d\u4e8e\u8fd9\u4e2a\u7f51\u7ad9\u4e0b\uff0c\u4f9b\u5927\u5bb6\u53c2\u8003\u3002
"},{"location":"%E7%BC%96%E7%A8%8B%E5%85%A5%E9%97%A8/C/CS50/","title":"CS50: This is CS50x","text":""},{"location":"%E7%BC%96%E7%A8%8B%E5%85%A5%E9%97%A8/C/CS50/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u8bfe\u7a0b\u89c6\u9891\uff1a\u539f\u7248\u53c2\u8003\u8bfe\u7a0b\u7f51\u7ad9\uff0c\u4e5f\u53ef\u4ee5\u5728 B \u7ad9\u627e\u5230\u4e2d\u6587\u5b57\u5e55\u7248\u3002
"},{"location":"%E7%BC%96%E7%A8%8B%E5%85%A5%E9%97%A8/C/Duke-Coursera-Intro-C/","title":"Introductory C Programming Specialization","text":""},{"location":"%E7%BC%96%E7%A8%8B%E5%85%A5%E9%97%A8/C/Duke-Coursera-Intro-C/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
@haidongji \u5728\u5b66\u4e60\u8fd9\u95e8\u8bfe\u4e2d\u7684\u4f5c\u4e1a\u5b9e\u73b0\u90fd\u6c47\u603b\u5728 Duke Coursera Intro C \u4e2d\u3002\u56e0\u4e3a\u65f6\u95f4\u5173\u7cfb\uff0c\u6211\u6700\u540e\u4e00\u8bfe\u6700\u540e\u4e00\u5468\u7684\u51e0\u4e2a\u4f5c\u4e1a\u5230\u76ee\u524d\u8fd8\u6ca1\u6709\u5b8c\u6210\u3002
\u4e3b\u8bb2\u8001\u5e08 Michael Ryan Clarkson\uff0c\u6d78\u6deb\u7f16\u7a0b\u591a\u5e74\uff0c\u7528\u8bcd\u7b80\u5355\uff0c\u8868\u8ff0\u6e05\u6670\uff0c\u5185\u5bb9\u73af\u73af\u76f8\u6263\uff0c\u5256\u6790\u4e00\u9488\u89c1\u8840\u3002\u8bfe\u7a0b\u89c6\u9891\u751a\u81f3\u7528\u6765\u7ec3\u542c\u529b\uff0c\u542c\u4e0d\u61c2\u5f00\u82f1\u6587\u5b57\u5e55\u7406\u89e3\u8d77\u6765\u6beb\u4e0d\u8d39\u529b\u3002
"},{"location":"%E7%BC%96%E7%A8%8B%E5%85%A5%E9%97%A8/Java/MIT%206.092/","title":"MIT 6.092: Introduction To Programming In Java","text":""},{"location":"%E7%BC%96%E7%A8%8B%E5%85%A5%E9%97%A8/Java/MIT%206.092/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
"},{"location":"%E7%BC%96%E7%A8%8B%E5%85%A5%E9%97%A8/Python/CS50P/","title":"CS50P Introduction to Programming with Python","text":""},{"location":"%E7%BC%96%E7%A8%8B%E5%85%A5%E9%97%A8/Python/CS50P/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
"},{"location":"%E7%BC%96%E7%A8%8B%E5%85%A5%E9%97%A8/Python/CS61A/","title":"CS61A: Structure and Interpretation of Computer Programs","text":""},{"location":"%E7%BC%96%E7%A8%8B%E5%85%A5%E9%97%A8/Python/CS61A/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
"},{"location":"%E7%BC%96%E7%A8%8B%E5%85%A5%E9%97%A8/Rust/CS110L/","title":"CS110L: Safety in Systems Programming","text":""},{"location":"%E7%BC%96%E7%A8%8B%E5%85%A5%E9%97%A8/Rust/CS110L/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u5982\u679c\u4f60\u5b66\u8fc7 C \u5e76\u63a5\u89e6\u8fc7\u4e00\u4e9b\u7cfb\u7edf\u7f16\u7a0b\u7684\u8bdd\uff0c\u5e94\u8be5\u5bf9 C \u7684\u5185\u5b58\u6cc4\u6f0f\u4ee5\u53ca\u6307\u9488\u7684\u5371\u9669\u6709\u6240\u8033\u95fb\uff0c\u4f46 C \u7684\u5e95\u5c42\u7279\u6027\u4ee5\u53ca\u9ad8\u6548\u4ecd\u7136\u8ba9\u5b83\u5728\u7cfb\u7edf\u7ea7\u7f16\u7a0b\u4e2d\u65e0\u6cd5\u88ab\u4f8b\u5982 Java \u7b49\u81ea\u5e26\u5783\u573e\u6536\u96c6\u673a\u5236\u7684\u9ad8\u7ea7\u8bed\u8a00\u6240\u66ff\u4ee3\u3002\u800c Rust \u7684\u76ee\u6807\u5219\u662f\u5e0c\u671b\u5728 C \u7684\u9ad8\u6548\u57fa\u7840\u4e0a\uff0c\u5f25\u8865\u5176\u5b89\u5168\u4e0d\u8db3\u7684\u7f3a\u70b9\u3002\u56e0\u6b64 Rust \u5728\u8bbe\u8ba1\u4e4b\u521d\uff0c\u5c31\u6709\u5e26\u6709\u5f88\u591a\u7cfb\u7edf\u7f16\u7a0b\u7684\u89c2\u70b9\u3002\u5b66\u4e60 Rust\uff0c\u4e5f\u80fd\u8ba9\u4f60\u4e4b\u540e\u80fd\u7528 C \u8bed\u8a00\u7f16\u5199\u51fa\u66f4\u5b89\u5168\u66f4\u4f18\u96c5\u7684\u7cfb\u7edf\u7ea7\u4ee3\u7801\uff08\u4f8b\u5982\u64cd\u4f5c\u7cfb\u7edf\u7b49\uff09\u3002
"},{"location":"%E7%BC%96%E7%A8%8B%E5%85%A5%E9%97%A8/cpp/AUT1400/","title":"Amirkabir University of Technology 1400-2: Advanced Programming Course","text":""},{"location":"%E7%BC%96%E7%A8%8B%E5%85%A5%E9%97%A8/cpp/AUT1400/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u6240\u5c5e\u5927\u5b66\uff1aAmirkabir University of Technology
"},{"location":"%E7%BC%96%E7%A8%8B%E5%85%A5%E9%97%A8/cpp/CS106L/","title":"CS106L: Standard C++ Programming","text":""},{"location":"%E7%BC%96%E7%A8%8B%E5%85%A5%E9%97%A8/cpp/CS106L/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u6211\u4ece\u5927\u4e00\u5f00\u59cb\u4e00\u76f4\u90fd\u662f\u5199\u7684 C++ \u4ee3\u7801\uff0c\u76f4\u5230\u5b66\u5b8c\u8fd9\u95e8\u8bfe\u6211\u624d\u610f\u8bc6\u5230\uff0c\u6211\u5199\u7684 C++ \u4ee3\u7801\u5927\u6982\u53ea\u662f C \u8bed\u8a00 + cin/cout \u800c\u5df2\u3002
\u8fd9\u95e8\u8bfe\u4f1a\u6df1\u5165\u5230\u5f88\u591a\u6807\u51c6 C++ \u7684\u7279\u6027\u548c\u8bed\u6cd5\uff0c\u8ba9\u4f60\u7f16\u5199\u51fa\u9ad8\u8d28\u91cf\u7684 C++ \u4ee3\u7801\u3002\u4f8b\u5982 auto binding, uniform initialization, lambda function, move semantics\uff0cRAII \u7b49\u6280\u5de7\u90fd\u5728\u6211\u6b64\u540e\u7684\u4ee3\u7801\u751f\u6daf\u4e2d\u88ab\u53cd\u590d\u7528\u5230\uff0c\u975e\u5e38\u5b9e\u7528\u3002
\u4e3b\u8bb2\u8001\u5e08 Will Crichton \u8fd8\u5c06\u4ed6\u7684\u8bfe\u7a0b\u8bbe\u8ba1\u601d\u60f3\u5199\u6210\u4e86\u8bba\u6587 From Theory to Systems: A Grounded Approach to Programming Language Education\uff0c\u9610\u8ff0\u4e86\u8fd9\u6761\u4ece\u7406\u8bba\u8d70\u5411\u7cfb\u7edf\u7684\u6559\u5b66\u8def\u7ebf\u3002
"},{"location":"%E7%BC%96%E7%A8%8B%E8%AF%AD%E8%A8%80%E8%AE%BE%E8%AE%A1%E4%B8%8E%E5%88%86%E6%9E%90/Cambridge-Semantics/","title":"Cambridge: Semantics of Programming Languages","text":""},{"location":"%E7%BC%96%E7%A8%8B%E8%AF%AD%E8%A8%80%E8%AE%BE%E8%AE%A1%E4%B8%8E%E5%88%86%E6%9E%90/Cambridge-Semantics/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u6240\u5c5e\u5927\u5b66\uff1aUniversity of Cambridge
\u8be5\u8bfe\u7a0b\u9762\u5411\u771f\u5b9e\u7684 C \u8bed\u8a00\u800c\u975e\u81ea\u5b9a\u4e49\u7684\u73a9\u5177\u8bed\u8a00\uff0c\u5e76\u4e14\u4f1a\u4f7f\u7528 C \u8bed\u8a00 Fuzzing \u5de5\u5177 (Csmith) \u8fdb\u884c\u6d4b\u8bd5\u3002
\u8be5\u8bfe\u7a0b\u6ce8\u91cd\u5b9e\u7528\u6027\uff0c\u5bf9\u7f16\u8bd1\u5668\u524d\u7aef\u7406\u8bba\u6d89\u53ca\u5f88\u5c11\uff0c\u7b2c\u4e00\u4e2a\u5b9e\u9a8c\u4e5f\u662f\u76f4\u63a5\u4ece\u62bd\u8c61\u8bed\u6cd5\u6811\u7684\u904d\u5386\u5f00\u59cb\uff0c\u5e76\u4e0d\u8981\u6c42\u4f60\u624b\u52a8\u5b8c\u6210\u524d\u7aef\u3002\u8bfe\u7a0b\u91cd\u70b9\u5173\u6ce8\u4e8e IR \u7684\u8bbe\u8ba1\u3001\u751f\u6210\u548c\u4f18\u5316\uff0c\u4ee5\u53ca RISC-V \u6c47\u7f16\u4ee3\u7801\u751f\u6210\u3002\u672c\u8bfe\u7a0b\u5bf9\u4e8e\u7406\u89e3\u548c\u5b66\u4e60 LLVM \u4e5f\u5f88\u6709\u5e2e\u52a9\u3002
\u6559\u7a0b\u91c7\u7528\u589e\u91cf\u5f0f\u3001\u8fed\u4ee3\u5f0f\u7684\u601d\u8def\uff0c\u5f15\u5bfc\u4f60\u4ece\u4e00\u4e2a\u53ea\u80fd\u5904\u7406 main \u51fd\u6570\u7684\u7f16\u8bd1\u5668\u5f00\u59cb\uff0c\u9010\u6b65\u6269\u5c55\u5b9e\u73b0\u4e00\u4e2a\u80fd\u5904\u7406\u5305\u62ec\u63a7\u5236\u6d41\u3001\u51fd\u6570\u8c03\u7528\u3001\u6570\u7ec4\u5728\u5185\u7684\uff0c\u7c7b C \u8bed\u8a00\u7684\u7f16\u8bd1\u5668\u3002\u7f16\u8bd1\u5668\u53ef\u4ee5\u8f93\u51fa RISC-V \u6c47\u7f16\u3002
\u6559\u7a0b\u4ecb\u7ecd\u4e86\u76f8\u5173\u5de5\u5177\uff0c\u53ef\u4ee5\u4e3a\u4f60\u4ee3\u52b3\u4e00\u4e9b\u67af\u71e5\u7684\u82e6\u529b\u6d3b\uff0c\u6bd4\u5982\u751f\u6210 lexer/parser\uff0c\u89e3\u6790\u548c\u751f\u6210 IR \u7b49\u7b49\u3002\u5269\u4e0b\u7684\u4e8b\u60c5\uff0c\u5982\u6784\u5efa AST\u3001\u8bed\u4e49\u5206\u6790\u3001\u751f\u6210 IR \u4ee5\u53ca\u751f\u6210\u76ee\u6807\u4ee3\u7801\uff0c\u5b8c\u5168\u7531\u4f60\u81ea\u5df1\u7f16\u7a0b\u5b9e\u73b0\u3002
\u6700\u540e\uff0c\u5411 @MaxXing \u81f4\u4ee5\u6211\u5d07\u9ad8\u7684\u656c\u610f\u3002\u2014\u2014 from PKUFlyingPig
"},{"location":"%E7%BC%96%E8%AF%91%E5%8E%9F%E7%90%86/USTC-Compilers/","title":"USTC: Principles and Techniques of Compiler","text":""},{"location":"%E7%BC%96%E8%AF%91%E5%8E%9F%E7%90%86/USTC-Compilers/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u8fd9\u95e8\u8bfe\u7a0b\u7684\u7406\u8bba\u90e8\u5206\u5185\u5bb9\u5e7f\u6cdb\uff0c\u65e2\u6db5\u76d6\u4e86\u4f20\u7edf\u7f16\u8bd1\u539f\u7406\u8bfe\u7a0b\u7684\u8bcd\u6cd5\u5206\u6790\u3001\u8bed\u6cd5\u5206\u6790\u3001\u8bed\u6cd5\u5236\u5bfc\u7ffb\u8bd1\u3001\u4e2d\u95f4\u4ee3\u7801\u7ffb\u8bd1\uff0c\u53c8\u8986\u76d6\u4e86\u8fd0\u884c\u65f6\u7ba1\u7406\u3001\u673a\u5668\u65e0\u5173\u4e0e\u9762\u5411\u673a\u5668\u7684\u4ee3\u7801\u4f18\u5316\u3002\u5b9e\u9a8c\u90e8\u5206\u5219\u63d0\u4f9b\u4e86 C++ \u8bed\u8a00\u7f16\u5199\u7684Cminusf\u7f16\u8bd1\u5668\u6846\u67b6\u4ee3\u7801\uff0c\u4e8e6\u4e2a\u5b9e\u9a8c\u4e2d\u9010\u6b65\u6784\u5efa\u4e00\u4e2a\u5177\u5907\u73b0\u4ee3\u5b8c\u6574\u6d41\u7a0b\u7684\u7f16\u8bd1\u5668\u3002\u4e0e\u5176\u4ed6\u7f16\u8bd1\u539f\u7406\u8bfe\u7a0b\u7684\u5b9e\u9a8c\u4e0d\u540c\u7684\u662f\uff0c\u672c\u8bfe\u7a0b\u7684\u5b9e\u9a8c\u91c7\u7528\u73b0\u4ee3LLVM\u7684\u5b50\u96c6\u4f5c\u4e3a\u4e2d\u95f4\u4ee3\u7801\uff0c\u66f4\u5177\u524d\u77bb\u6027\uff0c\u540c\u65f6\u5305\u62ec\u4e86\u540e\u7aef\u4ee3\u7801\u7684\u751f\u6210\u548c\u4e2d\u95f4\u4ee3\u7801\u4f18\u5316\u7684\u90e8\u5206\uff0c\u582a\u79f0\u56fd\u9645\u4e00\u6d41\u7684\u7f16\u8bd1\u539f\u7406\u8bfe\u7a0b\u3002
"},{"location":"%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%B3%BB%E7%BB%9F%E5%9F%BA%E7%A1%80/CS110/","title":"CS110: Principles of Computer Systems","text":""},{"location":"%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%B3%BB%E7%BB%9F%E5%9F%BA%E7%A1%80/CS110/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u5317\u5927\u8d2d\u4e70\u4e86\u8fd9\u95e8\u8bfe\u7684\u7248\u6743\u5e76\u5f00\u8bbe\u4e86 Introduction to Computer System \u8fd9\u95e8\u8bfe\uff0c\u4f46\u5176\u5b9e CSAPP \u6240\u6709\u7684\u8bfe\u7a0b\u8d44\u6e90\u548c\u5b9e\u9a8c\u4ee3\u7801\u90fd\u80fd\u5728\u5b83\u7684\u5b98\u65b9\u4e3b\u9875\u4e0a\u8bbf\u95ee\u5230\uff08\u5177\u4f53\u53c2\u89c1\u4e0b\u65b9\u94fe\u63a5\uff09\u3002
\u8fd9\u95e8\u8bfe\u7684\u4e3b\u8bb2\u4eba\u4e4b\u4e00\u662f\u7f51\u7edc\u9886\u57df\u7684\u5de8\u64d8 Nick McKeown \u6559\u6388\u3002\u8fd9\u4f4d\u62e5\u6709\u81ea\u5df1\u521b\u4e1a\u516c\u53f8\u7684\u5b66\u754c\u4e1a\u754c\u53cc\u5de8\u4f6c\u4f1a\u5728\u4ed6\u6155\u8bfe\u6bcf\u4e00\u7ae0\u8282\u7684\u6700\u540e\u91c7\u8bbf\u4e00\u4f4d\u4e1a\u754c\u7684\u9ad8\u7ba1\u6216\u8005\u5b66\u754c\u7684\u9ad8\u4eba\uff0c\u975e\u5e38\u5f00\u9614\u773c\u754c\u3002
\u5728\u8fd9\u95e8\u8bfe\u7684 Project \u4e2d\uff0c\u4f60\u5c06\u7528 C++ \u5faa\u5e8f\u6e10\u8fdb\u5730\u642d\u5efa\u51fa\u6574\u4e2a TCP/IP \u534f\u8bae\u6808\uff0c\u5b9e\u73b0 IP \u8def\u7531\u4ee5\u53ca ARP \u534f\u8bae\uff0c\u6700\u540e\u5229\u7528\u4f60\u81ea\u5df1\u7684\u534f\u8bae\u6808\u4ee3\u66ff Linux Kernel \u7684\u7f51\u7edc\u534f\u8bae\u6808\u548c\u5176\u4ed6\u5b66\u751f\u7684\u8ba1\u7b97\u673a\u8fdb\u884c\u901a\u4fe1\uff0c\u975e\u5e38 amazing\uff01
"},{"location":"%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%BD%91%E7%BB%9C/topdown/","title":"Computer Networking: A Top-Down Approach","text":""},{"location":"%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%BD%91%E7%BB%9C/topdown/#_1","title":"\u8bfe\u7a0b\u7b80\u4ecb","text":"
\u300a\u81ea\u9876\u5411\u4e0b\u65b9\u6cd5\u300b\u662f\u8ba1\u7b97\u673a\u7f51\u7edc\u9886\u57df\u7684\u4e00\u672c\u7ecf\u5178\u6559\u6750\uff0c\u4e24\u4f4d\u4f5c\u8005 Jim Kurose \u548c Keith Ross \u7cbe\u5fc3\u5236\u4f5c\u4e86\u6559\u6750\u914d\u5957\u7684\u8bfe\u7a0b\u7f51\u7ad9\uff0c\u5e76\u4e14\u516c\u5f00\u4e86\u81ea\u5df1\u5f55\u5236\u7684\u7f51\u8bfe\u89c6\u9891\uff0c\u4ea4\u4e92\u5f0f\u7684\u5728\u7ebf\u7ae0\u8282\u6d4b\u8bd5\uff0c\u4ee5\u53ca\u5229\u7528 WireShark \u8fdb\u884c\u6293\u5305\u5206\u6790\u7684 lab\u3002\u552f\u4e00\u9057\u61be\u7684\u662f\u8fd9\u95e8\u8bfe\u5e76\u6ca1\u6709\u786c\u6838\u7684\u7f16\u7a0b\u4f5c\u4e1a\uff0c\u800c Stanford \u7684 CS144 \u80fd\u5f88\u597d\u5730\u5f25\u8865\u8fd9\u4e00\u70b9\u3002
Safe from bugs. Correctness (correct behavior right now) and defensiveness (correct behavior in the future) are required in any software we build.
Easy to understand. The code has to communicate to future programmers who need to understand it and make changes in it (fixing bugs or adding new features). That future programmer might be you, months or years from now. You\u2019ll be surprised how much you forget if you don\u2019t write it down, and how much it helps your own future self to have a good design.
Ready for change. Software always changes. Some designs make it easy to make changes; others require throwing away and rewriting a lot of code.
\u4f2f\u514b\u5229\u7684\u8f6f\u4ef6\u5de5\u7a0b\u8bfe\u7a0b\uff0c\u4e0d\u540c\u4e8e\u5f88\u591a\u4f20\u7edf\u7684\u8f6f\u4ef6\u5de5\u7a0b\u8bfe\u5f3a\u8c03\u5404\u79cd\u7c7b\u56fe\u3001\u6587\u6863\u8bbe\u8ba1 (plan and document \u6a21\u5f0f)\uff0c\u8fd9\u95e8\u8bfe\u4e13\u6ce8\u4e8e\u6700\u8fd1\u9010\u6e10\u6d41\u884c\u8d77\u6765\u7684\u654f\u6377\u5f00\u53d1 (Agile Development)\u6a21\u5f0f\uff0c\u5229\u7528\u4e91\u5e73\u53f0\u63d0\u4f9b\u8f6f\u4ef6\u5373\u670d\u52a1 (software as a service)\u3002\u4e3a\u6b64\uff0c\u8bfe\u7a0b\u8bbe\u8ba1\u8005\u7f16\u5199\u4e86 Software as a service \u8fd9\u672c\u6559\u6750\uff0c\u901a\u8fc7 Ruby/Rails \u6846\u67b6\u6765\u9610\u91ca SaaS \u8fd9\u4e2a\u6982\u5ff5\uff0c\u5e76\u4e14\u6709\u4e30\u5bcc\u7684\u914d\u5957\u7f16\u7a0b\u7ec3\u4e60\u3002
\u8fd9\u95e8\u8bfe\u5728 Edx \u8fd9\u4e2a\u7531 MIT \u548c Harvard \u5927\u5b66\u53d1\u8d77\u7684\u5728\u7ebf\u6559\u80b2\u5e73\u53f0\u5168\u8d44\u6599\u5f00\u6e90\uff0c\u5927\u5bb6\u53ef\u4ee5\u5728 Edx \u81ea\u884c\u641c\u7d22 Agile SaaS Development \u8fd9\u95e8\u8bfe\u7a0b\u8fdb\u884c\u5b66\u4e60\u3002\u8bfe\u7a0b\u5185\u5bb9\u57fa\u672c\u6309\u7167\u6559\u6750\u7684\u987a\u5e8f\u5e26\u4f60\u4e00\u6b65\u6b65\u4ee5\u654f\u6377\u5f00\u53d1\u7684\u65b9\u5f0f\u642d\u5efa\u4e00\u4e2a\u8f6f\u4ef6\u5e76\u514d\u8d39\u90e8\u7f72\u5728\u4e91\u5e73\u53f0\u4e0a\u3002
This is a self-learning guide to computer science, and a memento of my three years of self-learning at university.
It is also a gift to the young students at Peking University. It would be a great encouragement and comfort to me if this book could be of even the slightest help to you in your college life.
The book is currently organized to include the following sections (if you have other good suggestions, or would like to join the ranks of contributors, please feel free to email zhongyinmin@pku.edu.cn or ask questions in the issue).
User guide for this book: Given the numerous resources covered in this book, I have developed corresponding usage guides based on different people's free time and learning objectives.
A reference CS learning plan: This is a comprehensive and systematic CS self-learning plan that I have formulated based on my own self-study experience.
Productivity Toolkit: IDE, VPN, StackOverflow, Git, Github, Vim, Latex, GNU Make and so on.
Book recommendations: Those who have read the CSAPP must have realized the importance of good books. I will list links to books and resources in different areas of Computer Science that I find rewarding to read.
List of high quality CS courses: I will summarize all the high quality foreign CS courses I have taken and the community contributed into different categories and give relevant self-learning advice. Most of them will have a separate repository containing relevant resources as well as the homework/project implementations.
"},{"location":"en/#the-place-where-dreams-start-cs61a","title":"The place where dreams start \u2014\u2014 CS61A","text":"
In my freshman year, I was a novice who knew nothing about computers. I installed a giant IDE Visual Studio and fight with OJ every day. With my high school maths background, I did pretty well in maths courses, but I felt struggled to learn courses in my major. When it came to programming, all I could do was open up that clunky IDE, create a new project that I didn't know exactly what it was for, and then cin, cout, for loops, and then CE, RE, WA loops. I was in a state where I was desperately trying to learn well but I didn't know how to learn. I listened carefully in class but I couldn't solve the homework problems. I spent almost all my spare time doing the homework after class, but the results were disappointing. I still retain the source code of the project for Introduction to Computing course \u2014\u2014 a single 1200-line C++ file with no header files, no class abstraction, no unit tests, no makefile, no version control. The only good thing is that it can run, the disadvantage is the complement of \"can run\". For a while I wondered if I wasn't cut out for computer science, as all my childhood imaginings of geekiness had been completely ruined by my first semester's experience.
It all turned around during the winter break of my freshman year, when I had a hankering to learn Python. I overheard someone recommend CS61A, a freshman introductory course at UC Berkeley on Python. I'll never forget that day, when I opened the CS61A course website. It was like Columbus discovering a new continent, and I opened the door to a new world.
I finished the course in 3 weeks and for the first time I felt that CS could be so fulfilling and interesting, and I was shocked that there existed such a great course in the world.
To avoid any suspicion of pandering to foreign courses, I will tell you about my experience of studying CS61A from the perspective of a pure student.
Course website developed by course staffs: The course website integrates all the course resources into one, with a well organised course schedule, links to all slides, recorded videos and homework, detailed and clear syllabus, list of exams and solutions from previous years. Aesthetics aside, this website is so convenient for students.
Textbook written by course instructor: The course instructor has adapted the classic MIT textbook Structure and Interpretation of Computer Programs (SICP) into Python (the original textbook was based on Scheme). This is a great way to ensure that the classroom content is consistent with the textbook, while adding more details. The entire book is open source and can be read directly online.
Various, comprehensive and interesting homework: There are 14 labs to reinforce the knowledge gained in class, 10 homework assignments to practice, and 4 projects each with thousands of lines of code, all with well-organized skeleton code and babysitting instructions. Unlike the old-school OJ and Word document assignments, each lab/homework/project has a detailed handout document, fully automated grading scripts, and CS61A staffs have even developed an automated assignment submission and grading system. Of course, one might say \"How much can you learn from a project where most of code are written by your teaching assistants?\" . For someone who is new to CS and even stumbling over installing Python, this well-developed skeleton code allows students to focus on reinforcing the core knowledge they've learned in class, but also gives them a sense of achievement that they already can make a little game despite of learning Python only for a month. It also gives them the opportunity to read and learn from other people's high quality code so that they can reuse it later. I think in the freshman year, this kind of skeleton code is absolutely beneficial. The only bad thing perhaps is for the instructors and teaching assistants, as developing such assignments can conceivably require a considerable time commitment.
Weekly discussion sessions: The teaching assistants will explain the difficult knowledge in class and add some supplementary materials which may not be covered in class. Also, there will be exercises from exams of previous years. All the exercises are written in LaTeX with solutions.
In CS61A, You don't need any prerequesites about CS at all. You just need to pay attention, spend time and work hard. The feeling that you do not know what to do, that you are not getting anything in return for all the time you put in, is gone. It suited me so well that I fell in love with self-learning.
Imagine that if someone could chew up the hard knowledge and present it to you in a vivid and straightforward way, with so many fancy and varied projects to reinforce your theoretical knowledge, you'd think they were really trying their best to make you fully grasp the course, and it was even an insult to the course builders not to learn it well.
If you think I'm exaggerating, start with CS61A, because it's where my dreams began.
"},{"location":"en/#why-write-this-book","title":"Why write this book?","text":"
In the 2020 Fall semester, I worked as a teaching assistant for the class \"Introduction to Computer Systems\" at Peking University. At that time, I had been studying totally on my own for over a year. I enjoyed this style of learning immensely. To share this joy, I have made a CS Self-learning Materials List for students in my seminar. It was purely on a whim at the time, as I wouldn't dare to encourage my students to skip classes and study on their own.
But after another year of maintenance, the list has become quite comprehensive, covering most of the courses in Computer Science, Artificial Intelligence and Soft Engineering, and I have built separate repositories for each course, summarising the self-learning materials that I used.
In my last college year, when I opened up my curriculum book, I realized that it was already a subset of my self-learning list. By then, it was only two and a half years after I had started my self-learning journey. Then, a bold idea came to my mind: perhaps I could create a self-learning book, write down the difficulty I encountered and the interest I found during these years of self-learning, hoping to make it easy for students who may also enjoy self-learning to start their wonderful self-learning journey.
If you can build up the whole CS foundation in less than three years, have relatively solid mathematical skills and coding ability, experience dozens of projects with thousands of lines of code, master at least C/C++/Java/JS/Python/Go/Rust and other mainstream programming languages, have a good understanding of algorithms, circuits, architectures, networks, operating systems, compilers, artificial intelligence, machine learning, computer vision, natural language processing, reinforcement learning, cryptography, information theory, game theory, numerical analysis, statistics, distributed systems, parallel computing, database systems, computer graphics, web development, cloud computing, supercomputing etc. I think you will be confident enough to choose the area you are interested in, and you will be quite competitive in both industry and academia.
I firmly believe that if you have read to this line, you do not lack the ability and commitment to learn CS well, you just need a good teacher to teach you a good course. And I will try my best to pick such courses for you, based on my three years of experience.
"},{"location":"en/#pros","title":"Pros","text":"
For me, the biggest advantage of self-learning is that I can adjust the pace of learning entirely according to my own progress. For difficult parts, I can watch the videos over and over again, Google it online and ask questions on StackOverflow until I have it all figured out. For those that I mastered relatively quickly, I could skip them at twice or even three times the speed.
Another great thing about self-learning is that you can learn from different perspectives. I have taken core courses such as architectures, networking, operating systems, and compilers from different universities. Different instructors may have different views on the same knowledge, which will broaden your horizon.
A third advantage of self-learning is that you do not need to go to the class, listening to the boring lectures.
"},{"location":"en/#cons","title":"Cons","text":"
Of course, as a big fan of self-learning, I have to admit that it has its disadvantages.
The first is the difficulty of communication. I'm actually a very keen questioner, and I like to follow up all the points I don't understand. But when you're facing a screen and you hear a teacher talking about something you don't understand, you can't go to the other end of the network and ask him or her for clarification. I try to mitigate this by thinking independently and making good use of Google, but it would be great to have a few friends to study together. You can refer to README for more information on participating a community group.
The second thing is that these courses are basically in English. From the videos to the slides to the assignments, all in English. You may struggle at first, but I think it's a challenge that if you overcome, it will be extremely rewarding. Because at the moment, as reluctant as I am, I have to admit that in computer science, a lot of high quality documentation, forums and websites are all in English.
The third, and I think the most difficult one, is self-discipline. Because have no DDL can sometimes be a really scary thing, especially when you get deeper, many foreign courses are quite difficult. You have to be self-driven enough to force yourself to settle down, read dozens of pages of Project Handout, understand thousands of lines of skeleton code and endure hours of debugging time. With no credits, no grades, no teachers, no classmates, just one belief - that you are getting better.
"},{"location":"en/#who-is-this-book-for","title":"Who is this book for?","text":"
As I said in the beginning, anyone who is interested in learning computer science on their own can refer to this book. If you already have some basic skills and are just interested in a particular area, you can selectively pick and choose what you are interested in to study. Of course, if you are a novice who knows nothing about computers like I did back then, and just begin your college journey, I hope this book will be your cheat sheet to get the knowledge and skills you need in the least amount of time. In a way, this book is more like a course search engine ordered according to my experience, helping you to learn high quality CS courses from the world's top universities without leaving home.
Of course, as an undergraduate student who has not yet graduated, I feel that I am not in a position nor have the right to preach one way of learning. I just hope that this material will help those who are also self-motivated and persistent to gain a richer, more varied and satisfying college life.
I would like to express my sincere gratitude to all the professors who have made their courses public for free. These courses are the culmination of decades of their teaching careers, and they have chosen to selflessly make such a high quality CS education available to all. Without them, my university life would not have been as fulfilling and enjoyable. Many of the professors would even reply with hundreds of words in length after I had sent them a thank you email, which really touched me beyond words. They also inspired me all the time that if decide to do something, do it with all heart and soul.
"},{"location":"en/#want-to-join-as-a-contributor","title":"Want to join as a contributor?","text":"
There is a limit to how much one person can do, and this book was written by me under a heavy research schedule, so there are inevitably imperfections. In addition, as I work in the area of systems, many of the courses focus on systems, and there is relatively little content related to advanced mathematics, computing theory, and advanced algorithms. If any of you would like to share your self-learning experience and resources in other areas, you can directly initiate a Pull Request in the project, or feel free to contact me by email (zhongyinmin@pku.edu.cn).
"},{"location":"en/CS%E5%AD%A6%E4%B9%A0%E8%A7%84%E5%88%92/","title":"A Reference Guide for CS Learning","text":"
The field of computer science is vast and complex, with a seemingly endless sea of knowledge. Each specialized area can lead to limitless learning if pursued deeply. Therefore, a clear and definite study plan is very important. I've taken some detours in my years of self-study and finally distilled the following content for your reference.
Before you start learning, I highly recommend a popular science video series for beginners: Crash Course: Computer Science. In just 8 hours, it vividly and comprehensively covers various aspects of computer science: the history of computers, how computers operate, the important modules that make up a computer, key ideas in computer science, and so on. As its slogan says, Computers are not magic! I hope that after watching this video, everyone will have a holistic perception of computer science and embark on the detailed and in-depth learning content below with interest.
As the saying goes: sharpening your axe will not delay your job of chopping wood. If you are a pure beginner in the world of computers, learning some tools will make you more efficient.
Learn to ask questions: You might be surprised that asking questions is the first one listed? I think in the open-source community, learning to ask questions is a very important ability. It involves two aspects. First, it indirectly cultivates your ability to solve problems independently, as the cycle of forming a question, describing it, getting answers from others, and then understanding the response is quite long. If you expect others to remotely assist you with every trivial issue, then the world of computers might not suit you. Second, if after trying, you still can't solve a problem, you can seek help from the open-source community. But at that point, how to concisely explain your situation and goal to others becomes particularly important. I recommend reading the article How To Ask Questions The Smart Way, which not only increases the probability and efficiency of solving your problems but also keeps those who provide answers in the open-source community in a good mood.
Learn to be a hacker: MIT-Missing-Semester covers many useful tools for a hacker and provides detailed usage instructions. I strongly recommend beginners to study this course. However, one thing to note is that the course occasionally refers to terms related to the development process. Therefore, it is recommended to study it at least after completing an introductory computer science course.
GFW: For well-known reasons, sites like Google and GitHub are not accessible in mainland China. However, in many cases, Google and StackOverflow can solve 99% of the problems encountered during development. Therefore, learning to use a VPN is almost an essential skill for a mainland CSer. (Considering legal issues, the methods provided in this book are only applicable to users with a Peking University email address).
Command Line: Proficiency in using the command line is often overlooked or considered difficult to master, but in reality, it greatly enhances your flexibility and productivity as an engineer. The Art of Command Line is a classic tutorial that started as a question on Quora, but with the contribution of many experts, it has become a top GitHub project with over 100,000 stars, translated into dozens of languages. The tutorial is not long, and I highly recommend everyone to read it repeatedly and internalize it through practice. Also, mastering shell script programming should not be overlooked, and you can refer to this tutorial.
IDE (Integrated Development Environment): Simply put, it's where you write your code. The importance of an IDE for a programmer goes without saying, but many IDEs are designed for large-scale projects and are quite bulky and overly feature-rich. Nowadays, some lightweight text editors with rich plugin ecosystems can basically meet the needs of daily lightweight programming. My personal favorites are VS Code and Sublime (the former has a very simple plugin configuration, while the latter is a bit more complex but aesthetically pleasing). Of course, for large projects, I would still use slightly heavier IDEs, such as Pycharm (Python), IDEA (Java), etc. (Disclaimer: all IDEs are the best in the world).
Vim: A command-line editor. Vim has a somewhat steep learning curve, but mastering it, I think, is very necessary because it will greatly improve your development efficiency. Most modern IDEs also support Vim plugins, allowing you to retain the coolness of a geek while enjoying a modern development environment.
Emacs: A classic editor that stands alongside Vim, with equally high development efficiency and more powerful expandability. It can be configured as a lightweight editor or expanded into a custom IDE, and even more sophisticated tricks.
Git: A version control tool for your project. Git, created by the father of Linux, Linus, is definitely one of the must-have tools for every CS student.
GitHub: A code hosting platform based on Git. The world's largest open-source community and a gathering place for CS experts.
GNU Make: An engineering build tool. Proficiency in GNU Make will help you develop a habit of modularizing your code and familiarize you with the compilation and linking processes of large projects.
CMake: A more powerful build tool than GNU Make, recommended for study after mastering GNU Make.
LaTex: Pretentious Paper typesetting tool.
Docker: A lighter-weight software packaging and deployment tool compared to virtual machines.
Practical Toolkit: In addition to the tools mentioned above that are frequently used in development, I have also collected many practical and interesting free tools, such as download tools, design tools, learning websites, etc.
Thesis: Tutorial for writing graduation thesis in Word.
I believe a good textbook should be people-oriented, rather than a display of technical jargon. It's certainly important to tell readers \"what it is,\" but a better approach would be for the author to integrate decades of experience in the field into the book and narratively convey to the reader \"why it is\" and what should be done in the future.
If you are a Mac user, you're in luck, as this guide will walk you through setting up the entire development environment. If you are a Windows user, thanks to the efforts of the open-source community, you can enjoy a similar experience with Scoop.
Additionally, you can refer to an environment setup guide inspired by 6.NULL MIT-Missing-Semester, focusing on terminal beautification. It also includes common software sources (such as GitHub, Anaconda, PyPI) for acceleration and replacement, as well as some IDE configuration and activation tutorials.
Server-side operation and maintenance require basic use of Linux (or other Unix-like systems) and fundamental concepts like processes, devices, networks, etc. Beginners can refer to the Linux 101 online notes compiled by the Linux User Association of the University of Science and Technology of China. If you want to delve deeper into system operation and maintenance, you can refer to the Aspects of System Administration course.
Additionally, if you need to learn a specific concept or tool, I recommend a great GitHub project, DevOps-Guide, which covers a lot of foundational knowledge and tutorials in the administration field, such as Docker, Kubernetes, Linux, CI-CD, GitHub Actions, and more.
As mentioned at the beginning of this chapter, this course map is merely a reference guide for course planning, from my perspective as an undergraduate nearing graduation. I am acutely aware that I neither have the right nor the capability to preach to others about \u201chow one should learn\u201d. Therefore, if you find any issues with the course categorization and selection below, I fully accept and deeply apologize for them. You can tailor your own course map in the next section Customize Your Own Course Map.
Apart from courses labeled as basic or introductory, there is no explicit sequence in the following categories. As long as you meet the prerequisites for a course, you are free to choose any course according to your needs and interests.
"},{"location":"en/CS%E5%AD%A6%E4%B9%A0%E8%A7%84%E5%88%92/#mathematical-foundations","title":"Mathematical Foundations","text":""},{"location":"en/CS%E5%AD%A6%E4%B9%A0%E8%A7%84%E5%88%92/#calculus-and-linear-algebra","title":"Calculus and Linear Algebra","text":"
As a freshman, mastering calculus and linear algebra is as important as learning to code. This point has been reiterated countless times by predecessors, but I feel compelled to emphasize it again: mastering calculus and linear algebra is really important! You might complain that these subjects are forgotten after exams, but I believe that indicates a lack of deep understanding of their essence. If you find the content taught in class to be obscure, consider referring to MIT\u2019s Calculus Course and 18.06: Linear Algebra course notes. For me, they greatly deepened my understanding of the essence of calculus and linear algebra. Also, I highly recommend the maths YouTuber 3Blue1Brown, whose channel features videos explaining the core of mathematics with vivid animations, offering both depth and breadth of high quality.
"},{"location":"en/CS%E5%AD%A6%E4%B9%A0%E8%A7%84%E5%88%92/#introduction-to-information-theory","title":"Introduction to Information Theory","text":"
For computer science students, gaining some foundational knowledge in information theory early on is beneficial. However, most information theory courses are targeted towards senior or even graduate students, making them quite inaccessible to beginners. MIT\u2019s 6.050J: Information theory and Entropy is tailored for freshmen, with almost no prerequisites, covering coding, compression, communication, information entropy, and more, which is very interesting.
"},{"location":"en/CS%E5%AD%A6%E4%B9%A0%E8%A7%84%E5%88%92/#advanced-mathematics","title":"Advanced Mathematics","text":""},{"location":"en/CS%E5%AD%A6%E4%B9%A0%E8%A7%84%E5%88%92/#discrete-mathematics-and-probability-theory","title":"Discrete Mathematics and Probability Theory","text":"
Set theory, graph theory, and probability theory are essential tools for algorithm derivation and proof, as well as foundations for more advanced mathematical courses. However, the teaching of these subjects often falls into a rut of being overly theoretical and formalistic, turning classes into mere recitations of theorems and conclusions without helping students grasp the essence of these theories. If theory teaching can be interspersed with examples of algorithm application, students can expand their algorithm knowledge while appreciating the power and charm of theory.
UCB CS70: Discrete Math and Probability Theory and UCB CS126: Probability Theory are UC Berkeley\u2019s probability courses. The former covers the basics of discrete mathematics and probability theory, while the latter delves into stochastic processes and more advanced theoretical content. Both emphasize the integration of theory and practice and feature abundant examples of algorithm application, with the latter including numerous Python programming assignments to apply probability theory to real-world problems.
For computer science students, developing computational thinking is crucial. Modeling and discretizing real-world problems, and simulating and analyzing them on computers, are vital skills. Recently, the Julia programming language, developed by MIT, has become popular in the field of numerical computation with its C-like speed and Python-friendly syntax. Many MIT mathematics courses have started using Julia as a teaching tool, presenting complex mathematical theories through clear and intuitive code.
ComputationalThinking is an introductory course in computational thinking offered by MIT. All course materials are open source and accessible on the course website. Using the Julia programming language, the course covers image processing, social science and data science, and climatology modeling, helping students understand algorithms, mathematical modeling, data analysis, interactive design, and graph presentation. The course content, though not difficult, profoundly impressed me with the idea that the allure of science lies not in obscure theories or jargon but in presenting complex concepts through vivid examples and concise, deep language.
After completing this experience course, if you\u2019re still eager for more, consider MIT\u2019s 18.330: Introduction to Numerical Analysis. This course also uses Julia for programming assignments but is more challenging and in-depth. It covers floating-point encoding, root finding, linear systems, differential equations, and more, with the main goal of using discrete computer representations to estimate and approximate continuous mathematical concepts. The course instructor has also written an accompanying open-source textbook, Fundamentals of Numerical Computation, which includes abundant Julia code examples and rigorous formula derivations.
If you\u2019re still not satisfied, MIT\u2019s graduate course in numerical analysis, 18.335: Introduction to Numerical Methods, is also available for reference.
Wouldn't it be cool if the motion and development of everything in the world could be described and depicted with equations? Although differential equations are not a mandatory part of any CS curriculum, I believe mastering them provides a new perspective to view the world.
Since differential equations often involve complex variable functions, you can refer to MIT18.04: Complex Variables Functions course notes to fill in prerequisite knowledge.
MIT18.03: Differential Equations mainly covers the solution of ordinary differential equations, and on this basis, MIT18.152: Partial Differential Equations dives into the modeling and solving of partial differential equations. With the powerful tool of differential equations, you will gain enhanced capabilities in modeling real-world problems and intuitively grasping the essence among various noisy variables.
As a computer science student, I often hear arguments about the uselessness of mathematics. While I neither agree nor have the authority to oppose such views, if everything is forcibly categorized as useful or useless, it indeed becomes quite dull. Therefore, the following advanced mathematics courses, aimed at senior and even graduate students, are available for those interested.
Languages are tools, and you choose the right tool for the right job. Since there's no universally perfect tool, there's no universally perfect language.
"},{"location":"en/CS%E5%AD%A6%E4%B9%A0%E8%A7%84%E5%88%92/#electronics-fundamentals","title":"Electronics Fundamentals","text":""},{"location":"en/CS%E5%AD%A6%E4%B9%A0%E8%A7%84%E5%88%92/#basics-of-circuits","title":"Basics of Circuits","text":"
For computer science students, understanding basic circuit knowledge and experiencing the entire pipeline from sensor data collection to data analysis and algorithm prediction can be very helpful for future learning and developing computational thinking. EE16A&B: Designing Information Devices and Systems I&II at UC Berkeley are introductory courses for freshmen in electrical engineering. EE16A focuses on collecting and analyzing data from the real environment through circuits, while EE16B focuses on analyzing these collected data to make predictive actions.
"},{"location":"en/CS%E5%AD%A6%E4%B9%A0%E8%A7%84%E5%88%92/#signals-and-systems","title":"Signals and Systems","text":"
Signals and Systems is a course I find very worthwhile. Initially, I studied it out of curiosity about Fourier Transform, but after completing it, I was amazed at how Fourier Transform provided a new perspective to view the world, just like differential equations, immersing you in the elegance and magic of precisely depicting the world with mathematics.
MIT 6.003: Signal and Systems provides all course recordings, written assignments, and answers. You can also check out this course's ancient version.
UCB EE120: Signal and Systems has very well-written notes on Fourier Transform and provides many interesting Python programming assignments to practically apply the theories and algorithms of signals and systems.
"},{"location":"en/CS%E5%AD%A6%E4%B9%A0%E8%A7%84%E5%88%92/#data-structures-and-algorithms","title":"Data Structures and Algorithms","text":"
Algorithms are the core of computer science and the foundation for almost all professional courses. How to abstract real-world problems into algorithmic problems mathematically and solve them under time and memory constraints using appropriate data structures is the eternal theme of algorithm courses. If you are fed up with your teacher's rote teaching, I highly recommend UC Berkeley's UCB CS61B: Data Structures and Algorithms and Princeton's Coursera: Algorithms I & II. Both courses are taught in a deep yet simple manner and have rich and interesting programming experiments to integrate theory with knowledge.
Both of these courses are based on Java. If you prefer C/C++, you can refer to Stanford's data structure and basic algorithm course Stanford CS106B/X: Programming Abstractions. For those who prefer Python, you can learn MIT's introductory algorithm course MIT 6.006: Introduction to Algorithms.
For those interested in more advanced algorithms and NP problems, consider UC Berkeley's course on algorithm design and analysis UCB CS170: Efficient Algorithms and Intractable Problems or MIT's advanced algorithms course MIT 6.046: Design and Analysis of Algorithms.
There is a fundamental difference between \u201cworking\u201d code and high-quality industrial code. Therefore, I highly recommend senior students to take MIT 6.031: Software Construction. Based on Java, this course teaches how to write high-quality code that is bug-resistant, clear, and easy to maintain and modify with rich and detailed reading materials and well-designed programming exercises. From macro data structure design to minor details like how to write comments, following these details and experiences summarized by predecessors can greatly benefit your future programming career.
Of course, if you want to systematically take a software engineering course, I recommend UC Berkeley\u2019s UCB CS169: Software Engineering. However, unlike most software engineering courses, this course does not involve the traditional design and document model that emphasizes various class diagrams, flowcharts, and document design. Instead, it adopts the Agile Development model, which has become popular in recent years, featuring small team rapid iterations and the Software as a Service model using cloud platforms.
Since childhood, I've always heard that the world of computers is made of 0s and 1s, which I didn't understand but was deeply impressed by. If you also have this curiosity, consider spending one to two months learning the barrier-free computer course Coursera: Nand2Tetris. This comprehensive course starts from 0s and 1s, allowing you to build a computer by hand and run a Tetris game on it. It covers compilation, virtual machines, assembly, architecture, digital circuits, logic gates, etc., from top to bottom, from software to hardware. Its difficulty is carefully designed to omit many complex details of modern computers, extracting the most core essence, aiming to make it understandable to everyone. In lower levels, establishing a bird's-eye view of the entire computer system is very beneficial.
Of course, if you want to delve into the complex details of modern computer architecture, you still need to take a university-level course UCB CS61C: Great Ideas in Computer Architecture. This course emphasizes practice, and you will hand-write assembly to construct neural networks in projects, build a CPU from scratch, and more, all of which will give you a deeper understanding of computer architecture, beyond the monotony of \"fetch, decode, execute, memory access, write back.\"
"},{"location":"en/CS%E5%AD%A6%E4%B9%A0%E8%A7%84%E5%88%92/#introduction-to-computer-systems","title":"Introduction to Computer Systems","text":"
Computer systems are a vast and profound topic. Before delving into a specific area, having a macro conceptual understanding of each field and some general design principles will reinforce core and even philosophical concepts in your subsequent in-depth study, rather than being shackled by complex internal details and various tricks. In my opinion, the key to learning systems is to grasp these core concepts to design and implement your own systems.
MIT6.033: System Engineering is MIT's introductory course to systems, covering topics like operating systems, networks, distributed systems, and system security. In addition to the theory, this course also teaches some writing and expression skills, helping you learn how to design, introduce, and analyze your own systems. The accompanying textbook Principles of Computer System Design: An Introduction is also very well written and recommended for reading.
CMU 15-213: Introduction to Computer System is CMU\u2019s introductory systems course, covering architecture, operating systems, linking, parallelism, networks, etc., with both breadth and depth. The accompanying textbook Computer Systems: A Programmer's Perspective is also of very high quality and strongly recommended for reading.
There\u2019s nothing like writing your own kernel to deepen your understanding of operating systems.
Operating systems provide a set of elegant abstractions to virtualize various complex underlying hardware, providing rich functional support for all application software. Understanding the design principles and internal mechanisms of operating systems is greatly beneficial for a programmer who is not satisfied with just being a coder. Out of love for operating systems, I have taken many operating system courses in different colleges, each with its own focus and merits. You can choose based on your interests.
MIT 6.S081: Operating System Engineering, offered by the famous PDOS lab at MIT, features 11 projects that modify an elegantly implemented Unix-like operating system xv6. This course made me realize that systems is not about reading PPTs; it's about writing tens of thousands of lines of code.
UCB CS162: Operating System, UC Berkeley\u2019s operating system course, uses the same Project as Stanford \u2014 an educational operating system, Pintos. As the teaching assistant for Peking University\u2019s 2022 and 2023 Spring Semester Operating Systems Course, I introduced and improved this Project. The course resources are fully open-sourced, with details on the course website.
NJU: Operating System Design and Implementation, offered by Professor Yanyan Jiang at Nanjing University, provides an in-depth and accessible explanation of various operating system concepts, combining a unique system perspective with rich code examples. All course content is in Chinese, making it very convenient for students.
HIT OS: Operating System, taught by Professor Zhijun Li at Harbin Institute of Technology, is a Chinese course on operating systems. Based on the Linux 0.11 source code, the course places great emphasis on code practice, explaining the intricacies of operating systems from the student's perspective.
"},{"location":"en/CS%E5%AD%A6%E4%B9%A0%E8%A7%84%E5%88%92/#parallel-and-distributed-systems","title":"Parallel and Distributed Systems","text":"
In recent years, the most common phrase heard in CS lectures is \"Moore's Law is coming to an end.\" As single-core capabilities reach their limits, multi-core and many-core architectures are becoming increasingly important. The changes in hardware necessitate adaptations and changes in the upper-level programming logic. Writing parallel programs has nearly become a mandatory skill for programmers to fully utilize hardware performance. Meanwhile, the rise of deep learning has brought unprecedented demands on computing power and storage, making the deployment and optimization of large-scale clusters a hot topic.
Whether you chose computer science because of a youthful dream of becoming a hacker, the reality is that becoming a hacker is a long and difficult journey.
UCB CS161: Computer Security at UC Berkeley covers stack attacks, cryptography, website security, network security, and more.
ASU CSE365: Introduction to Cybersecurity at Arizona State University focuses mainly on injections, assembly, and cryptography.
ASU CSE466: Computer Systems Security at Arizona State University covers a wide range of topics in system security. It has a high barrier to entry, requiring familiarity with Linux, C, and Python.
SU SEED Labs at Syracuse University, supported by a $1.3 million grant from the NSF, has developed hands-on experimental exercises (called SEED Labs) for cybersecurity education. The course emphasizes both theoretical teaching and practical exercises, including detailed open-source lectures, video tutorials, textbooks (printed in multiple languages), and a ready-to-use virtual machine and Docker-based attack-defense environment. This project is currently used by 1,050 institutions worldwide and covers a wide range of topics in computer and information security, including software security, network security, web security, operating system security, and mobile app security.
After mastering this theoretical knowledge, it's essential to cultivate and hone these \"hacker skills\" in practice. CTF competitions are a popular way to comprehensively test your understanding and application of computer knowledge in various fields. Peking University also successfully held the 0th and 1st editions, encouraging participation to improve skills through practice. Here are some resources I use for learning (and relaxing):
There\u2019s nothing like writing your own TCP/IP protocol stack to deepen your understanding of computer networks.
The renowned Stanford CS144: Computer Network includes 8 projects that guide you in implementing the entire TCP/IP protocol stack.
If you're just looking to understand computer networks theoretically, I recommend the famous networking textbook \"A Top-Down Approach\" and its accompanying learning resources Computer Networking: A Top-Down Approach.
There\u2019s nothing like building your own relational database to deepen your understanding of database systems.
CMU's famous database course CMU 15-445: Introduction to Database System guides you through 4 projects to add various functionalities to the educational relational database bustub. The experimental evaluation framework is also open-source, making it very suitable for self-learning. The course experiments also use many new features of C++11, offering a great opportunity to strengthen C++ coding skills.
Berkeley, as the birthplace of the famous open-source database PostgreSQL, has its own course UCB CS186: Introduction to Database System where you will implement a relational database in Java that supports SQL concurrent queries, B+ tree indexing, and fault recovery.
Front-end development is often overlooked in computer science curricula, but mastering these skills has many benefits, such as building your personal website or creating an impressive presentation website for your course projects.
Data science, machine learning, and deep learning are closely related, with a focus on practical application. Berkeley's UCB Data100: Principles and Techniques of Data Science lets you master various data analysis tools and algorithms through extensive programming exercises. The course guides you through extracting desired results from massive datasets and making predictions about future data or user behavior. For those looking to learn industrial-level data mining and analysis techniques, Stanford's big data mining course CS246: Mining Massive Data Sets is an option.
Artificial intelligence has been one of the hottest fields in computer science over the past decade. If you're not content with just hearing about AI advancements in the media and want to delve into the subject, I highly recommend Harvard's renowned CS50 series AI course Harvard CS50: Introduction to AI with Python. The course is concise and covers several major branches of traditional AI, supplemented with rich and interesting Python programming exercises to reinforce your understanding of AI algorithms. However, the content is somewhat simplified for online learners and doesn't delve into deep mathematical theories. For a more systematic and in-depth study, consider an undergraduate-level course like Berkeley's UCB CS188: Introduction to Artificial Intelligence. This course's projects feature the classic game \"Pac-Man,\" allowing you to use AI algorithms to play the game, which is very fun.
The most significant recent progress in the field of machine learning is the emergence of deep learning, a branch based on deep neural networks. However, many algorithms based on statistical learning are still widely used in data analysis. If you're new to machine learning and don't want to get bogged down in complex mathematical proofs, start with Andrew Ng's (Enda Wu) Coursera: Machine Learning. This course is well-known in the field of machine learning, and Enda Wu, with his profound theoretical knowledge and excellent presentation skills, makes many complex algorithms accessible and practical. The accompanying assignments are also of high quality, helping you get started quickly.
However, completing this course will only give you a general understanding of the field of machine learning. To truly understand the mathematical principles behind these \"magical\" algorithms or to engage in related research, you need a more \"mathematical\" course, such as Stanford CS229: Machine Learning or UCB CS189: Introduction to Machine Learning.
The popularity of AlphaGo a few years ago brought deep learning to the public eye, leading many universities to establish related majors. Many other areas of computer science also use deep learning technology for research, so regardless of your field, you will likely encounter some needs related to neural networks and deep learning. For a quick introduction, I again recommend Andrew Ng's (Enda Wu) Coursera: Deep Learning, a top-rated course on Coursera. Additionally, if you find English-language courses challenging, consider Professor Hongyi Li's course National Taiwan University: Machine Learning. Although titled \"Machine Learning,\" this course covers almost all areas of deep learning and is very comprehensive, making it suitable for getting a broad overview of the field. The professor is also very humorous, with frequent witty remarks in class.
Due to the rapid development of deep learning, there are now many research branches. For further in-depth study, consider the following representative courses:
"},{"location":"en/CS%E5%AD%A6%E4%B9%A0%E8%A7%84%E5%88%92/#customize-your-course-map","title":"Customize Your Course Map","text":"
Better to teach fishing than to give fish.
The course map above inevitably carries strong personal preferences and may not suit everyone. It is more intended to serve as a starting point for exploration. If you want to select your own areas of interest for study, you can refer to the following resources:
MIT OpenCourseWare: MIT's open-sharing project for course resources, featuring thousands of courses from various disciplines, including computer science courses numbered 6.xxx.
MIT CS Course List: List of CS courses at MIT.
UC Berkeley EECS Course Map: UC Berkeley's EECS curriculum plan, presenting the categories and prerequisites of various courses in a course map format, most of which are included in this book.
UC Berkeley CS Course List: List of CS courses at UC Berkeley.
Stanford CS Course List: List of CS courses at Stanford.
"},{"location":"en/%E4%BD%BF%E7%94%A8%E6%8C%87%E5%8D%97/","title":"How to Use This Book","text":"
As the number of contributors grows, the content of this book keeps expanding. It is impractical and unnecessary to try to complete all the courses in the book. Attempting to do so might even be counterproductive, resulting in effort without reward. To better align with our readers and make this book truly useful for you, I have roughly divided readers into the following three categories based on their needs. Everyone can plan their own self-study program accurately according to their actual situation.
If you have just entered the university or are in the lower grades, and you are studying or planning to switch to computer science, then you are lucky. As studying is your main task, you have ample time and freedom to learn what you are interested in without the pressure of work and daily life. You needn't be overly concerned with utilitarian thoughts like \"is it useful\" or \"can it help me find a job\". So, how should you arrange your studies? The first point is to break away from the passive learning style formed in high school. As a small-town problem solver, I know that most Chinese high schools fill every minute of your day with tasks, and you just need to passively follow the schedule. As long as you are diligent, the results won\u2019t be too bad. However, once you enter university, you have much more freedom. All your extracurricular time is yours to use, and no one will organize knowledge points or summarize outlines for you. Exams are not as formulaic as in high school. If you still hold the mentality of a \"good high school student\", following everything step by step, the results may not be as expected. The professional training plan may not be reasonable, the teaching may not be responsible, attending classes may not guarantee understanding, and even the exam content may not relate to what was taught. Jokingly, you might feel that the whole world is against you, and you can only rely on yourself.
Given this reality, if you want to change it, you must first survive and have the ability to question it. In the lower grades, it\u2019s important to lay a solid foundation. This foundation is comprehensive, covering both in-class knowledge and practical skills, which are often lacking in China's undergraduate computer science education. Based on personal experience, I offer the following suggestions for your reference.
First, learn how to write \"elegant\" code. Many programming introductory courses in China can be extremely boring syntax classes, less effective than reading official documentation. Initially, letting students understand what makes code elegant and what constitutes \"bad taste\" is beneficial. Introductory courses usually start with procedural programming (like C language), but even here, the concepts of modularity and encapsulation are crucial. If you write code just to pass on OpenJudge, using lengthy copy-pasting and bloated main functions, your code quality will remain poor. For larger projects, endless debugging and maintenance costs will overwhelm you. So, constantly ask yourself, is there a lot of repetitive code? Is the current function too complex (Linux advocates each function should do only one thing)? Can this code be abstracted into a function? Initially, this may seem cumbersome for simple problems, but remember, good habits are invaluable. Even middle school students can master C language, so why should a company hire you as a software engineer?
After procedural programming, the second semester of the freshman year usually introduces object-oriented programming (like C++ or Java). I highly recommend MIT 6.031: Software Construction course notes, which use Java (switch to TypeScript after 2022) to explain how to write \u201celegant\u201d code in detail, including Test-Driven development, function Specification design, exception handling, and more. Also, understanding common design patterns is necessary when learning object-oriented programming. Domestic object-oriented courses can easily become dull syntax classes, focusing on inheritance syntax and puzzling questions, neglecting that these are rarely used in real-world development. The essence of object-oriented programming is teaching students to abstract real problems into classes and their relationships, and design patterns are the essence of these abstractions. I recommend the book \"Big Talk Design Patterns\", which is very easy to understand.
Second, try to learn some productivity-enhancing tools and skills, such as Git, Shell, Vim. I strongly recommend the MIT missing semester course. Initially, you may feel awkward, but force yourself to use them, and your development efficiency will skyrocket. Additionally, many applications can greatly increase your productivity. A rule of thumb is: any action that requires your hands to leave the keyboard should be eliminated. For example, switching applications, opening files, browsing the web - there are plugins for these (like Alfred for Mac). If you find an daily operation that takes more than 1 second, try to reduce it to 0.1 seconds. After all, you'll be dealing with computers for decades, so forming a smooth workflow can greatly enhance efficiency. Lastly, learn to touch type! If you still need to look at the keyboard while typing, find a tutorial online and learn to type without looking. This will significantly increase your development efficiency.
Third, balance coursework and self-learning. We feel angry about the institution but must also follow the rules, as GPA is still important for postgraduate recommendations. Therefore, in the first year, I suggest focusing on the curriculum, complemented by high-quality extracurricular resources. For example, for calculus and linear algebra, refer to MIT 18.01/18.02 and MIT 18.06. During holidays, learn Python through UCB CS61A. Also, focus on good programming habits and practical skills mentioned above. From my experience, mathematics courses matter a lot for your GPA in the first year, and the content of math exams varies greatly between different schools and teachers. Self-learning might help you understand the essence of mathematics, but it may not guarantee good grades. Therefore, it\u2019s better to specifically practice past exams.
In your sophomore year, as computer science courses become the majority, you can fully immerse yourself in self-learning. Refer to A Reference Guide for CS Learning, a guide I created based on three years of self-learning, introducing each course and its importance. For every course in your curriculum, this guide should have a corresponding one, and I believe they are of higher quality. If there are course projects, try to adapt labs or projects from these self-learning courses. For example, I took an operating systems course and found the teacher was still using experiments long abandoned by UC Berkeley, so I emailed the teacher to switch to the MIT 6.S081 xv6 Project I was studying. This allowed me to self-learn while inadvertently promoting curriculum reform. In short, be flexible. Your goal is to master knowledge in the most convenient and efficient way. Anything that contradicts this goal can be \u201cfudged\u201d as necessary. With this attitude, after my junior year, I barely attended offline classes (I spent most of my sophomore year at home due to the pandemic), and it had no impact on my GPA.
Finally, I hope everyone can be less impetuous and more patient in their pursuit. Many ask if self-learning requires strong self-discipline. It depends on what you want. If you still hold the illusion that mastering a programming language will earn you a high salary and a share of the internet\u2019s profits, then whatever I say is pointless. Initially, my motivation was out of pure curiosity and a natural desire for knowledge, not for utilitarian reasons. The process didn't involve \u201cextraordinary efforts\u201d; I spent my days in college as usual and gradually accumulated this wealth of materials. Now, as the US-China confrontation becomes a trend, we still humbly learn techniques from the West. Who will change this? You, the newcomers. So, go for it, young man!
"},{"location":"en/%E4%BD%BF%E7%94%A8%E6%8C%87%E5%8D%97/#simplify-the-complex","title":"Simplify the Complex","text":"
If you have graduated and started postgraduate studies, or have begun working, or are in another field and want to learn coding in your spare time, you may not have enough time to systematically complete the materials in A Reference Guide for CS Learning, but still want to fill the gaps in your undergraduate foundation. Considering that these readers usually has some programming experience, there is no need to repeat introductory courses. From a practical standpoint, since the general direction of work is already determined, there is no need to deeply study every branch of computer science. Instead, focus on general principles and skills. Based on my own experience, I've selected the most important and highest quality core professional courses to deepen readers' understanding of computer science. After completing these courses, regardless of your specific job, I believe you won't just be an ordinary coder, but will have a deeper understanding of the underlying logic of computers.
Course Direction Course Name Discrete Mathematics and Probability Theory UCB CS70: Discrete Math and Probability Theory Data Structures and Algorithms Coursera: Algorithms I & II Software Engineering MIT 6.031: Software Construction Full-Stack Development MIT Web Development Course Introduction to Computer Systems CMU CS15213: CSAPP Introductory System Architecture Coursera: Nand2Tetris Advanced System Architecture CS61C: Great Ideas in Computer Architecture Principles of Databases CMU 15-445: Introduction to Database Systems Computer Networking Computer Networking: A Top-Down Approach Artificial Intelligence Harvard CS50: Introduction to AI with Python Deep Learning Coursera: Deep Learning"},{"location":"en/%E4%BD%BF%E7%94%A8%E6%8C%87%E5%8D%97/#focused-and-specialized","title":"Focused and Specialized","text":"
If you have a solid grasp of the core professional courses in computer science and have already determined your work or research direction, then there are many courses in the book not mentioned in A Reference Guide for CS Learning for you to explore.
As the number of contributors increases, new branches such as Advanced Machine Learning and Machine Learning Systems will be added to the navigation bar. Under each branch, there are several similar courses from different schools with different emphases and experiments, such as the Operating Systems branch, which includes courses from MIT, UC Berkeley, Nanjing University, and Harbin Institute of Technology. If you want to delve into a field, studying these similar courses will give you different perspectives on similar knowledge. Additionally, I plan to contact researchers in related fields to share research learning paths in specific subfields, enhancing the depth of the CS Self-learning Guide while pursuing breadth.
If you want to contribute in this area, feel free to contact the author via email zhongyinmin@pku.edu.cn.
This is Stanford's Web Application course covers HTML, CSS, JavaScript, ReactJs, NodeJS, ExpressJS, Web Security, and more. Eight projects will enhance your web development skills in practice.
This course provides a comprehensive but concise introduction to the best practices of React front-end development and React Native mobile development. It focuses on the latest versions of React and React Native and is updated every semester. It is a valuable resource for tackling the complexities of front-end development.
The course also offers a good training ground. Be prepared for a significant workload throughout the semester. The techniques and knowledge points involved in the homework will be explained in class, but code won't be written hand by hand (I personally think that hand-holding code writing is very inefficient, and most courses on Udemy are of this type). As this isn't a hand-holding course, if you are unsure about how to write React code when doing homework, I recommend spending extra time carefully reading the relevant chapters on react.dev before diving in. The starter code also provides you with a great starting point, saving you from coping with Node.js environment settings.
Although this course doesn't require prior knowledge of Javascript/HTML/CSS, the classroom introduction to syntax is relatively limited. It's recommended to frequently consult resources and ask questions when encountering syntax issues during learning and coding.
This course also includes an introduction to and practices for Dialog Flow, a ChatBot development tool by Google. You can also find content related to UX development (on the practical side) in this course.
All course materials and assignments are open-source, but you will need to request an X-CS571-ID header from the instructor, Cole Nelson (ctnelson2@wisc.edu). The header will be necessary for API request. When sending an email, it is advisable to include a brief self-introduction. It is unclear whether the instructor is willing to give everyone an ID. If you got turned down, please raise an issue for this GitHub repo.
This course serves as an introduction to modern web application development with JavaScript. The main focus is on building single page applications with ReactJS that use REST APIs built with Node.js. The course also contains a section on GraphQL, a modern alternative to REST APIs.
The course covers testing, configuration and environment management, and the use of MongoDB for storing the application\u2019s data.
Prerequisites: better if you are already proficient in a programming language
Programming Languages: JavaScript/HTML/CSS/NoSQL
Difficulty: \ud83c\udf1f\ud83c\udf1f\ud83c\udf1f
Class Hour: Varying according to the learner
Independent Activities Period (IAP) is a four-week period in January during which faculty and students are freed from the rigors of regularly scheduled classes for flexible teaching and learning and for independent study and research, and that's how this web development course was born.
Within a month, you will master the core content of designing, building, beautifying, and publishing a website from scratch, basically covering full-stack web development. If you don't need to learn web development systematically, but just want to add it to your toolkit out of interest, then this class will be perfect for you.
This introductory artificial intelligence course at UC Berkeley provides in-depth and accessible course notes, making it possible to grasp the material without necessarily watching the lecture videos. The course follows the chapters of the classic AI textbook Artificial Intelligence: A Modern Approach, covering topics such as search pruning, constraint satisfaction problems, Markov decision processes, reinforcement learning, Bayesian networks, Hidden Markov Models, as well as fundamental concepts in machine learning and neural networks.
The Fall 2018 version of the course offered free access to gradescope, allowing students to complete written assignments online and receive real-time assessment results. The course also includes 6 projects of high quality, featuring the recreation of the classic Pac-Man game. These projects challenge students to apply their AI knowledge to implement various algorithms, enabling their Pac-Man to navigate mazes, evade ghosts, and collect pellets.
Course Videos\uff1aFall 2022, Fall 2018, with links to each lecture on the course website
Course Textbook\uff1aArtificial intelligence: A Modern Approach
Course Assignments\uff1aOnline assessments for written assignments and projects, details available on the course website
"},{"location":"en/%E4%BA%BA%E5%B7%A5%E6%99%BA%E8%83%BD/CS50/","title":"Harvard's CS50: Introduction to AI with Python","text":""},{"location":"en/%E4%BA%BA%E5%B7%A5%E6%99%BA%E8%83%BD/CS50/#descriptions","title":"Descriptions","text":"
Offered by: Harvard University
Prerequisites: Basic knowledge of probability theory and Python
Programming Languages: Python
Difficulty: \ud83c\udf1f\ud83c\udf1f\ud83c\udf1f
Class Hour: 30
A very basic introductory AI course, what makes it stand out is the 12 well-designed programming assignments, all of which will use the learned knowledge to implement a simple game AI, such as using reinforcement learning to play Nim game, using max-min search with alpha-beta pruning to sweep mines, and so on. It's perfect for newbies to get started or bigwigs to relax.
This course, taught by Professor Onur Mutlu, delves into computer architecture. It appears to be an advanced course following DDCA, aimed at teaching how to design control and data paths hardware for a MIPS-like processor, how to execute machine instructions concurrently through pipelining and simple superscalar execution, and how to design fast memory and storage systems. According to student feedback, the course is at least more challenging than CS61C, and some of its content is cutting-edge. Bilibili uploaders recommend it as a supplement to Carnegie Mellon University's 18-447 course. The reading materials provided are extensive, akin to attending a semester's worth of lectures.
The official website description is as follows:
\"We will learn the fundamental concepts of the different parts of modern computing systems, as well as the latest major research topics in Industry and Academia. We will extensively cover memory systems (including DRAM and new Non-Volatile Memory technologies, memory controllers, flash memory), new paradigms like processing-in-memory, parallel computing systems (including multicore processors, coherence and consistency, GPUs), heterogeneous computing, interconnection networks, specialized systems for major data-intensive workloads (e.g., graph analytics, bioinformatics, machine learning), etc. We will focus on fundamentals as well as cutting-edge research. Significant attention will be given to real-life examples and tradeoffs, as well as critical analysis of modern computing systems.\"
The programming practice involves using Verilog to design and simulate RT implementations of a MIPS-like pipeline processor to enhance theoretical course understanding. The initial experiments include Verilog CPU pipeline programming. Additionally, students will develop a cycle-accurate processor simulator in C and explore processor design options using this simulator.
This is the last course in Berkeley's CS61 series, which dives into the internal of computer architecture and will make you understand how the C language is translated into RISC-V assembly language and executed on the CPU. Unlike Nand2Tetris, this course is much more difficult and more in-depth, covering pipelining, cache, virtual memory, and concurrency-related content.
The projects are very innovative and interesting. Project1 is a warmup assignment in C. In 2020Fall, you will implement the famous Game of Life. Project2 requires you to write a fully-connected neural network in RISC-V assembly to classify handwritten digits in MNIST dataset, which is a great exercise to write assembly code. In Project3, you will use Logisim, a digital circuit simulation software, to build a two-stage pipeline CPU from scratch and run RISC-V assembly code on it. In Project4 you will implement a toy version of Numpy, using OpenMP, SIMD, and other techniques to speed up matrix operations.
In a word, this is the best computer architecture course I have ever taken.
All the resources and assignments used by @PKUFlyingPig in this course are maintained in PKUFlyingPig/CS61C-summer20 - GitHub.
"},{"location":"en/%E4%BD%93%E7%B3%BB%E7%BB%93%E6%9E%84/DDCA/","title":"Digital Design and Computer Architecture","text":""},{"location":"en/%E4%BD%93%E7%B3%BB%E7%BB%93%E6%9E%84/DDCA/#descriptions","title":"Descriptions","text":"
Offered by: ETH Zurich
Prerequisites: CS50 or same level course; Better have a basic knowledge of C
Programming Languages: C, Verilog, MIPS, LC3
Difficulty: \ud83c\udf1f\ud83c\udf1f\ud83c\udf1f
Class Hour: 100 hours
In this course, Onur Mutlu, a great expert in the field of Computer Architecture, will teach you about digital circuits and computer architecture. The course is entirely from the perspective of a computer designer, starting with transistors and logic gates and extending to microarchitecture, caches, and virtual memory. It also covers many of the latest research advances in the field of computer architecture. After learning, you will master digital circuits, hardware description language Verilog, MIPS instruction set, CPU design and performance analysis, pipelining, cache, virtual memory, and so on.
There are 9 labs in the course. You will use the Basys 3 FPGA board and Vivado to design and synthesize the circuits, starting from combinational and sequential circuits, and eventually assembly into a complete CPU. Except for assignment solutions, all the course materials are open source.
As one of the most popular courses on Coursera, tens of thousands of people give it a full score, and over four hundred colleges and high schools teach it. It guides the students who may have no preparatory knowledge in computer science to build a whole computer from Nand logic gates and finally run the Tetris game on it.
Sounds cool, right? It's even cooler when you implement it!
The course is divided into hardware modules and software modules respectively.
In the hardware modules, you will dive into a world based on 0 and 1, create various logic gates from Nand gates, and construct a CPU step by step to run a simplified instruction set designed by the course instructors.
In the software modules, you will first write a compiler to compile a high-level language Jack which is designed by the instructors into byte codes that can run on virtual machines. Then you will further translate the byte codes into assembly language that can run on the CPU you create in the hardware modules. You will also develop a simple operating system that enables your computer to support GUI.
Finally, you can use Jack to create the Tetris game, compile it into assembly language, run it on your self-made CPU, and interact with it through the OS built by yourself. After taking this course, you will have a comprehensive and profound understanding of the entire computer architecture, which might be extremely helpful to your subsequent learning.
You may think that the course is too difficult. Don't worry, because it is completely designed for laymen. In the instructors' expectations, even high school students can understand the content. So as long as you keep pace with the syllabus, you can finish it within a month.
This course extracts the essence of computers while omitting the tedious and complex details in modern computer systems that are designed for efficiency and performance. Surely you will enjoy the elegance and magic of computers in a relaxing and jolly journey.
The professor Kayvon Fatahalian used to teach course 15-418 at CMU. After he became an assistant professor at Stanford, he offered a similar course, CS149 at Stanford. In general, the 15-418 version is more comprehensive and has lecture recordings, but CS149's programming assignments are more fashionable. Personally, I watched the recordings of 15-418 but completed the assignments of CS149.
The goal of this course is to provide a deep understanding of the fundamental principles and engineering trade-offs involved in designing modern parallel computing systems, as well as to teach how to utilize hardwares and software programming frameworks (such as CUDA, MPI, OpenMP, etc.) for writing high-performance parallel programs. Due to the complexity of parallel computing architecture, this course involves a lot of advanced computer architecture and network communication content, the knowledge is quite low-level and hardcore. Meanwhile, the five assignments develop your understanding and application of upper-level abstraction through software, specifically by analyzing bottlenecks in parallel programs, writing multi-threaded synchronization code, learning CUDA programming, OpenMP programming, and the popular Spark framework, etc. It really combines theory and practice perfectly.
This course, the same as MIT 6.S081, comes from the renowned MIT PDOS Lab. The instructor, Professor Robert Morris, was once a famous hacker who created 'Morris', the first worm virus in the world.
Each lecture will discuss a classic paper in the field of distributed systems, teaching you the important principles and key techniques of distributed systems design and implementation. The Project is known for its difficulty. In four programming assignments, you will implement a KV-store framework step by step based on the Raft consensus algorithm, allowing you to experience the randomness and complexity to implement and debug a distributed system.
This course is so famous that you can easily have access to the project solutions on the Internet. It is highly recommended to implement the projects on your own.
All the resources and assignments used by @PKUFlyingPig in this course are maintained in PKUFlyingPig/MIT6.824 - GitHub.
@OneSizeFitsQuorum has written a Lab Documentation that quite clearly describes many of the details to be considered when implementing lab 1-4 and challenge 1-2, you can read when you encounter bottlenecks ~ ~
Similar to GNU make, CMake is a cross-platform tool designed to build, test and package software. It uses CMakeLists.txt to define build configuration, and have more functionalities compared to GNU make. It is highly recommended to learn GNU Make and get familiar with Makefile first before learning CMake.
"},{"location":"en/%E5%BF%85%E5%AD%A6%E5%B7%A5%E5%85%B7/CMake/#how-to-learn-cmake","title":"How to learn CMake","text":"
Compare to Makefile, CMakeLists.txt is more obscure and difficult to understand and use. Nowadays many IDEs (e.g., Visual Studio, CLion) offer functionalities to generate CMakeLists.txt automatically, but it's still necessary to manage basic usage of CMakeLists.txt. Besides Official CMake Tutorial, this one-hour video tutorial (in Chinese) presented by IPADS group at SJTU is also a good learning resource.
The main obstacle when using software/tools developed by others is often the hassle of setting up the environment. This configuration headache can significantly dampen your enthusiasm for software and programming. While virtual machines can solve some of these issues, they are cumbersome and might not be worth simulating an entire operating system for a single application's configuration.
Docker has changed the game by making environment configuration (potentially) less painful. In essence, Docker uses lightweight \"containers\" instead of an entire operating system to support an application's configuration. Applications, along with their environment configurations, are packaged into images that can freely run on different platforms in containers, saving considerable time and effort for everyone.
"},{"location":"en/%E5%BF%85%E5%AD%A6%E5%B7%A5%E5%85%B7/Docker/#how-to-learn-docker","title":"How to learn Docker","text":"
The official Docker documentation is the best starting point, but the best teacher is often yourself\u2014try using Docker to experience its convenience. Docker has rapidly developed in the industry and is already quite mature. You can download its desktop version and use the graphical interface.
If you're like me, reinventing the wheel, consider building a Mini Docker yourself to deepen your understanding.
KodeKloud Docker for the Absolute Beginner offers a comprehensive introduction to Docker's basic functionalities with numerous hands-on exercises. It also provides a free cloud environment for practice. While other cloud-related courses, such as Kubernetes, may require payment, I highly recommend them. The explanations are detailed, suitable for beginners, and come with a corresponding Kubernetes lab environment, eliminating the need for complex setups.
Emacs is a powerful editor as famous as Vim. Emacs has almost all the benefits of Vim, such as:
Everything can be done with keyboard only, as there are a large number of shortcuts to improve the efficiency of code editing.
Supporting both graphical and non-graphical interface in various scenarios.
Besides, the biggest difference between Emacs and most other editors lies in its powerful extensibility. Emacs kernel imposes no restrictions on users behaviors. With Emacs Lisp programming language, users is able to write any plugins to extend the functionality. After decades of development, Emacs' plugin ecosystem is arguably one of the richest and most powerful in the editor world. There is a joke saying that \"Emacs is an OS that lacks a decent text editor\". Futhermore, you can also write your own Emacs extensions with only a small amount of effort.
Emacs is friendly to Vim users as there is an extension called evil that migrate Vim operations into Emacs. Users can switch from Vim to Emacs with minimum effort. Statistics show that a considerable number of users would switch from Vim to Emacs, but there were almost no users who would switch from Emacs to Vim. In fact, the only weaknesss of Emacs is that it is not as efficient as Vim in pure text editing because of Vim's multi-modal editing. However, with Emacs' powerful extensibility, it can make up for its weaknesses by combining the strengths of both.
"},{"location":"en/%E5%BF%85%E5%AD%A6%E5%B7%A5%E5%85%B7/Emacs/#how-to-learn-emacs","title":"How to learn Emacs","text":"
Same as Vim, Emacs also has a steep learning curve. But once you understand the basic underlying logic, you will never live without it.
There are plenty of tutorials for Emacs. Since Emacs is highly customizable, every user has their own learning path. Here are some good starting points:
This tutorial is a brief guide to the basic logic of Emacs.
Awesome Emacs lists a large number of useful Emacs packages, utilities, and libraries.
One of the most shortcomings of Emacs is the excessive use of the Ctrl key, which is a burden on your left little finger. It is highly recommended to change the keyboard mapping of the Ctrl key. Please refer to Vim for details to remapping.
"},{"location":"en/%E5%BF%85%E5%AD%A6%E5%B7%A5%E5%85%B7/GNU_Make/#why-gnu-make","title":"Why GNU Make","text":"
Everyone remembers their first \"hello world\" program. After editing helloworld.c, you needed to use gcc to compile and generate an executable file, and then execute it. (If you're not familiar with this, please Google gcc compilation and understand the related content first.) However, what if your project consists of hundreds of C source files scattered across various subdirectories? How do you compile and link them together? Imagine if your project takes half an hour to compile (quite common for large projects), and you only changed a semicolon\u2014would you want to wait another half an hour?
This is where GNU Make comes to the rescue. It allows you to define the entire compilation process and the dependencies between target files and source files in a script (known as a Makefile). It only recompiles the parts affected by your changes, significantly reducing compilation time.
"},{"location":"en/%E5%BF%85%E5%AD%A6%E5%B7%A5%E5%85%B7/GNU_Make/#how-to-learn-gnu-make","title":"How to learn GNU Make","text":"
Here is a well-written [document] (https://seisman.github.io/how-to-write-makefile/overview.html) for in-depth and accessible understanding.
Mastering GNU Make is relatively easy, but using it effectively requires continuous practice. Integrate it into your daily development routine, be diligent in learning, and mimic the Makefile styles from other excellent open-source projects. Develop your own template that suits your needs, and over time, you will become more proficient in using GNU Make.
Git is a distributed version control system. The father of Linux, Linus Torvalds developed Git to maintain the version control of Linux, replacing the centralized version control tools which were difficult and costly to use.
The design of Git is very elegant, but beginners usually find it very difficult to use without understanding its internal logic. It is very easy to mess up the version history if misusing the commands.
Git is a powerful tool and when you finally master it, you will find all the effort paid off.
"},{"location":"en/%E5%BF%85%E5%AD%A6%E5%B7%A5%E5%85%B7/Git/#how-to-learn-git","title":"How to learn Git","text":"
Different from Vim, I don't suggest beginners use Git rashly without fully understanding it, because its inner logic can not be acquainted by practicing. Here is my recommended learning path:
Read this Git tutorial in English, or you can watch this Git tutorial (by \u5c1a\u7845\u8c37) in Chinese.
Read Chap1 - Chap5 of this open source book Pro Git. Yes, to learn Git, you need to read a book.
Now that you have understood its principles and most of its usages, it's time to consolidate those commands by practicing. How to use Git properly is a kind of philosophy. I recommend reading this blog How to Write a Git Commit Message.
You are now in love with Git and are not content with only using it, you want to build a Git by yourself! Great, that's exactly what I was thinking. This tutorial will satisfy you!
What? Building your own Git is not enough? Seems that you are also passionate about reinventing the wheels. These two GitHub projects, build-your-own-x and project-based-learning, collected many wheel-reinventing tutorials, e.g., text editor, virtual machine, docker, TCP and so on.
"},{"location":"en/%E5%BF%85%E5%AD%A6%E5%B7%A5%E5%85%B7/GitHub/#what-is-github","title":"What is GitHub","text":"
Functionally, GitHub is an online platform for hosting code. You can host your local Git repositories on GitHub for collaborative development and maintained by a group. However, GitHub's significance has evolved far beyond that. It has become a very active and resource-rich open-source community. Developers from all over the world share a wide variety of open-source software on GitHub. From industrial-grade deep learning frameworks like PyTorch and TensorFlow to practical scripts consisting of just a few lines of code, GitHub offers hardcore knowledge sharing, beginner-friendly tutorials, and even many technical books are open-sourced here (like the one you're reading now). Browsing GitHub has become a part of my daily life.
On GitHub, stars are the ultimate affirmation for a project. If you find this book useful, you are welcome to enter the repository's homepage via the link in the upper right corner and give your precious star\u2728.
"},{"location":"en/%E5%BF%85%E5%AD%A6%E5%B7%A5%E5%85%B7/GitHub/#how-to-use-github","title":"How to Use GitHub","text":"
If you have never created your own remote repository on GitHub or cloned someone else's code, I suggest you start your open-source journey with GitHub's official tutorial.
If you want to keep up with some interesting open-source projects on GitHub, I highly recommend the HelloGitHub website. It regularly features GitHub's recently trending or very interesting open-source projects, giving you the opportunity to access various quality resources firsthand.
I believe GitHub's success is due to the \"one for all, all for one\" spirit of open source and the joy of sharing knowledge. If you also want to become the next revered open-source giant or the author of a project with tens of thousands of stars, then transform your ideas that spark during development into code and showcase them on GitHub.
However, it's important to note that the open-source community is not lawless. Many open-source softwares are not meant for arbitrary copying, distribution, or even sale. Understanding various open-source licenses and complying with them is not only a legal requirement but also the responsibility of every member of the open-source community.
If you need to write academic papers, please skip directly to the next section, as learning LaTeX is not just a choice but a necessity.
LaTeX is a typesetting system based on TeX, developed by Turing Award winner Lamport, while TeX was originally developed by Knuth, both of whom are giants in the field of computer science. Of course, the developers' prowess is not the reason we learn LaTeX. The biggest difference between LaTeX and the commonly used WYSIWYG (What You See Is What You Get) Word documents is that in LaTeX, users only need to focus on the content of the writing, leaving the typesetting entirely to the software. This allows people without any typesetting experience to produce papers or articles with highly professional formatting.
Berkeley computer science professor Christos Papadimitriou once jokingly said:
Every time I read a LaTeX document, I think, wow, this must be correct!
"},{"location":"en/%E5%BF%85%E5%AD%A6%E5%B7%A5%E5%85%B7/Latex/#how-to-learn-latex","title":"How to Learn LaTeX","text":"
The recommended learning path is as follows:
Setting up the LaTeX environment can be a headache. If you encounter problems with configuring LaTeX locally, consider using Overleaf, an online LaTeX editor. The site not only offers a variety of LaTeX templates to choose from but also eliminates the difficulty of environment setup.
Read the following three tutorials: Part-1, Part-2, Part-3.
The best way to learn LaTeX is, of course, by writing papers. However, starting with a math class and using LaTeX for homework is also a good choice.
Other recommended introductory materials include:
A brief guide to installing LaTeX [GitHub] or the TEX Live Guide (texlive-zh-cn) [PDF] can help you with installation and environment setup.
A (not so) brief introduction to LaTeX2\u03b5 (lshort-zh-cn) [PDF] [GitHub], translated by the CTEX development team, helps you get started quickly and accurately. It's recommended to read it thoroughly.
Liu Haiyang's \"Introduction to LaTeX\" can be used as a reference book, to be consulted when you have specific questions. Skip the section on CTEX suite.
Modern LaTeX Introduction Seminar
A Very Short LaTeX Introduction Document
"},{"location":"en/%E5%BF%85%E5%AD%A6%E5%B7%A5%E5%85%B7/Scoop/#why-use-scoop","title":"Why Use Scoop","text":"
Setting up a development environment in Windows has always been a complex and challenging task. The lack of a unified standard means that the installation methods for different development environments vary greatly, resulting in unnecessary time costs. Scoop helps you uniformly install and manage common development software, eliminating the need for manual downloads, installations, and environment variable configurations.
For example, to install Python and Node.js, you just need to execute:
Scoop requires Windows PowerShell 5.1 or PowerShell as its runtime environment. If you are using Windows 10 or later, Windows PowerShell is built into the system. However, the version of Windows PowerShell built into Windows 7 is outdated, and you will need to manually install a newer version of PowerShell.
Many students have encountered issues due to setting up Windows user accounts with Chinese usernames, leading to user directories also being named in Chinese. Installing software via Scoop into user directories in such cases may cause some software to execute incorrectly. Therefore, it is recommended to install in a custom directory. For other installation methods, please refer to: ScoopInstaller/Install
# Set PowerShell execution policy\nSet-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser\n# Download the installation script\nirm get.scoop.sh -outfile 'install.ps1'\n# Run the installation, use --ScoopDir parameter to specify Scoop installation path\n.\\install.ps1 -ScoopDir 'C:\\Scoop'\n
Scoop's official documentation is very user-friendly for beginners. Instead of elaborating here, it is recommended to read the official documentation or the Quick Start guide.
The Scoop community only maintains installation configurations, and all software is downloaded from the official download links provided by the software's creators. Therefore, mirror sources are not provided. If your network environment causes repeated download failures, you may need a bit of magic.
"},{"location":"en/%E5%BF%85%E5%AD%A6%E5%B7%A5%E5%85%B7/Scoop/#why-cant-i-find-java-8","title":"Why Can't I Find Java 8?","text":"
For the same reasons mentioned above, the official download links for Java 8 are no longer provided. It is recommended to use ojdkbuild8 as a substitute.
"},{"location":"en/%E5%BF%85%E5%AD%A6%E5%B7%A5%E5%85%B7/Scoop/#how-do-i-install-python-2","title":"How Do I Install Python 2?","text":"
For software that is outdated and no longer in use, the Scoop community removes it from ScoopInstaller/Main and adds it to ScoopInstaller/Versions. If you need such software, you need to manually add the bucket:
In my opinion, the Vim editor has the following benefits:
It keeps your finger on the keyboard throughout the development and moving the cursor without the arrow keys keeps your fingers in the best position for typing.
Convenient file switching and panel controls allow you to edit multiple files simultaneously or even different locations of the same file.
Vim's macros can batch repeat operations (e.g. add tabs to multi-lines, etc.)
Vim is well-suited for Linux servers without GUI. When you connect to a remote server through ssh, you can only develop from the command line because there is no GUI (of course, many IDEs such as PyCharm now provide ssh plugins to solve this problem).
A rich ecology of plugins gives you the world's most fancy command-line editor.
"},{"location":"en/%E5%BF%85%E5%AD%A6%E5%B7%A5%E5%85%B7/Vim/#how-to-learn-vim","title":"How to learn Vim","text":"
Unfortunately Vim does have a pretty steep learning curve and it took me a few weeks to get used to developing with Vim. You'll feel very uncomfortable at first, but once you get past the initial stages, trust me, you'll fall in love with Vim.
There is a vast amount of learning material available on Vim, but the best way to master it is to use it in your daily development, no need to learn all the fancy advanced Vim tricks right away. The recommended learning path is as follows:
Read This tutorial first to understand the basic Vim concepts and usage.
Use Vim's own vimtutor to practice. After installing Vim, type vimtutor directly into the command line to enter the practice program.
Then you can force yourself to use Vim for development, and you can install Vim plugins in your favorite IDE.
Once you're fully comfortable with Vim, a new world opens up to you, and you can configure your own Vim on demand (by modifying the .vimrc file), and there are countless resources on the Internet to learn from.
If you want to know more about how to customize Vim to suit your needs, Learn Vim Script the Hard Way is a perfect start point.
Ctrl and Esc keys are probably two of the most used keys in Vim. However, these two keys are pretty far away from home row. In order to make it easier to reach these keys, you can remap CapsLock to Esc or Ctrl.
On Windows, Powertoys or AutoHotkey can be used to achieve this goal. On macOS, you can remap keys in system settings, see this page. Karabiner-Elements also works.
A better solution is to make CapsLock function as Esc and Ctrl simultaneously. Click CapsLock to send Esc, hold CapsLock to use it as Ctrl key. Here's how to do it on different systems:
Neil,\u00a0Drew.\u00a0Practical Vim: Edit Text at the Speed of Thought.\u00a0N.p.,\u00a0Pragmatic Bookshelf,\u00a02015.
Neil,\u00a0Drew.\u00a0Modern Vim: Craft Your Development Environment with Vim 8 and Neovim.\u00a0United States,\u00a0Pragmatic Bookshelf.
"},{"location":"en/%E5%BF%85%E5%AD%A6%E5%B7%A5%E5%85%B7/thesis/","title":"Thesis Writing","text":""},{"location":"en/%E5%BF%85%E5%AD%A6%E5%B7%A5%E5%85%B7/thesis/#why-i-wrote-this-tutorial","title":"Why I Wrote This Tutorial","text":"
In 2022, I graduated from my college. When I started writing my thesis, I embarrassingly realized that my command of Word was limited to basic functions like adjusting fonts and saving documents. I considered switching to LaTeX, but formatting requirements for the thesis were more conveniently handled in Word. After a painful struggle, I finally completed the writing and defense of my thesis. To prevent others from following in my footsteps, I compiled relevant resources into a ready-to-use document for everyone's reference.
"},{"location":"en/%E5%BF%85%E5%AD%A6%E5%B7%A5%E5%85%B7/thesis/#how-to-write-a-graduation-thesis-in-word","title":"How to Write a Graduation Thesis in Word","text":"
Just as it takes three steps to put an elephant in a fridge, writing a graduation thesis in Word also requires three simple steps:
Determine the Format Requirements of the Thesis: Usually, colleges will provide the formatting requirements for theses (font and size for headings, sections, formatting of figures and citations, etc.), and if you're lucky, they might even provide a thesis template (if so, jump to the next step). Unfortunately, my college did not issue standard format requirements and provided a chaotic and almost useless template. Out of desperation, I found the thesis format requirements of Peking University graduate students and created a template based on their guidelines. Feel free to use it, but I take no responsibility for any issues for using it.
Learn Word Formatting: At this stage, you either have a standard template provided by your college or just a vague set of formatting requirements. Now, the priority is to learn basic Word formatting skills. If you have a template, learn to use it; if not, learn to create one. Remember, there's no need to ambitiously start with a lengthy Word tutorial video. A half-hour tutorial is enough to get started for creating a passable academic paper. I watched a concise and practical Bilibili tutorial video, which is very useful for a quick start.
Produce Academic Work: The easiest step. Everyone has their own way, so unleash your creativity. Best wishes for a smooth graduation!
excalidraw: A hand-drawn style drawing tool, great for creating diagrams in course reports or PPTs.
tldraw: A drawing tool suitable for flowcharts, architecture diagrams, etc.
draw.io: A powerful and concise online drawing website, supports flowcharts, UML diagrams, architecture diagrams, prototypes, etc., with export options for Onedrive, Google Drive, Github, and offline client availability.
origamiway: Step-by-step origami tutorials.
thingiverse: Includes various 2D/3D design resources, with STL files ready for 3D printing.
iconfont: The largest icon and illustration library in China, useful for development or drawing system architecture diagrams.
turbosquid: A platform to purchase various models.
flaticon: A site to download free and high-quality icons.
Standard Map Service System: Official standard map downloads.
GitHub: Many open-source projects' hosting platform, also a major communication platform for many open-source projects, where issues can solve many problems.
StackExchange: A programming community composed of 181 Q&A communities (including Stack Overflow).
StackOverflow: An IT technical Q&A site related to programming.
Gitee: A code hosting platform similar to GitHub, where you can find solutions to common questions in the issues of corresponding projects.
Zhihu: A Q&A community similar to Quora, where you can ask questions, with some answers containing computer knowledge.
Cnblogs: A knowledge-sharing community for developers, containing blogs on common questions. Accuracy is not guaranteed, please use with caution.
CSDN: Contains blogs on common questions. Accuracy is not guaranteed, please use with caution.
The field of computer science is vast and rapidly evolving, making lifelong learning crucial. However, our sources of knowledge in daily development and learning are complex and fragmented. We encounter extensive documentation manuals, brief blogs, and even snippets of news and public accounts on our phones that may contain interesting knowledge. Therefore, it's vital to use various tools to create a learning workflow that suits you, integrating these knowledge fragments into your personal knowledge base for easy reference and review. After two years of learning alongside work, I have developed the following learning workflow:
Initially, when learning new knowledge, I referred to Chinese blogs but often found bugs and gaps in my code practice. Gradually, I realized that the information I referred to might be incorrect, as the threshold for posting blogs is low and their credibility is not high. So, I started consulting some related Chinese books.
Chinese books indeed provide a comprehensive and systematic explanation of concepts. However, given the rapid evolution of computer technology and the US's leadership in CS, content in Chinese books often lags behind the latest knowledge. This led me to realize the importance of firsthand information. Some Chinese books are translations of English ones, and translation can take a year or two, causing a delay in information transmission and loss during translation. If a Chinese book is not a translation, it likely references other books, introducing biases in interpreting the original English text.
Therefore, I naturally started reading English books. The quality of English books is generally higher than that of Chinese ones. As I delved deeper into my studies, I discovered a hierarchy of information reliability: source code > official documentation > English books > English blogs > Chinese blogs. This led me to create an \"Information Loss Chart\":
Although firsthand information is crucial, subsequent iterations (N-th hand information) are not useless. They include the author's transformation of the source knowledge \u2014 such as logical organization (flow charts, mind maps) or personal interpretations (abstractions, analogies, extensions to other knowledge points). These transformations can help us quickly grasp and consolidate core knowledge, like using guidebooks in school. Moreover, interacting with others' interpretations during learning is important, allowing us to benefit from various perspectives. Hence, it's advisable to first choose high-quality, less distorted sources of information while also considering multiple sources for a more comprehensive and accurate understanding.
In real-life work and study, learning rarely follows a linear, deep dive into a single topic. Often, it involves other knowledge points, such as new jargon, classic papers not yet read, or unfamiliar code snippets. This requires us to think deeply and \"recursively\" learn, establishing connections between multiple knowledge points.
"},{"location":"en/%E5%BF%85%E5%AD%A6%E5%B7%A5%E5%85%B7/workflow/#choosing-the-right-note-taking-software","title":"Choosing the Right Note-taking Software","text":"
The backbone of the workflow is built around the core logic of \"multiple references for a single knowledge point and building connections among various points.\" This is similar to writing academic papers. Papers usually have footnotes explaining keywords and multiple references at the end. But our daily notes are much more casual, hence the need for a more flexible method.
I'm accustomed to jumping to related functions and implementations in an IDE. It would be great if notes could also be interlinked like code. Current \"double-link note-taking software,\" such as Roam Research, Logseq, Notion, and Obsidian, addresses this need. I chose Obsidian for the following reasons:
Obsidian is based locally, with fast opening speeds, and can store many e-books. My laptop, an Asus TUF Gaming FX505 with 32GB of RAM, runs Obsidian very smoothly.
Obsidian is Markdown-based. This is an advantage because if a note-taking software uses a proprietary format, it's inconvenient for third-party extensions and opening notes with other software.
Obsidian has a rich and active plugin ecosystem, allowing for an \"all in one\" effect, meaning various knowledge sources can be integrated in one place.
Obsidian's plugins support PDF formats, and it naturally supports Markdown. To achieve \"all in one,\" you can convert other file formats to PDF or Markdown. This presents two questions:
File formats depend on their display platforms. Before considering formats, let's list the sources of information I usually access:

The main categories are articles, papers, e-books, and courses, primarily including formats like web pages, PDFs, MOBI, AZW, and AZW3.
"},{"location":"en/%E5%BF%85%E5%AD%A6%E5%B7%A5%E5%85%B7/workflow/#conversion-to-pdf-or-markdown","title":"Conversion to PDF or Markdown","text":"
Online articles and courses are mostly presented as web pages. To convert web pages to Markdown, I use the clipping software \"Simplified Read,\" which can clip articles from nearly all platforms into Markdown and import them into Obsidian.
For papers and e-books, if the format is already PDF, it's straightforward. Otherwise, I use Calibre for conversion:
Now, using Obsidian's PDF plugin and native Markdown support, I can seamlessly take notes and reference across these documents (see \"Information Processing\" below for details).
"},{"location":"en/%E5%BF%85%E5%AD%A6%E5%B7%A5%E5%85%B7/workflow/#managing-information-sources","title":"Managing Information Sources","text":"
For file resources like PDFs, I use local or cloud storage. For web resources, I categorize and save them in browser bookmarks or clip them into Markdown notes. However, browsers don't support mobile web bookmarking. To enable cross-platform web bookmarking, I use Cubox. With a swipe on my phone, I can save interesting web pages in one place. Although the free version limits to 100 bookmarks, it's usually sufficient and prompts me to process these pages promptly.
Moreover, many of the web pages we bookmark are not from fully-featured blog platforms like Zhihu or Juejin but personal sites without mobile apps. These can be easily overlooked in browser bookmarks, and we might miss new article notifications. Here, RSS comes into play.
RSS (Rich Site Summary) is a type of web feed that allows users to access updates to online content in a standardized format. On desktops, RSSHub Radar helps discover and generate RSS feeds, which can be subscribed to using Feedly (both have official Chrome browser plugins).
With this, the information collection process is comprehensive. But no matter how well categorized, information needs to be internalized to be useful. After collecting information, the next step is processing it \u2014 reading, understanding the semantics (especially for English sources), highlighting key sentences or paragraphs, noting queries, brainstorming related knowledge points, and writing summaries. What tools are needed for this process?
For English materials, I initially used \"Youdao Dictionary\" for word translation, Google Translate for sentences, and \"Deepl\" for paragraphs. Eventually, I realized this was too slow and inefficient. Ideally, a single tool that can handle word, sentence, and paragraph translation would be optimal. After researching, I chose \"Quicker\" + \"Saladict\" for translation.
This combo allows translation outside browsers and supports words, sentences, and paragraphs, offering results from multiple translation platforms. For non-urgent word lookups, the \"Collins Advanced\" dictionary is helpful as it explains English words in English, providing context to aid understanding.
After processing text-based information, it's important to consider how to handle multimedia information. Specifically, I'm referring to English videos, as I don't have a habit of learning through podcasts or recordings and I rarely watch Chinese tutorials anymore. Many renowned universities offer open courses in video format. Wouldn't it be helpful if you could take notes on these videos? Have you ever thought it would be great if you could convert the content of a lecture into text, since we usually read faster than a lecturer speaks? Fortunately, the software Language Reactor can export subtitles from YouTube and Netflix videos, along with Chinese translations.
We can copy the subtitles exported by Language Reactor into Obsidian and read them as articles. Besides learning purposes, you can also use this plugin while watching YouTube videos. It displays subtitles in both English and Chinese, and you can click on unfamiliar words in the subtitles to see their definitions.
However, reading texts isn't always the most efficient way to learn about some abstract concepts. As the saying goes, \"A picture is worth a thousand words.\" What if we could link a segment of text to corresponding images or even video operations? While browsing the Obsidian plugin marketplace, I discovered a plugin called Media Extended. This plugin allows you to add links in your notes that jump to specific times in a video, effectively connecting your notes to the video! This works well with the video subtitles mentioned earlier, where each line of subtitles corresponds to a time stamp, allowing for jumps to specific parts of the video. This means you don't have to cut specific video segments; instead, you can jump directly within the article!
Obsidian also has a powerful plugin called Annotator, which allows you to jump from notes to the corresponding section in a PDF.
Now, with Obsidian's built-in double-chain feature, we can achieve inter-note linking, and with the above plugins, we can extend these links to multimedia. This completes the process of information handling. Learning often involves both a challenging ascent and a familiar descent. So, how can we incorporate the review process into this workflow?
Obsidian already has a plugin that connects to Anki, the renowned spaced repetition-based memory software. With this plugin, you can export segments of your notes to Anki as flashcards, each containing a link back to the original note.
This workflow evolved over two years of learning in my spare time. Frustration with repetitive processes led to specific needs, which were fortunately met by tools I discovered online. Don't force tools into your workflow just for the sake of satisfaction; life is short, so focus on what's truly important.
By the way, this article discusses the evolution of the workflow. If you're interested in the details of how this workflow is implemented, I recommend reading the following articles in order after this one:
3000+ Hours Accumulated Learning Workflow
Advanced Techniques in Obsidian | Creating Notes that Link to Any File Format
When encountering a problem, remember the first thing is to read the documentation. Don't start by searching online or asking others directly. Reviewing FAQs may quickly provide the answer.
Information retrieval, as I understand it, is essentially about skillfully using search engines to quickly find the information you need, including but not limited to programming.
The most important thing in programming is STFW (search the fucking web) and RTFM (read the fucking manual). First, you should read the documentation, and second, learn to search. With so many resources online, how you use them depends on your information retrieval skills.
To understand how to search effectively, we first need to understand how search engines work.
The working process of a search engine can generally be divided into three stages: 1
Crawling and Fetching: Search engine spiders visit web pages by tracking links, obtain the HTML code of the pages, and store it in a database.
Preprocessing: The indexing program processes the fetched web page data by extracting text, segmenting Chinese words, indexing, etc., preparing for the ranking program.
Ranking: When users enter keywords, the ranking program uses the indexed data to calculate relevance and then generates the search results page in a specific format.
The first step involves web crawlers, often exaggerated in Python courses. It can be simply understood as using an automated program to download all text, images, and related information from websites and store them locally.
The second step is the core of a search engine, but not critical for users to understand. It can be roughly understood as cleaning data and indexing pages, each with keywords for easy querying.
The third step is closely related to us. Whether it's Google, Baidu, Bing, or others, you input keywords or queries, and the search engine returns results. This article teaches you how to obtain better results.
Based on the above working principles, we can roughly understand that a search engine can be treated as a smart database. Using better query conditions can help you find the information you need faster. Here are some search techniques:
Don't search whole sentences. Although search engines automatically segment words, searching with whole sentences versus keywords can yield significantly different results in accuracy and order. Search engines are machines, not your teachers or colleagues. As mentioned above, searching is actually querying a database crawled by the search engine, so it's better to break down into keywords or phrases.
For example, if you want to know how to integrate vcpkg into a project instead of globally, searching for \"\u5982\u4f55\u5c06vcpkg\u96c6\u6210\u5230\u9879\u76ee\u4e2d\u800c\u4e0d\u662f\u5168\u5c40\" in a long sentence may not yield relevant results. It's better to break it down into keywords like \"vcpkg \u96c6\u6210 \u9879\u76ee \u5168\u5c40\".
If you can't find what you're looking for, try replacing \"\u9879\u76ee\" with \"\u5de5\u7a0b\" or remove \"\u96c6\u6210\". If that doesn't work, try advanced searching.
Use GitHub's Advanced Search page or refer to GitHub Query Syntax for advanced searches on GitHub. Examples include searching by repository name, description, readme, stars, fork count, size, update/creation date, license, language, user, and organization. These can be
Many programmers advise against using Baidu, preferring Google or Bing International. However, if you really need it, consider using alternatives like Ecosia or Yandex. For Chinese searches, Baidu might actually be the best option due to its database and indexing policies.
Firstly, the textbook: Operating Systems: Principles and Practice (2nd Edition) is written in an insightful but easy-to-understand way, well compensated for the lack of theoretical knowledge in MIT6.S081, I highly recommend you to read this book.
Secondly, the project for this course Pintos is a great journey for system hackers. Pintos is a toy operating system developed at Stanford for educational use. The author Ben Pfaff even published a paper to explain the design principles of Pintos.
Unlike the small but comprehensive design philosophy in MIT's xv6 labs, Pintos emphasizes system design and implementation more. The codebase is about 10,000 LOC and only provides the basic functions of a working operating system. The four projects let you add scheduler (Project1), system calls (Project2), virtual memory (Project3), and the file system (Project4) to this extremely simple operating system. All projects leave a a big design space for students and require more than 2000 LOC. Based on the feedback from Stanford students, the latter two projects take over 40 hours per person even in teams of 3-4 people.
Although it is tough, Stanford, Berkeley, JHU and many other top U.S. colleges have chosen Pintos as their OS course project. If you're really interested in operating systems, it will greatly improve your ability to write and debug low-level system code. For me, it is an invaluable experience to design, implement, and debug a large system independently.
Pintos will also be introduced as a course project in Peking University's OS Course. In the Spring 2022 semester, I worked with another TA to write a comprehensive lab documentation and provided a docker image for the ease of cross-platform development. In the last semester before graduation, I hope such an attempt can make more people fall in love with systems and contribute to the field of systems in China.
If you search on Zhihu for questions like \"how to self-study operating systems\", \"recommended open courses for operating systems\", \"computer courses you wish you had discovered earlier\", etc., the operating systems course by Professor Li Zhijun of Harbin Institute of Technology (HIT) is likely to appear in the high-rated answers. It's a relatively well-known and popular Chinese computer course.
This course excels at gently guiding students from their perspective. For instance, it starts from \"humbly asking, what is an operating system\" to \"lifting the lid of the operating system piano\", deriving the concept of processes from intuitive CPU management, and introducing memory management by initially \"letting the program enter memory\".
The course emphasizes the combination of theory and practice. Operating systems are tangible, and Professor Li repeatedly stresses the importance of doing experiments. You won't fully grasp operating systems if you just watch videos and theorize. The course explains and conducts experiments based on actual Linux 0.11 source code (around 20,000 lines in total), with eight small labs and four projects.
Of course, this course also has minor imperfections. For example, Linux 0.11 is very early industrial code and not designed for teaching. Thus, there are some unavoidable obscure and difficult parts of the codebase in the projects, but they don't contribute much to the understanding of operating systems.
This is the undergraduate operating system course at MIT, offered by the well-known PDOS Group. One of the instructors, Robert Morris, was once a famous hacker who created 'Morris', the first worm virus in the world.
The predecessor of this course was the famous MIT6.828. The same instructors at MIT created an educational operating system called JOS based on x86, which has been adopted by many other famous universities. While after the birth of RISC-V, they implemented it based on RISC-V, and offered MIT 6.S081. RISC-V is lightweight and user-friendly, so students don't have to struggle with the confusing legacy features in x86 as in JOS, but focus on the operating system design and implementation.
The instructors have also written a tutorial, elaborately explaining the ideas of design and details of the implementation of xv6 operating system.
The teaching style of this course is also interesting, the instructors guided the students to understand the numerous technical challenges and design principles in the operating systems by going through the xv6 source code, instead of merely teaching theoretical knowledge. Weekly Labs will let you add new features to xv6, which focus on enhancing students' practical skills. There are 11 labs in total during the whole semester which give you the chance to understand every aspect of the operating systems, bringing a great sense of achievement. Each lab has a complete framework for testing, some tests are more than a thousand lines of code, which shows how much effort the instructors have made to teach this course well.
In the second half of the course, the instructors will discuss a couple of classic papers in the operating system field, covering file systems, system security, networking, virtualization, and so on, giving you a chance to have a taste of the cutting edge research directions in the academic field.
All resources used and assignments implemented by @PKUFlyingPig when learning this course are in PKUFlyingPig/MIT6.S081-2020fall - GitHub.
@KuangjuX documented his solutions with detailed explanations and complementary knowledge. Moreover, @KuangjuX has reimplemented the xv6 operating system in Rust which contains more detailed reviews and discussions about xv6.
"},{"location":"en/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F/MIT6.S081/#some-blogs-for-references","title":"Some Blogs for References","text":"
I had always heard that the operating system course taught by Professor Yanyan Jiang at Nanjing University was excellent. This semester, I had the opportunity to watch his lectures on Bilibili and gained a lot. As a young professor with rich coding experience, his teaching is full of a hacker's spirit. Often in class, he would start coding in the command line on a whim, and many important points were illustrated with vivid and straightforward code examples. What struck me most was when he implemented a mini executable file and a series of binary tools to help students better understand the design philosophy of dynamic link libraries, solving many problems that had puzzled me for years.
In the course, Prof. Jiang starts from the perspective that \"programs are state machines\" to establish an explainable model for the \"root of all evil\" concurrent programs. Based on this, he discusses common methods of concurrency control and strategies for dealing with concurrency bugs. Then, he views the operating system as a series of objects (processes/threads, address spaces, files, devices, etc.) and their APIs (system calls), combined with rich practical examples to show how operating systems use these objects to virtualize hardware resources and provide various services to application software. In the final part about persistence, he builds up various storage devices from 1-bit storage media and abstracts a set of interfaces through device drivers to facilitate the design and implementation of file systems. Although I have taken many operating system courses before, this unique approach has given me many unique perspectives on system software.
In addition to its innovative theoretical instruction, the course's emphasis on practice is a key feature of Prof. Jiang's teaching. In class and through programming assignments, he subtly cultivates the ability to read source code and consult manuals, which are essential skills for computer professionals. During the fifth MiniLab, I read Microsoft's FAT file system manual in detail for the first time, gaining a very valuable experience.
The programming assignments consist of 5 MiniLabs and 4 OSLabs. Unfortunately, the grading system is only open to students at Nanjing University. However, Professor Jiang generously allowed me to participate after I emailed him. I completed the 5 MiniLabs, and the overall experience was excellent. Particularly, the second coroutine experiment left a deep impression on me, where I experienced the beauty and \"terror\" of context switching in a small experiment of less than a hundred lines. Also, the MiniLabs can be easily tested locally, so the lack of a grading system should not hinder self-learning. Therefore, I hope others will not collectively \"harass\" the professor for access.
Finally, I want to thank Professor Jiang again for designing and offering such an excellent operating system course, the first independently developed computer course from a domestic university included in this book. It's thanks to young, new-generation teachers like Professor Jiang, who teach with passion despite the heavy Tenure track evaluation, that many students have an unforgettable undergraduate experience. I also look forward to more such high-quality courses in China, which I will include in this book for the benefit of more people.
Gilbert Strang, a great mathematician at MIT, still insists on teaching in his eighties. His classic text book Introduction to Linear Algebra has been adopted as an official textbook by Tsinghua University. After reading the PDF version, I felt deeply guilty and spent more than 200 yuan to purchase a genuine version in English as collection. The cover of this book is attached below. If you can fully understand the mathematical meaning of the cover picture, then your understanding of linear algebra will definitely reach a new height.
In addition to the course materials, the famous Youtuber 3Blue1Brown's video series The Essence of Linear Algebra are also great learning resources.
Textbook: Introduction to Linear Algebra, Gilbert Strang
Assignments: refer to the course website
On May 15th, 2023, revered mathematics professor Gilbert Strang capped his 61-year career as a faculty member at MIT by delivering his final 18.06 Linear Algebra lecture before retiring at the age of 88. In addition to a brief review for the course final exam, the overflowing audience (both in person and on the live YouTube stream) heard recollections, appreciations, and congratulations from Prof. Strang\u2019s colleagues and former students. A rousing standing ovation concluded this historic event.
The calculus course at MIT consists of MIT18.01: Single Variable Calculus and MIT18.02: Multivariable Calculus. If you are confident in your math, you can just read the course notes, which are written in a very simple and vivid way, so that you will not be tired of doing homework but can really see the essence of calculus.
In addition to the course materials, the famous Youtuber 3Blue1Brown's video series The Essence of Calculus are also great learning resources.
This is MIT's introductory information theory course for freshmen, Professor Penfield has written a special textbook for this course as course notes, which is in-depth and interesting.
This is MIT\u2018s discrete mathematics and probability course taught by the notable Tom Leighton (co-founder of Akamai). It is very useful for learning algorithms subsequently.
This is Berkeley's advanced probability course, which involves relatively advanced theoretical content such as statistics and stochastic processes, so a solid mathematical foundation is required. But as long as you stick with it you will certainly take your mastery of probability theory to a new level.
The course is designed by Professor Jean Walrand, who has written an accompanying textbook, Probability in Electrical Engineering and Computer Science, in which each chapter uses a specific algorithm as a practical example to demonstrate the application of theory in practice. Such as PageRank, Route Planing, Speech Recognition, etc. The book is open source and can be downloaded as a free PDF or Epub version.
Jean Walrand has also created accompanying Python implementations of the examples throughout the book, which are published online as Jupyter Notebook that readers can modify, debug and run them online interactively.
In addition to the Homework, nine Labs will allow you to use probability theory to solve practical problems in Python.
All the resources and assignments used by @PKUFlyingPig in this course are maintained in PKUFlyingPig/EECS126 - GitHub
"},{"location":"en/%E6%95%B0%E5%AD%A6%E8%BF%9B%E9%98%B6/CS70/","title":"UCB CS70: Discrete Math and Probability Theory","text":""},{"location":"en/%E6%95%B0%E5%AD%A6%E8%BF%9B%E9%98%B6/CS70/#descriptions","title":"Descriptions","text":"
Offered by: UC Berkeley
Prerequisites: None
Programming Languages: None
Difficulty: \ud83c\udf1f\ud83c\udf1f\ud83c\udf1f
Class Hour: 60 hours
This is Berkeley's introductory discrete mathematics course. The biggest highlight of this course is that it not only teaches you theoretical knowledge, but also introduce the applications of theoretical knowledge in practical algorithms in each module. In this way, students majoring in CS can understand the essence of theoretical knowledge and use it in practice rather than struggle with cold formal mathematical symbols.
Specific theory-algorithm correspondences are listed below.
Logic proof: stable matching algorithm
Graph theory: network topology design
Basic number theory: RSA algorithm
Polynomial ring: error-correcting code design
Probability theory: Hash table design, load balancing, etc.
The course notes are also written in a very in-depth manner, with derivations of formulas and practical examples, providing a good reading experience.
Prerequisites: Calculus, Linear Algebra, Probabilities and Statistics
Programming Languages: Anything would be OK, Python preferred
Difficulty: \ud83c\udf1f\ud83c\udf1f\ud83c\udf1f
Class Hour: 30-50 hours
This is a course on information theory taught by Sir David MacKay at the University of Cambridge. The professor is a very famous scholar in information theory and neural networks, and the textbook for the course is a classic work in the field of information theory. Unfortunately, those whom God loves die young ...
Professor Stephen Boyd is a great expert in the field of convex optimization and his textbook Convex Optimization has been adopted by many prestigious universities. His team has also developed a programming framework for solving common convex optimization problems in Python, Julia, and other popular programming languages, and its homework assignments also use this programming framework to solve real-life convex optimization problems.
In practice, you will deeply understand that for the same problem, a small change in the modeling process can make a world of difference in the difficulty of solving the equation. It is an art to make the equations you formulate \"convex\".
While the computational power of computers has been helping people to push boundaries of science, there is a natural barrier between the discrete nature of computers and this continuous world, and how to use discrete representations to estimate and approximate those mathematically continuous concepts is an important theme in numerical analysis.
This course will explore various numerical analysis methods in the areas of floating-point representation, equation solving, linear algebra, calculus, and differential equations, allowing you to understand (1) how to design estimation (2) how to estimate errors (3) how to implement algorithms in Julia. There are also plenty of programming assignments to practice these ideas.
The designers of this course have also written an open source textbook for this course (see the link below) with plenty of Julia examples.
As an introductory course to databases at CMU, this course is taught by Andy Pavlo, a leading figure in the database field (quoted as saying, \"There are only two things I care about in this world, one is my wife, the second is the database\").
This is a high-quality, resource-rich introductory course to Databases.
The faculty and the CMU Database Group behind the course have open-sourced all the corresponding infrastructure (Autograder, Discord) and course materials (Lectures, Notes, Homework), enabling any student who is willing to learn about databases to enjoy an experience almost equivalent to that of a CMU student.
One of the highlights of this course is the relational database Bustub, which was specifically developed by the CMU Database Group for teaching purposes. It requires you to modify various components of this database and implement their functionalities.
Specifically, in 15-445, you will need to implement some key components in Bustub, a traditional disk-oriented relational database, through the progression of four Projects.
These components include the Buffer Pool Manager (for memory management), B Plus Tree (storage engine), Query Executors & Query Optimizer (operators & optimizer), and Concurrency Control, corresponding to Project #1 through Project #4.
Worth mentioning is that, during the implementation process, students can compile bustub-shell through shell.cpp to observe in real-time whether their implemented components are correct. The feedback is very sufficient.
Furthermore, as a medium-sized project written in C++, bustub covers many requirements such as program construction, code standards, unit testing, etc., making it an excellent open-source project for learning.
Course Website: Fall 2019, Fall 2020, Fall 2021, Fall 2022, Spring 2023
Recording: The course website is freely accessible, and the Youtube Lectures for Fall 2022 are fully open-source.
Textbook: Database System Concepts
Assignments: Five Projects and Five Homework
In Fall 2019, Project #2 involved creating a hash index, and Project #4 focused on logging and recovery.
In Fall 2020, Project #2 was centered on B-trees, while Project #4 dealt with concurrency control.
In Fall 2021, Project #1 required the creation of a buffer pool manager, Project #2 involved a hash index, and Project #4 focused on concurrency control.
In Fall 2022, the curriculum was similar to that of Fall 2021, with the only change being that the hash index was replaced by a B+ tree index, and everything else remained the same.
In Spring 2023, the overall content was largely identical to Fall 2022 (buffer pool, B+ tree index, operators, concurrency control), except Project #0 shifted to Copy-On-Write Trie. Additionally, a fun task of registering uppercase and lowercase functions was introduced, which allows you to see the actual effects of the functions you write directly in the compiled bustub-shell, providing a great sense of achievement.
It's important to note that the versions of bustub prior to 2020 are no longer maintained.
The last Logging & Recovery Project in Fall 2019 is broken (it may still run on the git head from 2019, but Gradescope doesn't provide a public version, so it is not recommended to work on it, it is sufficient to just review the code and handout).
Perhaps in the Fall 2023 version, the recovery features will be fixed, and there may also be an entirely new Recovery Project. Let's wait and see \ud83e\udd2a.
If you have the energy, I highly recommend giving all of them a try, or if there's something in the book that you don't quite understand, attempting the corresponding project can deepen your understanding (I personally suggest completing all of them, as I believe it will definitely be beneficial).
The unofficial Discord is a great platform for discussion. The chat history practically documents the challenges that other students have encountered. You can also raise your own questions or help answer others', which I believe will be a great reference.
For a guidance to get through Spring 2023, you can refer to this article by @xzhseh on Zhihu (Note: Since the article is originally written in Chinese, you may need a translator to read it :) ). It covers all the tools you need to succeed, along with guides and, most importantly, pitfalls that I've encountered, seen, or stepped into during the process of doing the Project.
All the resources and assignments used by @ysj1173886760 in this course are maintained in ysj1173886760/Learning:db - GitHub.
Due to Andy's request, the repository does not contain the source code for the project, only the solution for homework. In particular, for Homework1, @ysj1173886760 wrote a shell script to help you evaluate your solution automatically.
After the course, it is recommended to read the paper Architecture Of a Database System. This paper provides an overview of the overall architecture of database systems so that you can have a more comprehensive view of the database.
CMU15-721 is a graduate-level course on advanced database system topics. It mainly focuses on the in-memory database, and each class has a corresponding paper to read. It is suitable for those who wish to do research in the field of databases. @ysj1173886760 is currently following up on this course and will create a pull request here after completing it to provide advanced guidance.
This course has only been offered twice so far, in Fall 2013 and Spring 2022, and it discusses some cutting-edge topics in the field of databases. The Fall 2013 session covered topics like Streaming, Graph DB, NVM, etc., while the Spring 2022 session mainly focused on Self-Driving DBMS, with relevant papers provided.
The tasks for the Spring 2022 version of the course included:
Task One: Manual performance tuning based on PostgreSQL.
Task Two: Improving the Self-Driving DBMS based on NoisePage Pilot, with no limitations on features.
The teaching style is more akin to a seminar, with fewer programming assignments. This course can broaden the horizons for general students and may be particularly beneficial for those specializing in databases.
Caltech's course, unlike CMU15-445 which does not offer SQL layer functionality, focuses on the implementation at the SQL layer in its CS122 course labs. It covers various modules of a query optimizer, such as SQL parsing, translation, implementation of joins, statistics and cost estimation, subquery implementation, and the implementation of aggregations and group by operations. Additionally, there are experiments related to B+ trees and Write-Ahead Logging (WAL). This course is suitable for students who have completed the CMU15-445 course and are interested in query optimization.
Below is an overview of the first three assignments or lab experiments of this course:
Perform plan cost calculation for various plan nodes.
Calculate the selectivity of various predicates that may appear in the execution plan.
Update the tuple statistics of the plan nodes' outputs based on predicates.
For the remaining Assignments and Challenges, please refer to the course description. It is recommended to use IDEA to open the project and Maven for building, keeping in mind the log-related configurations.
How to write SQL queries? How are SQL commands disassembled, optimized, and transformed into on-disk query commands step by step? How to implement a high-concurrency database? How to implement database failure recovery? What is NoSQL? This course elaborates on the internal details of relational databases. Besides the theoretical knowledge, you will use Java to implement a real relational database that supports SQL concurrent query, B+ tree index, and failure recovery.
From a practical point of view, you will have the opportunity to write SQL queries and NoSQL queries in course projects, which is very helpful for building full-stack projects.
RedBase, the project for CS346, involves the implementation of a simplified database system and is highly structured. The project can be divided into the following parts, which also correspond to the four labs that need to be completed:
The Record Management Component: This involves the implementation of record management functionalities.
The Index Component: Focuses on the management of B+ tree indexing.
The System Management Component: Deals with DDL statements, command-line tools, data loading commands, and metadata management.
The Query Language Component: In this part, students are required to implement the RQL Redbase Query Language, including select, insert, delete, and update statements.
Extension Component: Beyond the basic components of a database system, students must implement an extension component, which could be a Blob type, network module, join algorithms, CBO optimizer, OLAP, transactions, etc.
RedBase is an ideal follow-up project for students who have completed CMU 15-445 and wish to learn other components of a database system. Due to its manageable codebase, it allows for convenient expansion as needed. Furthermore, as it is entirely written in C++, it also serves as good practice for C++ programming skills.
This is Berkeley's introductory course in data science, covering the basics of data cleaning, feature extraction, data visualization, machine learning and inference, as well as common data science tools such as Pandas, Numpy, and Matplotlib. The course is also rich in interesting programming assignments, which is one of the highlights of the course.
Probably the most precious course from the EECS department of MIT. Taught by Erik Demaine, one of the geniuses in Algorithms.
Compared with CS106B/X (Data structures and algorithms using C++), 6.006 emphasizes the algorithms more. It also covers several classical data structures such as AVL trees. You may use it to learn more about algorithms after CS106B/X.
Part 2 of the MIT Algorithms Trilogy. Taught by Erik Demaine, Srini Devadas, and Nancy Lynch.
Compared with 6.006 where you just learn and use the algorithms directly, in 6.046 you will be required to learn a methodology to \"Design and analyze\" algorithms to solve certain problems. There are few programming exercises in this course, and most of the assignmnets are about proposing an algorithm and do some mathematical proofs. Therefore, it would be much harder than 6.006.
Part 3 of the MIT Algorithms Trilogy is 6.854 Advanced Algorithms. But for the most of the exercises you'll encounter in tests and job-hunting, 6.046 is definitely enough.
This is the highest rated algorithms course on Coursera, and Robert Sedgewick has the magic to make even the most complex algorithms incredibly easy to understand. To be honest, the KMP and network flow algorithms that I have been struggling with for years were made clear to me in this course, and I can even write derivations and proofs for both of them two years later.
Do you feel that you forget the algorithms quickly after learning them? I think the key to fully grasping an algorithm lies in understanding the three points as follows:
Why should do this? (Correctness derivation, or the essence of the entire algorithm.)
How to implement it? (Talk is cheap. Show me the code.)
How to use it to solve practical problems? (Bridge the gap between theory and real life.)
The composition of this course covers the three points above very well. Watching the course videos and reading the professor's textbook will help you understand the essence of the algorithm and allow you to tell others why the algorithm should look like this in very simple and vivid terms.
After understanding the algorithms, you can read the professor's code implementation of all the data structures and algorithms taught in the course. Note that these codes are not demos, but production-ready, time-efficient implementations. They have extensive annotations and comments, and the modularization is also quite good. I learned a lot by just reading the codes.
Finally, the most exciting part of the course is the 10 high-quality projects, all with real-world backgrounds, rich test cases, and an automated scoring system (code style is also a part of the scoring). You'll get a taste of algorithms in real life.
This is Berkeley's algorithm design and analysis course. It focuses on the theoretical foundations and complexity analysis of algorithms, covering Divide-and-Conquer, Graph Algorithms, Shortest Paths, Spanning Trees, Greedy Algorithms, Dynamic programming, Union Finds, Linear Programming, Network Flows, NP-Completeness, Randomized Algorithms, Hashing, etc.
The textbook for this course is well written and very suitable as a reference book. In addition, this class has written assignments and is recommended to use LaTeX. You can take this opportunity to practice your LaTeX skills.
It is the second course of UC Berkeley's CS61 series. It mainly focuses on the design of data structures and algorithms as well as giving students the opportunity to be exposed to thousands of lines of engineering code and gain a preliminary understanding of software engineering through Java.
I took the version for 2018 Spring. Josh Hug, the instructor, generously made the autograder open-source. You can use gradescope invitation code published on the website for free and easily test your implementation.
All programming assignments in this course are done in Java. Students without Java experience don't have to worry. There will be detailed tutorials in the course from the configuration of IDEA to the core syntax and features of Java.
The quality of homework in this class is also unparalleled. The 14 labs will allow you to implement most of the data structures mentioned in the class by yourself, and the 10 homework will allow you to use data structures and algorithms to solve practical problems. In addition, there are 3 projects that give you the opportunity to be exposed to thousands of lines of engineering code and enhance your Java skills in practice.
Assignments: Slightly different every year. In the spring semester of 2018, there are 14 Labs, 10 Homework and 3 Projects. Please refer to the course website for specific requirements.
I did not take this course but used its lecture notes as reference books. From the course website, I think it is better than CS299 because all the assignments and autograder are open source. Also, this course is quite theoretical and in-depth.
This is another ML course offered by Andrew Ng. Since it is graduate-level, it focuses more on the mathematical theory behind machine learning. If you are not satisfied with using off-the-shelf tools but want to understand the essence of the algorithm, or aspire to engage in theoretical research on machine learning, you can take this course. All the lecture notes are provided on the course website, written in a professional and theoretical way, requiring a solid mathematical background.
Prerequisites: entry level of AI and proficient in Python
Programming Languages: Python
Difficulty: \ud83c\udf1f\ud83c\udf1f\ud83c\udf1f
Class Hour: 100 hours
When it comes to Andrew Ng, no one in the AI community should be unaware of him. He is one of the founders of the famous online education platform Coursera, and also a famous professor at Stanford. This introductory machine learning course must be one of his famous works (the other is his deep learning course), and has hundreds of thousands of learners on Coursera (note that these are people who paid for the certificate, which costs several hundred dollars), and the number of nonpaying learners should be far more than that.
The class is extremely friendly to novices, and Andrew has the ability to make machine learning as straightforward as 1+1=2. You'll learn about linear regression, logistic regression, support vector machines, unsupervised learning, dimensionality reduction, anomaly detection, and recommender systems, etc. and solidify your understanding with hands-on programming. The quality of the assignments needs no word to say. With detailed code frameworks and practical background, you can use what you've learned to solve real problems.
Of course, as a public mooc, the difficulty of this course has been deliberately lowered, and many mathematical derivations are skimmed over. If you are interested in machine learning theory and want to investigate the mathematical theory behind these algorithms, you can refer to CS229 and CS189.
My implementation is lost in system reinstallation. However, the course is so famous that you can easily find related resources online. Also, course material is available on Coursera.
Intelligent computing systems serve as the backbone for global AI, producing billions of devices annually, including smartphones, servers, and wearables. Training professionals for these systems is critical for China's AI industry competitiveness. Understanding intelligent computing systems is vital for computer science students, shaping their core skills.
Prof. Yunji Chen's course, taught in various universities, uses experiments to provide a holistic view of the AI tech stack. Covering deep learning frameworks, coding in low-level languages, and hardware design, the course fosters a systematic approach.
Personally, completing experiments 2-5 enhanced my grasp of deep learning frameworks. The BCL language experiment in chapter five is reminiscent of CUDA for those familiar.
I recommend the textbook for a comprehensive tech stack understanding. Deep learning-savvy students can start from chapter five to delve into deep learning framework internals.
Inspired by the course, I developed a simple deep learning framework and plan a tutorial. Written in Python, it's code-light, suitable for students with some foundation. Future plans include more operators and potential porting to C++ for balanced performance and efficiency.
Course Textbook\uff1a\"Intelligent Computing Systems\" by Chen Yunji
"},{"location":"en/%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%E7%B3%BB%E7%BB%9F/AICS/#personal-resources","title":"Personal Resources","text":""},{"location":"en/%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%E7%B3%BB%E7%BB%9F/AICS/#new-edition-experiments-for-2024","title":"New Edition Experiments for 2024","text":"
The 2024 edition of the Intelligent Computing Systems lab has undergone extensive adjustments in the knowledge structure, experimental topics, and lab manuals, including comprehensive use of PyTorch instead of TensorFlow, and the addition of experiments related to large models.
As the new lab topics and manuals have not been updated on the Cambricon Forum, the following repository is provided to store the new versions of the Intelligent Computing Systems lab topics, manuals, and individual experiment answers:
The resources for the new edition will be updated following the course schedule of the UCAS Spring Semester 2024, with completion expected by June 2024.
2024 New labs, manuals, and answers created by @Yuichi: https://github.com/Yuichi1001/2024-AICS-EXP
Old edition coursework: 6 experiments (including writing convolution operators, adding operators to TensorFlow, writing operators with BCL and integrating them into TensorFlow, etc.) (details can be found on the official website)
Old edition lab manuals: Experiment 2.0 Instruction Manual
Learning notes: https://sanzo.top/categories/AI-Computing-Systems/, notes summarized from the lab manuals (link is no longer active)
@ysj1173886760 has compiled all resources and homework implementations used in this course at ysj1173886760/Learning: ai-system - GitHub.
Prerequisites: Introduction to Systems (e.g., 15-213), Basics of Deep Learning, Fundamental Mathematical Knowledge
Programming Languages: Python, C++
Difficulty: \ud83c\udf1f\ud83c\udf1f\ud83c\udf1f
Estimated Hours: 100 hours
The rise of deep learning owes much to user-friendly frameworks like PyTorch and TensorFlow. Yet, many users remain unfamiliar with these frameworks' internals. If you're curious or aspiring to delve into deep learning framework development, this course is an excellent starting point.
Covering the full spectrum of deep learning systems, the curriculum spans top-level framework design, autodifferentiation principles, hardware acceleration, and real-world deployment. The hands-on experience includes five assignments, building a deep learning library called Needle. Needle supports automatic differentiation, GPU acceleration, and various neural networks like CNNs, RNNs, LSTMs, and Transformers.
Even for beginners, the course gradually covers simple classification and backpropagation optimization. Detailed Jupyter notebooks accompany complex neural networks, providing insights. For those with foundational knowledge, assignments post autodifferentiation are approachable, offering new understandings.
Instructors Zico Kolter and Tianqi Chen released open-source content. Online evaluations and forums are closed, but local testing in framework code remains. Hope for an online version next fall.
This course, offered by top scholar Chen Tianqi during the summer of 2022, focuses on the field of machine learning compilation. As of now, this area remains cutting-edge and rapidly evolving, with no dedicated courses available domestically or internationally. If you're interested in gaining a comprehensive overview of machine learning compilation, this course is worth exploring.
The curriculum predominantly centers around the popular machine learning compilation framework Apache TVM, co-founded by Chen Tianqi. It delves into transforming various machine learning models developed in frameworks like Tensorflow, Pytorch, and Jax into deployment patterns with higher performance and adaptability across different hardware. The course imparts knowledge at a relatively high level, presenting macro-level concepts. Each session is accompanied by a Jupyter Notebook that provides code-based explanations of the concepts. If you are involved in TVM-related programming and development, this course offers rich and standardized code examples for reference.
All course resources are open-source, with versions available in both Chinese and English. The course recordings can be found on both Bilibili and YouTube in both languages.
Course Resources: The course website includes slides, notes, videos, homework, and project materials.
CMU's course on Probabilistic Graphical Models, taught by Eric P. Xing, is a foundational and advanced course on graphical models. The curriculum covers the basics of graphical models, their integration with neural networks, applications in reinforcement learning, and non-parametric methods, making it a highly rigorous and comprehensive course.
For students with a solid background in machine learning, deep learning, and reinforcement learning, this course provides a deep dive into the theoretical and practical aspects of probabilistic graphical models. The extensive resources available on the course website make it an invaluable learning tool for anyone looking to master this complex and rapidly evolving field.
This course offers a rigorous blend of classical learning theory and the latest developments in deep learning theory, making it exceptionally challenging and comprehensive. Previously taught by Percy Liang, the course is now led by Tengyu Ma, ensuring a high level of expertise and insight into the theoretical aspects of machine learning.
The curriculum is designed for students with a solid foundation in machine learning, deep learning, and statistics, aiming to deepen their understanding of the underlying theoretical principles in these fields. This course is an excellent choice for anyone looking to gain a thorough understanding of both the traditional and contemporary theoretical approaches in machine learning.
\"Minimizing Expectations\" is an advanced Ph.D. level research course, focusing on the interplay between inference and control. The course is taught by Chris Maddison, a founding member of AlphaGo and a NeurIPS 2014 best paper awardee.
This course is notably challenging and is designed for students who have a strong background in Bayesian Inference and Reinforcement Learning. The curriculum explores deep theoretical concepts and their practical applications in the fields of machine learning and artificial intelligence.
Chris Maddison's expertise and his significant contributions to the field, particularly in the development of AlphaGo, make this course highly prestigious and insightful for Ph.D. students and researchers looking to deepen their understanding of inference and control in advanced machine learning contexts. The course website provides valuable resources for anyone interested in this specialized area of study.
\"Deep Generative Models\" is a Ph.D. level seminar course at Columbia University, taught by John Cunningham. This course is structured around weekly paper presentations and discussions, focusing on deep generative models, which represent the intersection of graphical models and neural networks and are one of the most important directions in modern machine learning.
The course is designed to explore the latest advancements and theoretical foundations in deep generative models. Participants engage in in-depth discussions about current research papers, fostering a deep understanding of the subject matter. This format not only helps students keep abreast of the latest developments in this rapidly evolving field but also sharpens their critical thinking and research skills.
Given the advanced nature of the course, it is ideal for Ph.D. students and researchers who have a solid foundation in machine learning, deep learning, and graphical models, and are looking to delve into the cutting-edge of deep generative models. The course website provides a valuable resource for accessing the curriculum and related materials.
This learning path is suitable for students who have already learned the basics of machine learning (ML, NLP, CV, RL), such as senior undergraduates or junior graduate students, and have published at least one paper in top conferences (NeurIPS, ICML, ICLR, ACL, EMNLP, NAACL, CVPR, ICCV) and are interested in pursuing a research path in machine learning.
The goal of this path is to lay the theoretical groundwork for understanding and publishing papers at top machine learning conferences, especially in the track of Probabilistic Methods.
There can be multiple advanced learning paths in machine learning, and this one represents the best path as understood by the author Yao Fu, focusing on probabilistic modeling methods under the Bayesian school and involving interdisciplinary knowledge.
W&J: Graphical Models, Exponential Families, and Variational Inference by Martin Wainwright and Michael Jordan
Theory of Point Estimation by E. L. Lehmann and George Casella
"},{"location":"en/%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%E8%BF%9B%E9%98%B6/roadmap/#reading-guidelines","title":"Reading Guidelines","text":""},{"location":"en/%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%E8%BF%9B%E9%98%B6/roadmap/#how-to-approach","title":"How to Approach","text":"
Essential textbooks are a must-read.
Reference books are like dictionaries: consult them when encountering unfamiliar concepts (instead of Wikipedia).
Advanced books should be approached after completing the essential textbooks, which should be read multiple times for thorough understanding.
Contrastive-comparative reading is crucial: open two books on the same topic, compare similarities, differences, and connections.
Recall previously read papers during reading and compare them with textbook content.
Start with AoS Chapter 6: Models, Statistical Inference, and Learning as a basic introduction.
Read PRML Chapters 10 and 11:
Chapter 10 covers Variational Inference, and Chapter 11 covers MCMC, the two main routes for Bayesian inference.
Consult earlier chapters in PRML or MLAPP for any unclear terms.
AoS Chapter 8 (Parametric Inference) and Chapter 11 (Bayesian Inference) can also serve as references. Compare these chapters with the relevant PRML chapters.
After PRML Chapters 10 and 11, proceed to AoS Chapter 24 (Simulation Methods) and compare it with PRML Chapter 11, focusing on MCMC.
If foundational concepts are still unclear, review PRML Chapter 3 and compare it with AoS Chapter 11.
Read PRML Chapter 13 (skip Chapter 12) and compare it with MLAPP Chapters 17 and 18, focusing on HMM and LDS.
After completing PRML Chapter 13, move on to Chapter 8 (Graphical Models).
Cross-reference these topics with CMU 10-708 PGM course materials.
By this point, you should have a grasp of:
Basic definitions of probabilistic models
Exact inference - Sum-Product
Approximate inference - MCMC
Approximate inference - VI
Afterward, you can proceed to more advanced topics.
CS224n is an introductory course in Natural Language Processing (NLP) offered by Stanford and led by renowned NLP expert Chris Manning, the creator of the word2vec algorithm. The course covers core concepts in the field of NLP, including word embeddings, RNNs, LSTMs, Seq2Seq models, machine translation, attention mechanisms, Transformers, and more.
The course consists of 5 progressively challenging programming assignments covering word vectors, the word2vec algorithm, dependency parsing, machine translation, and fine-tuning a Transformer.
The final project involves training a Question Answering (QA) model on the well-known SQuAD dataset. Some students' final projects have even led to publications in top conferences.
Stanford's Introduction to Graph Neural Networks course, I haven't taken this course, but many friends who are focusing on GNN have recommended it to me, so I guess Stanford's course quality is still guaranteed as always. The instructor of this course is very young and handsome :)
Yet another popular online course offered by Andrew Ng on Coursera. It has attracted many learners and can be seen as the Bible of fundamental deep learning. The course provides well-covered projects, with clear but thorough instructions. The course starts from basic neural networks, to CNN, RNN, and all the way to Transformer, which has been a hot topic these days. After learning this course, you'll be equipped with the basic knowledge and skills for deep learning, and you may want to participate in Kaggle competitions to practice your skills with real tasks.
Stanford's CV introductory class, led by the giant of the computer field, Fei-Fei Li (the research team of the epoch-making famous dataset ImageNet in CV field), but its content is relatively basic and friendly, if you have taken CS230, you can directly start the Project as practice.
The CS285 course, currently taught by Professor Sergey Levine, covers various aspects of deep reinforcement learning. It is suitable for students with a foundational understanding of machine learning, including concepts such as Markov Decision Processes (MDPs). The course involves a substantial amount of mathematical formulas, so a reasonable mathematical background is recommended. Additionally, the professor regularly updates the course content and assignments to reflect the latest research developments, making it a dynamic learning experience.
For course content access, as of the Fall 2022 semester, the teaching format involves pre-recorded videos for students to watch before class. The live sessions mainly focus on Q&A, where the professor discusses selected topics from the videos and answers students' questions. Therefore, the provided course video links already include all the content. The assignments consist of five programming projects, each involving the implementation and comparison of classical models. Occasionally, assignments may also include the reproduction of recent models. The final submission typically includes a report. Given that assignments provide a framework and often involve code completion based on hints, the difficulty level is not excessively high.
In summary, this course is suitable for beginners entering the field of deep reinforcement learning. Although the difficulty increases as the course progresses, it offers a rewarding learning experience.
The University of Michigan's Computer Vision course is of exceptionally high quality, with its videos and assignments covering an extensive range of topics.
The assignments gradually increase in difficulty and cover all stages of mainstream CV model development, making this an excellent introductory course for Computer Vision.
In each assignment, you'll build and train models or frameworks mentioned in the lectures, following the provided handouts.
You don't need any prior experience with deep learning frameworks.
The course will teach you from scratch how to use Pytorch in the early assignments, and it can subsequently serve as a reference book for you.
As each assignment deals with different themes, you'll not only gain a first-hand understanding of the development of mainstream CV models through these progressive assignments but also appreciate the impacts of different models and training methods on final performance and accuracy.
Moreover, you'll get hands-on experience in implementing them.
In Assignment 1 (A1), you'll learn how to use Pytorch and Google Colab.
In Assignment 2 (A2), you will build a Linear Classifier and a two-layer neural network. Finally, you'll have the opportunity to work with the MNIST dataset, on which you will train and evaluate your neural network.
In Assignment 3 (A3), you'll encounter the classic Convolutional Neural Network (CNN) and experience the power of convolutional neural networks.
In Assignment 4 (A4), you'll have the opportunity to build an object detection model from scratch, following the handout to implement a One-Stage Detector and a Two-Stage Detector from two research papers.
By Assignment 5 (A5), you'll transition from CNN to RNN. You'll have the opportunity to build two different attention-based models, RNNs (Vanilla RNN & LSTM), and the famous Transformer.
In the final assignment (A6), you'll get a chance to implement two more advanced models, VAE and GAN, and apply them to the MNIST dataset. Finally, you'll implement two very cool features: network visualization and style transfer.
Beyond the assignments, you can also implement a Mini-Project, building a complete deep learning pipeline. You can refer to the course homepage for specifics.
All the resources involved in the course, such as lectures, notes, and assignments, are open source.
The only downside is that the Autograder is only available to students enrolled at the University of Michigan.
However, given that the correctness of the implementation and the expected results can already be confirmed in the provided *.ipynb (i.e., the Handout), I personally feel that the absence of Autograder doesn't affect the learning process.
It's worth mentioning that the main lecturer for this course, Justin Johnson, is a Ph.D. graduate of Fei-Fei Li and currently an Assistant Professor at the University of Michigan.
The open-source 2017 version of Stanford's CS231N was taught by Justin Johnson.
Because CS231N was mainly developed by Justin Johnson and Andrej Karpathy, this course also adopts some materials from CS231N.
Therefore, students who have studied CS231N might find some materials in this course familiar.
Lastly, I recommend every student enrolled in this course to watch the lectures on YouTube. Justin Johnson's teaching style and content are very clear and easy to understand, making them a fantastic resource.
@Michael-Jetson The 200,000 to 300,000 words of notes I have taken (and did not include homework, etc.) can be used as a reference:Michael-Jetson/ML_DL_CV_with_pytorch
"},{"location":"en/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/LHY/","title":"National Taiwan University: Machine Learning by Hung-yi Lee","text":""},{"location":"en/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/LHY/#course-overview","title":"Course Overview","text":"
Professor Hung-yi Lee, a professor at National Taiwan University, is known for his humorous and engaging teaching style. He often incorporates fun elements like Pok\u00e9mon into his slides, making the learning experience enjoyable.
Although labeled as a machine learning course, the breadth of topics covered is impressive. The course includes a total of 15 labs covering Regression, Classification, CNN, Self-Attention, Transformer, GAN, BERT, Anomaly Detection, Explainable AI, Attack, Adaptation, RL, Compression, Life-Long Learning, and Meta Learning. This wide coverage allows students to gain insights into various domains of deep learning, helping them choose areas for further in-depth study.
Don't be overly concerned about the difficulty of the assignments. All assignments come with example code from teaching assistants, guiding students through data processing, model building, and more. Students are required to make modifications based on the provided code. This presents an excellent opportunity to learn from high-quality code, and the assignments serve as valuable resources for those looking to breeze through course projects.
This introductory class for freshmen majoring in electronics at UC Berkeley teaches the fundamentals of circuitry. Through a variety of hands-on labs, students will experience collecting information from the environment through sensors and analyzing it to make predictions. Due to the COVID-19, all labs have remote online version, making them ideal for self-study.
The highlight of this course is the six exciting labs that will allow you to use signals and systems theory to solve practical problems in Python. For example, in lab3 you will implement the FFT algorithm and compare the performance with Numpy's official implementation. In lab4 you will infer the heart rate by processing the video of fingers. Lab5 is the most awesome one where you will reduce the noise in the photos taken by the Hubble telescope to recover the brilliant and bright starry sky. In lab6 you will build a feedback system to stabilize the pole on the cart.
Computer Security course from UC Berkeley, devided into 5 parts:
Security principles: how to design a secure system
Memory safety: buffer overflow attack
Cryptography: symmetric encryption, asymmetric encryption, MAC, digital signature .........
Web: SQL-injection, XSS, XSRF .......
Networking: attacks for each layer
The most impressive part to me is Project2, which requires you to design and implement a secure file sharing system in Go. It took me three full days to complete this extremely difficult project, with over 3 thousand lines of code. Such an intensive development experience can greatly enhance your ability to design and implement a secure system.
In 2020 summer semester, the lecture recordings are posted publicly, which can be found in the links below.
The course is mainly based on challenges, supplemented by lectures and reading materials. The challenges are developed in the form of CTF, and the difficulty increases in order.
For hackers with weak foundations, getting stuck is a normal phenomenon. If you encounter difficulties in solving the problem, you can seek help from the Discord Server given in the Chat column on the homepage.
Lectures on YouTube: https://youtube.com/pwncollege
Live Broadcasts on Twitch: https://twitch.tv/pwncollege
Chat on Discord: https://pwn.college/discord
Open Source on GitHub: https://github.com/pwncollege
Contact us via Email: pwn-college@asu.edu
In addition, due to an important factor in evaluating ASU students' course grades, the course does not encourage uploading problem-solving ideas, except for the first two challenges of each module.
Like CSE365, the course is also based on challenges, supplemented by lectures and reading materials. The challenges are developed in the form of CTF, and the difficulty increases in order.
The quality of the exercises is excellent, but some modules are quite difficult, especially the parts involving the kernel. Sometimes you'll spend a whole day struggling at one challenge with no progress. If you encounter difficulties in solving the problem, you can seek help from the Discord Server given in the Chat column on the homepage.
Lectures on YouTube: https://youtube.com/pwncollege
Live Broadcasts on Twitch: https://twitch.tv/pwncollege
Chat on Discord: https://pwn.college/discord
Open Source on GitHub: https://github.com/pwncollege
Contact us via Email: pwn-college@asu.edu
In addition, due to an important factor in evaluating ASU students' course grades, the course does not encourage uploading problem-solving ideas, except for the first two challenges of each module and challenge 16 in the reversing module.
Prerequisites: discrete mathematics, basic programming, basic knowledge of computer systems
Programming Languages: Python3
Difficulty: \ud83c\udf1f\ud83c\udf1f\ud83c\udf1f
Class Hour: 50 hours
MIT6.1600 is the undergraduate course on computer system security at MIT. The course is divided into five modules: authentication, transport security, platform security, software security, and human/end-user security. The organization of the course is quite clear: the authentication module focuses on authentication security, that is, how to prove that the \"you\" in the computer world is indeed \"you\". It then moves to the topic on communication security, such as data encryption and decryption, key exchange, etc. However, transport is only one aspect; the code ultimately needs to run on a device, which involves the security of the platform on which the code runs and even the software code itself. The course will also cover some content about privacy security, discussing group information security from a sociological perspective.
After completing this course, you will master many important fundamental concepts of computer security, such as public and private key encryption algorithms, hash algorithms, digital signatures, key exchange algorithms, and more. Besides the mathematics and theorem proofs, the course also uses the theoretical knowledge to explain many real-world security vulnerabilities, giving you a more concrete understanding of these security concepts. Additionally, there are six interesting labs that allow you to exploit many vulnerabilities through programming, deepening your understanding of the knowledge in practice, which I personally find quite interesting.
This is MIT's Computer Systems Security course. Lectures cover threat models, attacks that compromise security, and techniques for achieving security, based on recent research papers. Topics include operating system (OS) security, capabilities, information flow control, language security, network protocols, hardware security, and security in web applications.
Assignments include labs that involve implementing and compromising a secure web server and web application, and a group final project:
Lab 1: you will explore the zoobar web application, and use buffer overflow attacks to break its security properties.
Lab 2: you will improve the zoobar web application by using privilege separation, so that if one component is compromised, the adversary doesn't get control over the whole web application.
Lab 3: you will build a program analysis tool based on symbolic execution to find bugs in Python code such as the zoobar web application.
Lab 4: you will improve the zoobar application against browser attacks.
I mainly did Lab 3 in this course. Lab 3 requires you to traverse all the branches of a program by concolic execution, and it is not difficult to do once you understand the idea of symbolic execution. This Lab visually demonstrates the use of symbolic execution.
In the Final Project, you will build a remote file system, SecFS, that provides both confidentiality and integrity in the face of a completely untrusted server. Reference Papers: SUNDR
Syracuse University's cybersecurity course, supported by a $1.3 million grant from the NSF, has developed hands-on practical lab exercises known as SEED Labs. This course emphasizes both theoretical instruction and practical hands-on experience, providing detailed open-source lecture materials, video tutorials, textbooks printed in multiple languages, and ready-to-use attack and defense environments based on virtual machines and Docker. Currently, 1,050 research institutions worldwide are using this project.
It covers a wide range of topics in the field of computer and information security, including software security, network security, web security, operating system security, and mobile application security.
Assignments: There are more than 40 labs in this course, the lab environment can be built with customized virtual machines and docker provided by the course in quickly set up , and detailed principle explanations and experimental guidance are also provided. Take Buffer Overflow Experiment as an example. This experiment belongs to Software Security Topic, here is its Experimental Guide, here is its corresponding Textbook Content
This is an introductory course on Linux from UCB, which I find more systematic and clearer than MIT's similarly aimed open course, Missing Semester. This is the main reason I recommend it. While Missing Semester seems more like a course for filling gaps for students who have started programming but haven't systematically used these tools, DeCal is more suitable for absolute beginners. The twelve-week course covers Linux basics, shell programming (including tmux and vim), package management, services, basic computer networks, network services, security (key management), Git, Docker, Kubernetes, Puppet, and CUDA. It's ideal for newcomers to understand and get started with the Linux environment.
A slight drawback is that some course assignments require operations on remote servers, like exercises on ssh, which need UCB internal account access. However, most assignments can be practiced by setting up a virtual machine and using tools like Xshell or directly using a Linux desktop version. After completing the full course and assignments, you should have a basic understanding of Linux.
To compensate for the inability to use remote servers and to familiarize with the Linux command line, I recommend bandit. Bandit is a Wargame from OverTheWire, providing a free practice range for CTF enthusiasts. The first 15 levels of bandit are basic Linux operations without any CTF knowledge. These exercises perfectly supplement the parts of DeCal that are inaccessible to external students (mainly remote connections, file permissions, etc.).
Course Videos: Available on the official course website, Bilibili has an incomplete translation that only includes the first part.
Course Textbook: No specified textbook, but each week's labs contain enough reading material for in-depth study.
Course Assignments: Available on the official course website.
"},{"location":"en/%E7%BC%96%E7%A8%8B%E5%85%A5%E9%97%A8/MIT-Missing-Semester/","title":"MIT: The Missing Semester of Your CS Education","text":""},{"location":"en/%E7%BC%96%E7%A8%8B%E5%85%A5%E9%97%A8/MIT-Missing-Semester/#descriptions","title":"Descriptions","text":"
Offered by: MIT
Prerequisites: None
Programming Languages: Shell
Difficulty: \ud83c\udf1f\ud83c\udf1f
Class Hour: 10 hours
Just as the course name indicated, this course will teach the missing things in the university courses. It will cover shell programming, git, vim editor, tmux, ssh, sed, awk and even how to beautify your terminal. Trust me, this will be your first step to become a hacker!
This course has been voted the most popular public course by Harvard students for many years. Professor Malan is very passionate in class. I still remember the scene where he tears up the Yellow pages to explain the dichotomy method. Since this is a university-wide public course, the contents are pretty friendly to beginners and even if you already have some programming experience, all the programming assignments are quite exciting and worth a try.
This is an excellent course which I benefited a lot from.
The course teaches fundamental concepts such as frame, stack memory, heap memory, etc.
There are great programming assignments to deepen and reinforce your understanding of the hardest part in C, like pointers.
The course provides excellent practice in GDB, Valgrind, and the assignments will cover some basic Git exercises.
The course instructor recommends using Emacs for homework, so it's a good opportunity to learn Emacs. If you already know how to use Vim, I suggest you use Evil. This way you don't lose the editing capabilities of Vim, and you get to experience the power of Emacs. Having both Emacs and Vim in your kit will increase your efficiency considerably. Emacs' org-mode, smooth integration of GDB, etc., are convenient for developers.
It may require payment, but I think it's worth it.
Although this is an introductory course, it has both breadth and depth.
All the resources and assignments used by in this course are maintained in Duke Coursera Intro C. Several assignments have not been completed so far for time reasons.
Prerequisites: basic knowledge about imperative programming\uff0csuch as C, Python, Java
Programming Languages: OCaml
Difficulty: \ud83c\udf1f\ud83c\udf1f\ud83c\udf1f
Class Hour: 40 hours
"},{"location":"en/%E7%BC%96%E7%A8%8B%E5%85%A5%E9%97%A8/Functional/CS3110/#evaluation-for-course-modern-sicp","title":"Evaluation for course: Modern SICP","text":"
If the best course for getting started with programming is SICP, then following it is CS3110.
If you are unfamiliar with what a functional programming language is, or have only heard the term, then this course, just like its name, will allow you to experience what is meant by correctness, efficiency, and elegance.
CS3110 is not only limited to functional programming, but it also combines theory and practical applications extensively. The course content goes further, covering OCaml language fundamentals, data structures and algorithms, test development, formal proofs, language feature implementation, and many more topics. Moreover, these contents are not isolated; instead, they are progressive and complementary, making it highly worth studying.
The main instructor, Michael Ryan Clarkson, with years of immersion in programming, employs simple language, clear explanations, and dissects the content with precision. The course videos are even useful for improving listening skills, and understanding is effortless with the aid of English subtitles.
"},{"location":"en/%E7%BC%96%E7%A8%8B%E5%85%A5%E9%97%A8/Functional/CS3110/#a-brief-history-of-cs-3110","title":"A Brief History of CS 3110","text":"
CS3110 is a course meticulously crafted by Cornell University over more than 20 years. Initially inspired by MIT6.001 SICP, it has been enriched with stricter methodologies and materials, encompassing functional programming, environment modeling, data structures, algorithms, and language implementation. In 2008, its formal title changed to CS3110, transitioning to the OCaml language. In the fall of 2018, the process of writing the course textbook began. The current course instructor announced course videos on YouTube in 2021.
Recordings on youtube: https://www.youtube.com/playlist?list=PLre5AT9JnKShBOPeuiD9b-I4XROIJhkIU
Recordings on Bilibili: https://www.bilibili.com/video/BV1dv4y127Ui/
Textbook\uff1ahttps://cs3110.github.io/textbook
Assignments\uff1aIn the textbook, exercises are optional, with difficulty ranging from 1 to 4 stars, noting that the difficulty between 3-star and 4-star exercises varies significantly.
Functional programming is increasingly being integrated into modern programming languages. Streams in Java, Promises in JavaScript, and Record & Tuple in the draft phase of ECMAScript... When I was learning these things, I always felt like I was memorizing the behaviours of their API, and although I was able to write some programs using them, I never felt like I had mastered them. Why do they exist? Why are they like that? What is the idea behind their design? Learning functional programming will give you the answer.
Its core ingredient is functional programming. Just like Java is probably the default choice for teaching object-oriented programming.
This course will teach just enough Haskell syntax, library functions, and a small number of tools to explain the core program semantics and the core idea of functional programming. This will save you time not getting bogged down in the details of the language and its ecology, which I think is the biggest advantage of the course.
Topics covered in the course:
Pure Function
Lazy Evaluation
Strongly Typed
Type Inferred
Curry
Monoid / Functor / Monad / Applicative
If you have some programming experience, part 1 of the course is very easy. Most of the difficulties lie in part 2, after chap 13. Its exercises are great, which can give you a feeling of doing exercise of CS61A. There are enough hints in the comments and the solutions will be given to you after submission, and you can ask questions or discuss them with others in the official Telegram community.
All the resources and assignments used by @showtheunli in this course are maintained in showthesunli/haskell-mooc - GitHub. (It is highly discouraged to refer to other people's implementations when working on assignments.)
MIT's Java introductory course is suitable for beginners with no programming background. Each session consists of one hour of lecture (knowledge explanation) and one hour of lab (code practice), with a total of seven sessions. Although it's a fourteen-hour course, the learning process is fast, and you can complete it in about a day. It feels quite manageable for beginners.
The course content includes:
Rapid introduction to fundamental concepts needed for Java: the Java compilation principle, the classic \"Hello world\" code, and the eight primitive types in the first session.
How to maintain good code style: emphasizing naming conventions, indentation, and proper use of spaces in the third session.
Debugging techniques: Using Eclipse warnings, assertions in the sixth session, and handling exceptions in the seventh session.
The assignments in the lab are not very difficult, and many of them are discussed in the following lecture after each lab session. The key point to note is that coding is a skill that requires practical experience. For beginners, the most important aspect of learning to code is to practice and write code regularly, whether in lectures or lab sessions.
For those who want to advance after completing this course, you can consider studying MIT 6.005/6.031.
One of the CS50 families, taught by David J. Malan. You'll learn how to program in Python and \"Pythonic\" ways to deal with everything. The course also introduces libraries, code testing, and handling exceptions.
No programming experiences are assumed. So it may be appropriate for anyone who wants to learn Python.
This is the first course in the Berkeley CS61 series, and my introductory course to Python.
The CS61 series is composed of introductory courses to the CS major at Berkeley, where
CS61A: Emphasizes abstraction and equips students to use programs to solve real-world problems without focusing on the underlying hardware details.
CS61B: Focuses on algorithms and data structures and the construction of large-scale programs, where students combine knowledge of algorithms and data structures with the Java language to build large-scale projects at the thousand-line code level (such as a simple Google Maps, a two-dimensional version of Minecraft).
CS61C: Focusing on computer architecture, students will understand how high-level languages (e.g. C) are converted step-by-step into machine-understandable bit strings and executed on CPUs. Students will learn about the RISC-V architecture and implement a CPU on their own by using Logism.
CS61B and CS61C are both included in this guidebook.
Going back to CS61A, you will note that this is not just a programming language class, but goes deeper into the principles of program construction and operation. Finally you will implement an interpreter for Scheme in Python in Project 4. In addition, abstraction will be a major theme in this class, as you will learn about functional programming, data abstraction, object orientation, etc. to make your code more readable and modular. Of course, learning a programming language is also a big part of this course. You will master three programming languages, Python, Scheme, and SQL, and in learning and comparing them, you will be equiped with the ability to quickly master a new programming language.
Note: If you have no prior programming experience at all, getting started with CS61A requires a relatively high level of learning ability and self-discipline. To avoid the frustration of a struggling experience, you may choose a more friendly introductory programming course at first. For example, CS10 at Berkeley or CS50 at Harvard are both good choices.
Prerequisites: basic knowledge about programming and computer system
Programming Languages: Rust
Difficulty: \ud83c\udf1f\ud83c\udf1f\ud83c\udf1f
Class Hour: 30 hours
In this course, you will learn a fantastic language, Rust.
If you have studied C and have some knowledge of systems programming, you should have heard about memory leaks and the danger of pointers, but C's high efficiency makes it impossible to be replaced by other higher-level languages with garbage collection such as Java in system-level programming. Whereas Rust aims to make up for C's lack of security while having competitive efficiency. Therefore, Rust was designed from a system programmer's point of view. By learning Rust, you will learn the principles to write safer and more elegant system code (e.g., operating systems, etc.).
The latter part of this course focuses on the topic of concurrency, where you will systematically learn multi-processing, multi-threading, event-driven programming, and several other techniques. In the second project, you will compare the pros and cons of each method.
Personally, I find the concept of \"futures\" in Rust fascinating and elegant, and mastering this idea will help you in your following systems-related courses. In addition, Tsinghua University's operating system lab, rCore is based on Rust. You can see the documentation for more details.
Assignments: 6 Labs, 2 Projects, the course website has specific requirements. The projects are quite interesting where you will Implement a GDB-like debugger and a load balancer in Rust.
All the resources and assignments used by @PKUFlyingPig in this course are maintained in PKUFlyingPig/CS110L - GitHub.
Due to the rapid evolution of Rust, the libraries used in the 2020 version of the course project are obsolete, so @fung-hwang tried to adapt these libraries (in November 2022). His adaptation advice and completed assignments are maintained in fung-hwang/CS110L-2020spr - GitHub. It is possible that Rust and these libraries will have changed again when you start to learn CS110L, but you can still refer to this repo for help.
CS431 is a course about concurrent programming, mainly using Rust. The course consists of two parts: theory and practice. The theory part focuses on building a programming model under concurrent situations, while the practice part mainly focuses on understanding the implementation principles of locks and lock-free data structures in Rust-related libraries.
This course is accompanied by a series of assignments with small code size but not simple to consolidate your understanding of concurrent programming, from the design of concurrent safe cache and linked list based on locks, to lock-free hash table and the famous hazard pointer. Like many high-quality courses, these assignments are of high quality and come with detailed local tests, which are suitable for self-study.
This course is much more in-depth than I expected. The knowledge I know about spin locks and mutex locks is the most basic in this course, while the introduction of promising semantics, memory model and lock-free data structures gives me a deeper understanding of concurrency and Rust.
This is an accidentally discovered C++ course. The quality of the homework assignments is outstanding, with each being independently structured and simple, complemented by comprehensive unit tests, making it highly suitable for learning C++ programming. The course includes a total of 7 homework assignments, as follows:
Implement a Matrix class and related functions.
Implement a program that simulates the operation of a cryptocurrency client/server.
Implement a Binary Search Tree (BST).
Implement SharedPtr and UniquePtr smart pointers in C++.
Use inheritance and polymorphism to implement multiple classes.
Solve 4 problems using the STL library.
There's a Python project, for those interested.
The course homepage was not found, but the source code for the homework (named AP1400-2-HW) can be found on GitHub.
CS106B/X are advanced programming courses at Stanford. CS106X is more difficult and in-depth than CS106B, but the main content is similar. Based on programming assignments in C++ language, students will develop the ability to solve real-world problems through programming abstraction. It also covers some simple data structures and algorithms, but is generally not as systematic as a specialized data structures course.
Some very basic but practical data structures and algorithms: collections, ADT, recursion, BFS, DFS, backtracking, sorting, hash, pointer, linked list, BST, OOP, pass by value, pass by reference, stack allocation, heap allocation, memory management. Additionally, some very useful techniques, such as how to use a debugger to troubleshoot, and how to escape from an initialized maze by reading the content in the debugger in assignment 8.
Like CS61A, code frameworks and test programs are provided. Although not as detailed as the CS61A tests, the assignments also require you to add your own test cases. Each assignment comes with a detailed document that guides you step-by-step to achieve each milestone. In the end, you can observe the results of your data structures and algorithm implementations in the GUI provided by the starter code, which is very rewarding. Each assignment corresponds to very interesting and practical cases, such as the final task of implementing Huffman encoding to compress and decompress files.
@Andy-xiaokang All the resources and assignment implementations used in studying this course are compiled in Andy-xiaokang/CS106B - GitHub about the incompatible libray you can refer to readme and I recommend the video youtube spring 2015
"},{"location":"en/%E7%BC%96%E7%A8%8B%E5%85%A5%E9%97%A8/cpp/CS106L/","title":"CS106L: Stanford C++ Programming","text":""},{"location":"en/%E7%BC%96%E7%A8%8B%E5%85%A5%E9%97%A8/cpp/CS106L/#descriptions","title":"Descriptions","text":"
Offered by: Stanford
Prerequisites: better if you are already proficient in a programming language
Programming Languages: C++
Difficulty: \ud83c\udf1f\ud83c\udf1f\ud83c\udf1f
Class Hour: 20 hours
I've been writing C++ code since freshman year, and it wasn't until I finished this class that I realized the C++ code I was writing was probably just C + cin/cout.
This class will dive into a lot of standard C++ features and syntax that will allow you to write quality C++ code. Techniques such as auto binding, uniform initialization, lambda function, move semantics, RAII, etc. have been used repeatedly in my coding career since then and are very useful.
It is worth mentioning that in this class, you will implement a HashMap (similar to unordered_map in STL), which almost ties the whole course together and is a great test of coding skills. Especially after the implementation of iterator, I started to understand why Linus is so sarcastic about C/C++, because it is really hard to write correctly.
In short, the course is not difficult but very informative which requires you to consolidate repeatedly in later practice. The reason why Stanford offers a single C++ programming class is that many of the subsequent CS courses' projects are based on C++. For example, CS144 Computer Networks and CS143 Compilers. Both of these courses are included in this book.
CS242 is a course about programming languages (PL), but it is not a pure theoretical course in the traditional sense. This course first introduces classic PL theories such as Lambda calculus and type system, then uses the ideas and actual programming languages of system programming to motivate students to understand these theories, and shows how they help developers avoid various errors in actual programming.
The instructor Will Crichton also wrote his course design ideas into a paper From Theory to Systems: A Grounded Approach to Programming Language Education, which elaborates this teaching route from theory to systems.
We help readers understand the specific content of this course by simply introducing each assignment:
Formalization and proof of JSON
Classic Lambda calculus in PL
Introduction to functional programming using OCaml
Use OCaml to implement a type checker and interpreter for a functional language, which is also a classic assignment in PL
Theory and practice of WebAssembly
Linear Type and Rust's ownership mechanism
Rust's asynchronous programming basics
Design state machines and implement session-typed TCP libraries using Rust's type system
The final assignment has four options:
Theorem proving in Lean
Read-Log-Update in Rust
Verified filesystems in F-Star
Deep learning framework in OCaml from a PL perspective
These assignments cover a wide range of knowledge, from the classic PL theory and practice to the impact of programming languages such as Rust on programming and system design, and finally the distinctive projects. Almost all programming assignments have detailed local tests, especially the deep learning framework in the final project has more than 200 tests, which is suitable for self-study.
The first few assignments are more about PL theory, and the later assignments are more about system programming. If you think that the course content and assignments in the first few times are too theoretical, you can focus on the assignment of implementing the interpreter using OCaml, which can not only help you have a deeper understanding of the previous theory, but also let you practice the type checking and interpretation of a functional language.
The later assignments tend to use theory to guide system programming and design, especially Rust and its unique ownership mechanism and type system. Although we often have to fight with the compiler, this also just shows the significance of type systems and theories for programming and design.
I personally feel that the assignments are difficult, but the gains are great. When the programming practice in the later assignments intersects with the theoretical knowledge learned before, there will be a pleasant feeling of sudden enlightenment. If you encounter difficulties in completing the assignments, this is normal. Please calm down and think carefully, or read the assignment guide again.
Prerequisites: elementary Discrete Mathematics, including logic and proof methodology, basic functional programming
Programming Languages: OCaml (ML)
Difficulty: \ud83c\udf1f\ud83c\udf1f\ud83c\udf1f
Class Hour: 20 to 30 hours (12 hours of lecture)
This course offers a structural, operational approach to programming language semantics. It provides a very beginner-friendly but mathematically rigorous introduction to the constructs and specification declaration of programming languages, in the context of actually defining and designing a language. It is also one of the few PLT courses that offers publicly available videos.
The course covers semantics topics ranging from operational and denotational semantics. The course starts with introducing the basic operational semantics of a simple imperative language defined by BNF, and gradually coming to introducing formal type systems, using mathematical induction (especially structural induction) to build rule-based induction proofs. It then comes to how we manipulate data under a functional programming perspective and introduces subtyping and handling of functions. Finally it comes to the discussion of semantics equivalence, congruence property and semantics under concurrency.
This course was taught to 2nd year undergraduate students, however building up some very important concepts. It would be a pivotal capstone for further studies on type theory, category theory, hoare logic and model checking.
Prerequisite: Data Structures and Algorithms, familiar with at least one programming language
Programming Languages: Java
Difficulty: \ud83c\udf1f\ud83c\udf1f\ud83c\udf1f
Learning Hours: 60 hours
Software Analysis is a course jointly offered by Yue Li and Tian Tan of Nanjing University. It mainly introduces program analysis, which refers to the theory and practice of static analysis. The idea of static analysis is to obtain approximate answers about specific properties of the program without running it. This course starts with the abstract syntax tree, control flow graph and intermediate representation, then introduces the theory and practice of data flow analysis and pointer analysis, and finally introduces several advanced topics, such as IFDS.
In my opinion, there are two reasons why this course is worth learning:
Teaching. Program analysis is generally not easy to get started, but the two teachers are particularly meticulous in their lectures, and they will also guide you step by step through the process of an algorithm. Personally, I think that as long as you listen carefully in class, there is no problem that you can't understand.
Assignments. The assignments are based on the Java program analysis framework Tai-e created by the teachers. The eight assignments cover a variety of static analysis techniques, including compiler optimization (liveness analysis, constant propagation, dead code detection), basic program analysis (program call graph construction, non/context-sensitive pointer analysis), and the application of program analysis in software security (taint analysis). The course also provides an online evaluation system available to everyone, which is suitable for self-study.
The assignments are mainly to implement the pseudo-code algorithms in class, so as to better help you understand the knowledge taught in class. I feel that the difficulty is not particularly high, especially suitable for completing the corresponding experiments after class to test your mastery of the knowledge taught in class. However, it is still challenging to pass all the test cases of each assignment.
Compared with the Software Analysis course of Nanjing University, this course covers more comprehensive theoretical and practical content of program analysis, and is more difficult. My main way of learning this course is to listen to the course. Prof. Xiong's lectures are very interesting. In addition to the theoretical content, he occasionally tells some academic related stories :)
The course project of this experiment is to implement a pointer analysis system on Java and a program synthesis tool, which is also a very interesting practice.
This course aims to impart the principles of compiler construction for programming languages to students. The instructors have designed a \u201cCOOL language\u201d, namely Classroom-Object-Oriented-Language. By study and practice, you will design and implement a compiler, which can translate the human-readable COOL language into machine-readable MIPS assembly which can be run on the SPIM emulator.
Following the Dragon Book, the theoretical part of the course covers lexical analysis, syntax analysis, semantics analysis, runtime environments, register allocation, optimization, and code generation. The practical part, accordingly, is divided into 4 steps: 3 for the frontend and 1 for the backend. The difficulty is considered gradual, increasing at a proper rate. Should you have enough time and interest even after completing all the required work, there\u2019s a huge room left for you to do optimization.
Textbook: Compilers: Principles, Techniques and Tools (Dragon Book)
Assignments: 5 written assignments + 5 programming labs
"},{"location":"en/%E7%BC%96%E8%AF%91%E5%8E%9F%E7%90%86/CS143/#collection-of-course-resources","title":"Collection of Course Resources","text":"
@skyzluo has been maintaining a repo of course resources used and reference implementations of programming labs: skyzluo/CS143-Compilers-Stanford - GitHub.
This course provides a compiler framework code called KECC(KAIST Educational C Compiler) written in Rust, based on which students build some core parts of the compiler, include AST print, SSA-based IR generation, IR optimization and RISC-V assembly generation. Compared to other compiler courses, this course has the following main characteristics:
The course focuses on the real C language rather than a custom toy language, and uses C language fuzzing tools(Csmith) for testing.
This course emphasizes on practicality. It does not talk much about the theory of compiler frontend and the assignments start with the traversal of AST so you do not need to build the frontend yourself. The course mainly focuses on IR design, generation and optimization, as well as RISC-V assembly code generation. This course is also helpful for understanding and learning LLVM.
The course comes with accompanying videos that provide detailed code tours, which is beginner-friendly.
The compiler principles course at Nanjing University utilizes the popular ANTLR (ANother Tool for Language Recognition) v4 programming language parsing and code generation tool to aid in teaching. This tool allows users to focus on designing lexical or syntactic analysis while ANTLR 4 generates repetitive template code. IDE plugins are also available, enabling real-time visualization of the parse tree for easier student comprehension.
ANTLR 4 is an LL parser generator, which, compared to LR and LALR parser generators, can handle a narrower scope of grammars. However, its generated parsers have the advantage of being easier to understand and use. Additionally, its support for \"infinite lookahead\" scanning improves handling of narrow grammar scopes.
The instructor delivers lectures on compiler design in a humorous and engaging manner, incorporating appropriate diagrams and real-life examples to maintain student interest. Particularly in this version of the course, the approach involves first practically completing small examples using ANTLR 4, followed by supplementing with theoretical knowledge. This allows students to approach theoretical aspects with specific questions in mind, enhancing memorability. Through the study of theoretical knowledge, the \"mysterious veil\" of the C language is gradually lifted.
The theoretical part follows the rhythm outlined in the \"Dragon Book,\" covering topics such as lexical analysis, syntax analysis, semantic analysis, runtime environments, register allocation, code optimization, and generation.
The practical aspect is the highlight of this course, guiding students step by step to implement their own compiler from simple to complex.
The instructor is extremely generous, allowing even non-university students to access the Online Judge and participate in course discussions. The instructor also meticulously organizes study materials from previous years, making them easily accessible on the course website.
The instructor also openly shares the Zulip address for the teaching group (if there are any changes, they can be found on the course website), meaning that students can ask questions and see the questions of other Nanjing University students studying the same material. These questions receive responses from teaching assistants and the instructor, eliminating the need to reiterate pitfalls or experiences, as students can exchange information on one platform with others studying the same content.
The biggest takeaway is that there is no longer a sense of difficulty or uncertainty in implementing a compiler. Upon completing the course, students have a preliminary and effective approach that enables them to face challenges confidently.
The practice course of Compiler Principles at Peking University aims to teach student to implement a compiler that translates from a simplified version of the C language \u2014 SysY to RISC-V assembly. Unlike other courses that provide skeleton code, this course grants you a great degree of freedom. The test programs only check the correctness of the assembly code your compiler outputs, without imposing any restrictions on the specific design of your compiler or even the programming language used. You need to start from scratch and gradually build your own compiler. However, this is quite challenging even for Peking University students, so in 2022, the course TA @MaxXing significantly upgraded this course, designing a special intermediate representation, Koopa IR, for the course. Koopa IR is more rationally designed and, while similar to LLVM IR, it simplifies many details, focusing only on the practical aspects needed. At the same time, a corresponding runtime library was designed for Koopa IR, allowing you to easily parse/generate/modify/output Koopa IR without having to consider other superfluous details. Additionally, a detailed document breaks down the large project of building a compiler into nine small steps, making it easier for any student willing to invest the time to implement their own compiler.
The following content is excerpted from @MaxXing's Blog which introduces this course in more details:
You may have seen countless tutorials teaching how to write a compiler, but they may have various issues that still leave you puzzled about where to start:
The tutorials are not aimed at people with \"zero compiler foundation,\" and can be difficult to understand.
They teach how to make a compiler but not why to do it that way, leaving you still in a fog after reading.
Complicated environment setup is required before starting coding, discouraging beginners at the start.
The initial tasks are unrelated to \"compiling a program,\" and it can take a month following the tutorial to see a running program from your compiler, resulting in a long feedback cycle.
What you finally write is just an interpreter, or it can't compile to a real ISA (like outputting some bytecode), or it's highly dependent on other frameworks (like LLVM), which doesn't let you feel the accomplishment of \"I really made a compiler\" and the exhilaration of \"doing everything myself.\"
The compiler implemented can only compile simple programs, such as sorting algorithms, which seem very boring. Who sorts just for fun?
Tutorials and their resources are not in Chinese, or they require payment and are not open source.
During my graduate studies, I was the TA in the undergraduate Compiler Principles course. To help undergraduates better understand how compilers work, after referring to several other tutorials, I designed a new set of tutorials that teach you how to write a compiler from scratch:
You can use C/C++/Rust to develop your compiler, the tutorial only requires you to have the ability to program in these languages, without any need for foundational knowledge of compiler principles or related practical experience.
The tutorial not only tells you how to write a compiler but also why to do it that way, and what else you could do.
The tutorial adopts an incremental, iterative approach, guiding you from a compiler that can only handle the main function to gradually expanding to implement a compiler for a C-like language that includes control flow, function calls, and arrays. The compiler can output RISC-V assembly.
Providing a Docker-based environment for one-click setup. The environment also includes automatic testing scripts for one-click testing of your compiler.
The tutorial introduces tools that can take over some of the tedious grunt work, such as generating lexer/parser, parsing and generating IR, etc. The rest, like building AST, semantic analysis, generating IR, and producing target code, is entirely up to you to implement.
The compiler you ultimately implement will be capable of compiling many complex programs, such as the Mandelbrot set drawing program or a Lisp interpreter (this interpreter can even interpret another Lisp interpreter). We will provide these programs for you to experience the real joy of using your compiler.
The tutorial and its accompanying tools, experimental environments, etc., are all open source and completely free!
You can access this tutorial on GitHub Pages: Peking University Compiler Practice Course Online Documentation. If you have never tried writing a compiler yourself, why not try it now?
My wish is that everyone feels the joy of writing compilers.
Finally, my highest regards to @MaxXing. \u2014 from PKUFlyingPig
The theoretical part of this course covers a wide range of topics, including lexical analysis, syntax analysis, syntax-directed translation, and intermediate code translation from traditional compiler principles courses, as well as runtime management and both machine-independent and machine-specific code optimization. The practical component provides C++ code for the Cminusf compiler framework, allowing students to progressively build a fully functional modern compiler over six labs. Unlike other compiler courses, this course uses a subset of modern LLVM as the intermediate code, offering a forward-looking approach and including backend code generation and intermediate code optimization, making it a world-class compiler course.
The course labs use scripts to provide comprehensive automated testing, with complete tutorials available on the course homepage.
The course includes a full set of open-source course materials, lab framework code, and lab tutorials, making it beginner-friendly.
The labs progress gradually, increasing in difficulty, ensuring that students with varying levels of prior knowledge can benefit.
In Lab 1, Flex and Bison are used to implement the compiler frontend. Lab 2 involves generating intermediate code with LightIR (a subset of LLVM). Lab 3 covers backend code generation for the Loongson assembly language. Lab 4 focuses on intermediate code optimization. Lab 5 implements machine-independent optimization, and Lab 6 deals with register allocation.
This course provides a comprehensive introduction to computer graphics. It focuses on fundamental concepts and techniques, and their cross-cutting relationship to multiple problem domains in graphics (rendering, animation, geometry, imaging). Topics include: sampling, aliasing, interpolation, rasterization, geometric transformations, parameterization, visibility, compositing, filtering, convolution, curves & surfaces, geometric data structures, subdivision, meshing, spatial hierarchies, ray tracing, radiometry, reflectance, light fields, geometric optics, Monte Carlo rendering, importance sampling, camera models, high-performance ray tracing, differential equations, time integration, numerical differentiation, physically-based animation, optimization, numerical linear algebra, inverse kinematics, Fourier methods, data fitting, example-based synthesis.
This introductory course in computer graphics begins with using Blender to generate images and understanding the underlying mathematical concepts, including triangles, normals, interpolation, texture mapping, bump mapping, and more. It then delves into light and color and how they affect computer displays and printing. The course also covers BRDF and some basic lighting and shading models. Towards the end, topics like ray tracing, anti-aliasing, and acceleration structures are introduced.
For more detailed information, you can visit the course website.
This course is somewhat less in-depth compared to GAMES101 and uses Python, making it more accessible for students who are not familiar with C++.
This course comprehensively and systematically introduces the four major components of modern computer graphics: (1) rasterization imaging, (2) geometric representation, (3) the theory of light propagation, and (4) animation and simulation. Each aspect is explained from basic principles to practical applications, along with the introduction of cutting-edge theoretical research. Through this course, you can learn the mathematics and physics behind computer graphics and enhance your practical programming skills. As an introduction, this course aims to cover as many aspects of graphics as possible, clearly explaining the basic concepts of each part to provide a complete, top-down understanding of computer graphics. A global understanding is crucial; after completing this course, you will realize that graphics is not just OpenGL or ray tracing but a set of methods for creating virtual worlds. The title of this course also contains the word \"modern,\" indicating that the knowledge imparted is contemporary and essential for the modern graphics industry.
GAMES101 is a well-known graphics course in China. Unlike the traditionally math and algorithm-heavy perception of graphics, this course introduces the field of graphics in a very vivid way.
Each project is not code-heavy but is quite interesting. Through these projects, students will implement simple rasterization to render basic models and ray tracing for better rendering quality. Each project also includes optional extensions to enhance the quality and speed of the rendered models.
If you enjoy gaming, you might be familiar with real-time ray tracing, a technology that the course instructor, Lingqi Yan, has directly contributed to. By following the course videos and completing each project, you'll likely develop a strong interest in graphics and modern rendering techniques, just as I did.
All resources and homework implementations used by @ysj1173886760 during the course are compiled at ysj1173886760/Learning: graphics/GAMES101 - GitHub.
This course serves as an introduction to physics-based computer animation techniques, focusing on various fundamental physical animation simulation technologies.
The course mainly covers four areas: 1) Rigid body simulation; 2) Particle systems, springs, constraints, and cloth simulation; 3) Elastic body simulation based on the finite element method; 4) Fluid simulation.
The course content will not delve into specific physical simulation engines but will discuss the technologies behind various engines and their pros and cons. Since developing and learning physical simulations requires a solid mathematical foundation, the initial stages of the course will also spend some time reviewing necessary mathematical concepts. Upon successful completion of the course, students should have a deep understanding of basic physical simulation techniques and some exposure to advanced simulation technologies.
In graphics, the field can be roughly divided into rendering, simulation, and geometry. While GAMES101 and GAMES202 mainly focus on rendering, GAMES103 is an excellent resource for learning about physical simulation.
All resources and homework requirements used by @indevn during the course are compiled at GAMES103 Unofficial. For detailed implementations of the assignments, there are many articles on Zhihu that provide in-depth explanations and can be referenced.
This course comprehensively introduces the key issues and solutions in modern real-time rendering. Since real-time rendering (>30 FPS) demands high speed, the focus of this course is on how to break the trade-off between speed and quality under strict time constraints, ensuring both high-speed real-time performance and photorealism.
The course will be presented in a thematic manner, covering cutting-edge content from both academia and industry, including: (1) real-time soft shadow rendering; (2) ambient lighting; (3) global illumination with or without precomputation; (4) physically-based shading models and methods; (5) real-time ray tracing; (6) anti-aliasing and supersampling; as well as various common acceleration methods.
In addition to the latest and most comprehensive content, an important distinction of this course from other real-time rendering tutorials is that it does not teach the use of game engines or emphasize specific shader implementation techniques. Instead, it focuses on the science and knowledge behind real-time rendering. The goal of this course is to provide you with a solid foundation to develop your own real-time rendering engine upon completion.
As an advanced course following GAMES101, GAMES202 offers a slightly increased level of difficulty, but it's manageable for students who have completed GAMES101. Each project requires a moderate amount of coding but involves significant thought.
Prerequisites: Calculus, Linear Algebra, C/C++ Programming, Data Structures
Programming Languages: C/C++
Difficulty: \ud83c\udf1f\ud83c\udf1f\ud83c\udf1f
Class Hour: 100 hours
Mr. Liu Ligang from the School of Mathematics at USTC uploaded the course during the 2020 epidemic, and I personally feel that it is more comprehensive compared to Games101's focus on rendering, with content such as discrete geometry processing that the latter does not have, and it seems to be more mathematical, so it can be complemented with Games101, and the course materials are fully open to the public.
Textbooks:E. Angel, Interactive Computer Graphics \u2014 A top-down approach using OpenGL\u2122, 6th ed., 2011.(This course does not prescribe the use of a prescribed textbook, and focuses on cutting-edge academic papers; the following textbooks are for reference only)
Assignments:http://staff.ustc.edu.cn/~lgliu/Courses/ComputerGraphics_2020_spring-summer/default.htm, 9 homework and 1 project
Prerequisites: Students should be able to write moderately complex programs, read and understand portions of large code bases, trace memory diagrams, and be fluent with Unix, GDB, Valgrind, and Make.
This course builds upon the foundational knowledge gained in CS107 and delves into advanced computer systems and program construction. It focuses on designing large systems, software that spans multiple machines, and parallel computing. The course aims to teach students the principles and practice of engineering of computer software and hardware systems.
The course covers a broad range of topics including how your programs map onto the components of computer systems, understanding of program behavior and execution, understanding the designs and tradeoffs of large systems, writing software that spans multiple machines, and writing software that runs tasks in parallel on a single machine.
The teaching style of this course is engaging and practical. The instructors guide the students to understand the numerous technical challenges and design principles in computer systems by going through the course materials and labs. Weekly labs let you add new features to the projects, which focus on enhancing students' practical skills. There are several labs during the whole semester which give you the chance to understand every aspect of the computer systems.
In addition to the labs, the course also includes assignments that are designed to provide hands-on experience and deepen understanding of the course material. Each assignment has a complete framework for testing.
This course is one of CMU's most reputable courses, and is known for its extensive content and difficult projects. The course covers assembly language, computer architecture, operating systems, compilation and linking, parallelism, networking, etc. As an introductory course of computer system, it has both breadth and depth, and does require considerable perseverance and coding skills if you learn it on your own.
The textbook for this course, known as CSAPP, was written by Professor Bryant, Dean of the School of Computer Science at CMU. This is also the first computer textbook that I read carefully from the start to the end, although it was tough, I gained a lot from it.
Peking University purchased the copyright of the course and opened a similar one, but you can have access to all of the course resources on its official homepage (see the link below for details).
This course is so famous that you can easily have access to the project solutions on the Internet. But if you really want to practice your coding skills, it is highly recommended to implement the projects on your own.
After completing this course, your understanding of computer systems will definitely go up a notch.
Textbook: Computer Systems: A Programmer's Perspective, 3/E
Assignments: 11 Projects, skeleton code all open source.
If you have trouble with Chapter 7 Linking, I recommend reading the book Programmer's Self-Cultivation, subtitled link. load and library. This book can complete our understanding of program linking, and I believe after reading this book you will have a deeper comprehension of program linking, ELF files, and dynamic libraries. It is highly recommended to be read as a supplementary material after reading CSAPP and having a certain understanding of computer systems.
One of the lecturers of this course is Professor Nick McKeown, a giant in the field of Networking. At the end of each chapter of MOOC, he will interview an executive in the industry or an expert in the academia, which can certainly broaden your horizons.
In the projects, you will use C++ to build the entire TCP/IP protocol stack, the IP router, and the ARP protocol step by step from scratch. Finally, you will replace Linux Kernel's protocol stack with your own and use socket programming to communicate with your classmates, which is really amazing and exciting.
Prerequisites: basic knowledge about computer system
Programming Languages: None
Difficulty: \ud83c\udf1f\ud83c\udf1f\ud83c\udf1f
Class Hour: 40 hours
Computer Networking: A Top-Down Approach is a classic textbook in the field of computer networking. The two authors, Jim Kurose and Keith Ross, have carefully crafted a course website to support the textbook, with lecture recordings, interactive online questions, and WireShark labs for network packet analysis. The only pity is that this course doesn't have hardcore programming assignments, and Stanford's CS144 makes up for that.
This course is a well-known computer networking course on the Chinese Internet, it adopts the renowned textbook: Computer Networking: A Top-Down Approach, 7th Edition. This a practical course that is not limited to theoretical knowledge, but it is Strongly recommended to read the textbook before watching videos, otherwise you may not catch up with the course easily.
The course covers the majority of the textbook and also includes exam content, so enjoy it.
The recordings of the lectures were uploaded by Prof. Zheng himself on Bilibili. Moreover, he has been answering questions in the comments below the videos since 2020, which is very patient and responsible.
Prerequisites: solid foundations of computer science
Programming Languages: Any
Difficulty: \ud83c\udf1f\ud83c\udf1f\ud83c\udf1f
Class Hour: 100 hours
This course focuses on a relatively \"unfamiliar\" area \u2014 empirical research in software engineering. It is taught by Bogdan Vasilescu, who has extensive expertise in empirical studies and open-source software research.
The course is offered by CMU for PhD students pursuing research in this field. It covers a range of qualitative and quantitative research methods, such as interviews, qualitative coding, survey design, and various statistical analysis methods, helping students understand, learn, and engage in empirical research. The course also introduces the extraction and integration of data from software repositories like GitHub and Stack Overflow, applying statistical modeling, social network analysis, and other data analytics techniques.
Although the field of computer science traditionally focuses more on engineering technology, empirical research is essential for the design, evaluation, and potential social value of tools and technologies. For example, it involves evaluating new algorithms or new technological frameworks, analyzing relevant data within a field, and understanding challenges that practitioners might face. This course can expand and complement a focus on technical aspects. For those interested in pursuing research involving empirical studies in the field of software engineering, this course could be an excellent introduction.
The goal of this course is for you to learn how to write high quality code, and what is meant by high quality is to meet the following three targets:
Safe from bugs. Correctness (correct behavior right now) and defensiveness (correct behavior in the future) are required in any software we build.
Easy to understand. The code has to communicate to future programmers who need to understand it and make changes in it (fixing bugs or adding new features). That future programmer might be you, months or years from now. You\u2019ll be surprised how much you forget if you don\u2019t write it down, and how much it helps your own future self to have a good design.
Ready for change. Software always changes. Some designs make it easy to make changes; others require throwing away and rewriting a lot of code.
To achieve this, the instructors write a book explaining many of the core principles of software construction and valuable lessons learned from the past. The book covers many practical topics such as how to write comments and specifications, how to design abstract data structures, and many parallel programming caveats. You will explore all of these ideas in the programming assignments.
In the 2016 spring, the course open-sourced all of its programming assignments, and the textbook can be found on the latest website (see links below).
This is Berkeley's software engineering course. Unlike many traditional software engineering courses that emphasize UML diagrams, plans, and documents, this course adopts agile development methodologies and uses the cloud platform to provide software as a service. The instructors wrote a textbook Software as a service to explain the concept of SaaS and agile development. Also, there are plenty of programming assignments using Ruby + Rails framework.
This course is available on Edx, an online education platform sponsored by MIT and Harvard, where you can search for the course Agile SaaS Development and learn it yourself. The course content follows the textbook's order and takes you to build software step by step in an agile development way and deploy it on the cloud platform for free.