极客时间-专栏+视频svip会员|持续更新|重磅首发|2022年12月已更新

课程介绍(A001078)：

极课时间专栏全部课程！！！为你打造随身图书馆，音视频齐全！！！，各类大厂技术大神（阿里P10、腾讯专家），CEO讲解成长路程！！！强烈推荐程序员学习的充电站，站在巨人的肩膀，早日成功！！

2022年12月已更新！！

2022年九月已更新！！

2022年八月已更新！！

2022年七月已更新！！

2022年六月已更新！！

2022年五月已更新！！

2022年四月已更新！！

2022年三月已更新！！

2022年1月已更新！！

（专栏+视频课262门课）

打包现有262个课程 + 后续新出课程

文件目录：

极客时间-专栏+视频svip会员持续更新重磅首发2022年12月已更新

│ ├─1、专栏

│ │ ├─001-技术与商业案例解读

│ │ │ ├─001-技术与商业案例解读

│ │ │ ├─001-西雅图IT公司之RealNetworks：一个帝国的兴衰（上）

│ │ │ ├─002-西雅图IT公司之RealNetworks：一个帝国的兴衰（下）

│ │ │ ├─003-以RealNetworks为例，谈谈初创公司如何应对巨头碾压

│ │ │ ├─004-可视化分析鼻祖Tableau

│ │ │ ├─005-从Tableau上市，看学术界和工业界人士创业

│ │ │ ├─006-在线旅游帝国Expedia崛起的背后

│ │ │ ├─007-房产经纪的颠覆者Redfin：在“传统”与“现代”间徘徊

│ │ │ ├─008-房产经纪的“协作者”Zillow：一个地产数据平台

│ │ │ ├─009-颠覆还是协作，房地产市场上Redfin和Zillow的抉择

│ │ │ ├─010-应用交付网络大厂F5：“一招鲜”之殇

│ │ │ ├─011-在线差旅报销鼻祖Concur：在转型中获得发展

│ │ │ ├─012-漫谈企业转型：在市场变迁中寻找生机

│ │ │ ├─013-克雷公司沉浮录：行走在超级计算机市场

│ │ │ ├─014-“单一化”的隐忧：从克雷公司看“一条腿走路”

│ │ │ ├─015-Halo的开发者Bungie：与微软的聚散

│ │ │ ├─016-“卖身”须谨慎：创业公司面临的抉择

│ │ │ ├─017-亚马逊领导力准则之要有硬骨头

│ │ │ ├─018-亚马逊领导力准则之决策正确

│ │ │ ├─019-亚马逊领导力准则之客户至尚

│ │ │ ├─020-亚马逊领导力准则之勤俭节约

│ │ │ ├─021-亚马逊领导力准则之主人翁精神

│ │ │ ├─022-亚马逊领导力准则之选贤育能

│ │ │ ├─023-亚马逊领导力准则之最高标准

│ │ │ ├─024-亚马逊领导力准则之创新简化

│ │ │ ├─025-亚马逊领导力准则之崇尚行动

│ │ │ ├─026-亚马逊领导力准则之远见卓识

│ │ │ ├─027-亚马逊领导力准则之好奇求知与赢得信任

│ │ │ ├─028-亚马逊领导力准则之刨根问底与达成业绩

│ │ │ ├─029-智能音箱的战斗：亚马逊的硬件路

│ │ │ ├─030-智能音箱的战斗：Echo攻城略地

│ │ │ ├─031-智能音箱的战斗：语音助手Alexa

│ │ │ ├─032-智能音箱的战斗：谷歌的杀入

│ │ │ ├─033-智能音箱的战斗：亚马逊的战略布局

│ │ │ ├─034-智能音箱的战斗：巨头纷纷入场

│ │ │ ├─035-智能音箱的战斗：白马非马

│ │ │ ├─036-如何透过一个领域去联合分析多家企业？

│ │ │ ├─037-管中窥豹之从面试看企业文化：微软

│ │ │ ├─038-管中窥豹之从面试看企业文化：亚马逊

│ │ │ ├─039-管中窥豹之从面试看企业文化：谷歌

│ │ │ ├─040-管中窥豹之从面试看企业文化：甲骨文

│ │ │ ├─041-管中窥豹之从面试看企业文化：Facebook

│ │ │ ├─042-透过企业用人之道看企业发展

│ │ │ ├─043-办公软件的战斗：开篇

│ │ │ ├─044-VisiCalc：第一个电子表格软件的诞生

│ │ │ ├─045-WordStar：第一个字处理软件的故事

│ │ │ ├─046-微软：办公软件战场的螳螂

│ │ │ ├─047-WordPerfect：字处理软件的新秀

│ │ │ ├─048-Lotus1-2-3：莲花公司的电子表格帝国

│ │ │ ├─049-红狮会战：微软的反击

│ │ │ ├─050-大杀器LotusNotes和被收购的莲花公司

│ │ │ ├─051-无敌寂寞的微软之为创新而创新

│ │ │ ├─052-办公软件的新时代：微软和谷歌的战斗

│ │ │ ├─053-异军突起的Slack

│ │ │ ├─054-办公软件战斗的启示：内忧总是强于外患

│ │ │ ├─055-办公软件战斗的启示：敌人的出现常常出其不意

│ │ │ ├─056-半条命的Dota帝国Valve：半条命

│ │ │ ├─057-半条命的Dota帝国Valve：Steam平台

│ │ │ ├─058-半条命的Dota帝国Valve：Dota2

│ │ │ ├─059-半条命的Dota帝国Valve：无领导管理

│ │ │ ├─060-半条命的Dota帝国Valve：虚拟现实

│ │ │ ├─061-GabeNewell：Valve帝国制度的利弊

│ │ │ ├─062-文档数据库的缔造者MongoDB（上）

│ │ │ ├─063-文档数据库的缔造者MongoDB（下）

│ │ │ ├─064-以MongoDB为例，看基础架构类产品创业

│ │ │ ├─065-直面MongoDB，谈微软的NoSQL战略

│ │ │ ├─066-Hadoop三国之魏国Cloudera

│ │ │ ├─067-Hadoop三国之吴国MapR

│ │ │ ├─068-Hadoop三国之蜀国Hortonworks

│ │ │ ├─069-Hadoop及其发行商的未来

│ │ │ ├─070-谷歌的大数据路：从“三驾马车”到一无所有

│ │ │ ├─071-谷歌的大数据路：一场影响深远的论战

│ │ │ ├─072-谷歌的大数据路：谷歌的“黑科技”

│ │ │ ├─073-如何读懂类似谷歌“三驾马车”这样的技术论文？

│ │ │ ├─074-雅虎：大数据领域的“活雷锋”

│ │ │ ├─075-IBM的大数据路之起早贪黑赶了晚集

│ │ │ ├─076-社交公司们的大数据贡献

│ │ │ ├─077-微软的大数据发展史：微软硅谷研究院

│ │ │ ├─078-微软的大数据发展史：必应的Cosmos

│ │ │ ├─079-微软的大数据发展史：Azure的大数据发展

│ │ │ ├─080-亚马逊的大数据故事：从先驱者到插管吸血开源

│ │ │ ├─081-亚马逊的大数据故事：创新和拿来并存的云服务

│ │ │ ├─082-阿里巴巴的大数据故事：数据分析平台发展史

│ │ │ ├─083-阿里巴巴的大数据故事：流计算引擎发展史

│ │ │ ├─084-大公司的大数据战略得失：自建轮子成本高

│ │ │ ├─085-大公司的大数据战略得失：抱团取暖难敌插管吸血者

│ │ │ ├─086-Palantir：神秘的大数据独角兽

│ │ │ ├─087-Splunk：机器大数据的分析帝国

│ │ │ ├─088-Confluent：在Kafka上飞驰的数据交换者

│ │ │ ├─089-Powerset：HBase的老东家

│ │ │ ├─090-Cassandra和DataStax的故事

│ │ │ ├─091-Databricks之Spark的数据金砖王国

│ │ │ ├─092-DataArtisans：浴火重生的新一代大数据计算引擎Flink

│ │ │ ├─093-Dremio-在Drill和Arrow上的大数据公司

│ │ │ ├─094-Imply：基于Druid的大数据分析公司

│ │ │ ├─095-Kyligence：阿帕奇麒麟背后的大数据公司

│ │ │ ├─096-Snowflake-云端的弹性数据仓库

│ │ │ ├─097-TiDB：一个国产新数据库的创业故事

│ │ │ ├─098-大数据创业公司的前景：红海创业多艰辛

│ │ │ ├─099-如何通过企业技术积累去分析一家企业？

│ │ │ ├─100-仁科：被迫再创业的DavidDuffield

│ │ │ ├─101-仁科：飞跃发展的企业级软件帝国

│ │ │ ├─102-仁科：收购和被收购

│ │ │ ├─103-仁科的成与败

│ │ │ ├─104-WorkDay：杜菲尔德复仇记

│ │ │ ├─105-DavidDuffield的眼界和成败

│ │ │ ├─106-分析企业的两要素：远见和执行力

│ │ │ ├─107-Zenefits：一个卖保险的创业公司

│ │ │ ├─108-Glassdoor：让公司信息对个人透明

│ │ │ ├─109-从巴顿的创业史看巴顿

│ │ │ ├─110-免费还是收费？WinRAR的生意经

│ │ │ ├─111-周鸿祎和BAT的沉浮录（上）

│ │ │ ├─112-周鸿祎和BAT的沉浮录（中）

│ │ │ ├─113-周鸿祎和BAT的沉浮录（下）

│ │ │ ├─114-周鸿祎和BAT的沉浮录（后记）

│ │ │ ├─115-互联网第一股雅虎的兴衰：霸主的诞生

│ │ │ ├─116-互联网第一股雅虎的兴衰：运气不敌技术

│ │ │ ├─117-互联网第一股雅虎的兴衰：没有救世主

│ │ │ ├─118-成也杨致远，败也杨致远

│ │ │ ├─119-企业因人成事，领导人很重要

│ │ │ ├─120-彼得·蒂尔的投资人生

│ │ │ ├─121-商业之外的彼得·蒂尔

│ │ │ ├─122-创业的智慧：从彼得·蒂尔的创投哲学说起

│ │ │ ├─123-谷歌的创新精神：好的、坏的和丑陋的（上）

│ │ │ ├─124-谷歌的创新精神：好的、坏的和丑陋的（下）

│ │ │ ├─125-Facebook的黑客精神

│ │ │ ├─126-Twitter：蓝色小鸟还能飞多久（上）

│ │ │ ├─127-Twitter：蓝色小鸟还能飞多久（下）

│ │ │ ├─128-赚钱是根本，换CEO也没救

│ │ │ ├─129-Square：手机POS机和比特币交易

│ │ │ ├─130-创意很重要，但不是一切

│ │ │ ├─131-杰克·多西：分身有术之兼任两家上市公司CEO

│ │ │ ├─132-Groupon：团购鼻祖的兴衰

│ │ │ ├─133-卖掉自己是不是更好

│ │ │ ├─134-企业在线存储Box

│ │ │ ├─135-个人在线存储Dropbox

│ │ │ ├─136-做产品先做消费者市场，还是先做企业市场

│ │ │ ├─137-今天我们都来Pin图片之Pinterest的图片社交路

│ │ │ ├─138-企业不上市为哪般

│ │ │ ├─139-微软的综合工程师改革

│ │ │ ├─140-SaaS先驱Salesforce

│ │ │ ├─141-太超前好不好

│ │ │ ├─142-Sun：太阳的升起

│ │ │ ├─143-Sun：太阳的陨落

│ │ │ ├─144-看错敌人多可怕

│ │ │ ├─145-SAP的HANA战略（上）

│ │ │ ├─146-SAP的HANA战略（下）

│ │ │ ├─147-成功的忽悠+成功的执行=成功的产品

│ │ │ ├─148-SQLServer发展史

│ │ │ ├─149-眼光决定一切

│ │ │ ├─150-Ashton-Tate：桌面数据库王者的兴衰

│ │ │ ├─151-无敌不可以肆意妄为

│ │ │ ├─152-Reddit：天涯论坛美国版

│ │ │ ├─153-HackerNews：创业社交两不误

│ │ │ ├─154-YCombinator：孵化器还是培训班？

│ │ │ ├─155-创业公司进孵化器真的值得吗？

│ │ │ ├─156-PaulGraham：硅谷创业教父

│ │ │ ├─157-Zynga：发家从农场开始

│ │ │ ├─158-论Zynga的倒台

│ │ │ ├─159-企业分析要求综合素质

│ │ │ ├─一键直达-系列解读文章回顾

│ │ │ ├─开篇词-突破技术思维，站在商业的角度看问题

│ │ │ ├─新书首发丨《大数据浪潮之巅》

│ │ │ ├─结束语-积跬步，而终至千里

│ │ │ └─结课测试-这些技术与商业的知识你都掌握了吗？

│ │ ├─002-AI技术内参

│ │ │ ├─001-聊聊2017年KDD大会的时间检验奖

│ │ │ ├─002-AI技术内参

│ │ │ ├─002-精读2017年KDD最佳研究论文

│ │ │ ├─003-精读2017年KDD最佳应用数据科学论文

│ │ │ ├─004-精读2017年EMNLP最佳长论文之一

│ │ │ ├─005-精读2017年EMNLP最佳长论文之二

│ │ │ ├─006-精读2017年EMNLP最佳短论文

│ │ │ ├─007-精读2017年ICCV最佳研究论文

│ │ │ ├─008-精读2017年ICCV最佳学生论文

│ │ │ ├─009-如何将“深度强化学习”应用到视觉问答系统？

│ │ │ ├─010-精读2017年NIPS最佳研究论文之一：如何解决非凸优化问题？

│ │ │ ├─011-精读2017年NIPS最佳研究论文之二：KSD测试如何检验两个分布的异同？

│ │ │ ├─012-精读2017年NIPS最佳研究论文之三：如何解决非完美信息博弈问题？

│ │ │ ├─013-WSDM2018论文精读：看谷歌团队如何做位置偏差估计

│ │ │ ├─014-WSDM2018论文精读：看京东团队如何挖掘商品的替代信息和互补信息

│ │ │ ├─015-WSDM2018论文精读：深度学习模型中如何使用上下文信息？

│ │ │ ├─016-TheWeb2018论文精读：如何对商品的图片美感进行建模？

│ │ │ ├─017-TheWeb2018论文精读：如何改进经典的推荐算法BPR？

│ │ │ ├─018-TheWeb2018论文精读：如何从文本中提取高元关系？

│ │ │ ├─019-SIGIR2018论文精读：偏差和“流行度”之间的关系

│ │ │ ├─020-SIGIR2018论文精读：如何利用对抗学习来增强排序模型的普适性？

│ │ │ ├─021-SIGIR2018论文精读：如何对搜索页面上的点击行为进行序列建模？

│ │ │ ├─022-CVPR2018论文精读：如何研究计算机视觉任务之间的关系？

│ │ │ ├─023-CVPR2018论文精读：如何从整体上对人体进行三维建模？

│ │ │ ├─024-CVPR2018论文精读：如何解决排序学习计算复杂度高这个问题？

│ │ │ ├─025-ICML2018论文精读：模型经得起对抗样本的攻击？这或许只是个错觉

│ │ │ ├─026-ICML2018论文精读：聊一聊机器学习算法的“公平性”问题

│ │ │ ├─027-ICML2018论文精读：优化目标函数的时候，有可能放大了“不公平”？

│ │ │ ├─028-ACL2018论文精读：问答系统场景下，如何提出好问题？

│ │ │ ├─029-ACL2018论文精读：什么是对话中的前提触发？如何检测？

│ │ │ ├─030-ACL2018论文精读：什么是“端到端”的语义哈希？

│ │ │ ├─031-经典搜索核心算法：TF-IDF及其变种

│ │ │ ├─032-经典搜索核心算法：BM25及其变种（内附全年目录）

│ │ │ ├─033-经典搜索核心算法：语言模型及其变种

│ │ │ ├─034-机器学习排序算法：单点法排序学习

│ │ │ ├─035-机器学习排序算法：配对法排序学习

│ │ │ ├─036-机器学习排序算法：列表法排序学习

│ │ │ ├─037-“查询关键字理解”三部曲之分类

│ │ │ ├─038-“查询关键字理解”三部曲之解析

│ │ │ ├─039-“查询关键字理解”三部曲之扩展

│ │ │ ├─040-搜索系统评测，有哪些基础指标？

│ │ │ ├─041-搜索系统评测，有哪些高级指标？

│ │ │ ├─042-如何评测搜索系统的在线表现？

│ │ │ ├─043-文档理解第一步：文档分类

│ │ │ ├─044-文档理解的关键步骤：文档聚类

│ │ │ ├─045-文档理解的重要特例：多模文档建模

│ │ │ ├─046-大型搜索框架宏观视角：发展、特点及趋势

│ │ │ ├─047-多轮打分系统概述

│ │ │ ├─048-搜索索引及其相关技术概述

│ │ │ ├─049-PageRank算法的核心思想是什么？

│ │ │ ├─050-经典图算法之HITS

│ │ │ ├─051-社区检测算法之“模块最大化”

│ │ │ ├─052-机器学习排序算法经典模型：RankSVM

│ │ │ ├─053-机器学习排序算法经典模型：GBDT

│ │ │ ├─054-机器学习排序算法经典模型：LambdaMART

│ │ │ ├─055-基于深度学习的搜索算法：深度结构化语义模型

│ │ │ ├─056-基于深度学习的搜索算法：卷积结构下的隐含语义模型

│ │ │ ├─057-基于深度学习的搜索算法：局部和分布表征下的搜索模型

│ │ │ ├─058-简单推荐模型之一：基于流行度的推荐模型

│ │ │ ├─059-简单推荐模型之二：基于相似信息的推荐模型

│ │ │ ├─060-简单推荐模型之三：基于内容信息的推荐模型

│ │ │ ├─061-基于隐变量的模型之一：矩阵分解

│ │ │ ├─062-基于隐变量的模型之二：基于回归的矩阵分解

│ │ │ ├─063-基于隐变量的模型之三：分解机

│ │ │ ├─064-高级推荐模型之一：张量分解模型

│ │ │ ├─065-高级推荐模型之二：协同矩阵分解

│ │ │ ├─066-高级推荐模型之三：优化复杂目标函数

│ │ │ ├─067-推荐的Exploit和Explore算法之一：EE算法综述

│ │ │ ├─068-推荐的Exploit和Explore算法之二：UCB算法

│ │ │ ├─069-推荐的Exploit和Explore算法之三：汤普森采样算法

│ │ │ ├─070-推荐系统评测之一：传统线下评测

│ │ │ ├─071-推荐系统评测之二：线上评测

│ │ │ ├─072-推荐系统评测之三：无偏差估计

│ │ │ ├─073-现代推荐架构剖析之一：基于线下离线计算的推荐架构

│ │ │ ├─074-现代推荐架构剖析之二：基于多层搜索架构的推荐系统

│ │ │ ├─075-现代推荐架构剖析之三：复杂现代推荐架构漫谈

│ │ │ ├─076-基于深度学习的推荐模型之一：受限波兹曼机

│ │ │ ├─077-基于深度学习的推荐模型之二：基于RNN的推荐系统

│ │ │ ├─078-基于深度学习的推荐模型之三：利用深度学习来扩展推荐系统

│ │ │ ├─079-广告系统概述

│ │ │ ├─080-广告系统架构

│ │ │ ├─081-广告回馈预估综述

│ │ │ ├─082-Google的点击率系统模型

│ │ │ ├─083-Facebook的广告点击率预估模型

│ │ │ ├─084-雅虎的广告点击率预估模型

│ │ │ ├─085-LinkedIn的广告点击率预估模型

│ │ │ ├─086-Twitter的广告点击率预估模型

│ │ │ ├─087-阿里巴巴的广告点击率预估模型

│ │ │ ├─088-什么是“基于第二价位的广告竞拍”？

│ │ │ ├─089-广告的竞价策略是怎样的？

│ │ │ ├─090-如何优化广告的竞价策略？

│ │ │ ├─091-如何控制广告预算？

│ │ │ ├─092-如何设置广告竞价的底价？

│ │ │ ├─093-聊一聊“程序化直接购买”和“广告期货”

│ │ │ ├─094-归因模型：如何来衡量广告的有效性

│ │ │ ├─095-广告投放如何选择受众？如何扩展受众群？

│ │ │ ├─096-如何利用机器学习技术来检测广告欺诈？

│ │ │ ├─097-LDA模型的前世今生

│ │ │ ├─098-LDA变种模型知多少

│ │ │ ├─099-针对大规模数据，如何优化LDA算法？

│ │ │ ├─100-基础文本分析模型之一：隐语义分析

│ │ │ ├─101-基础文本分析模型之二：概率隐语义分析

│ │ │ ├─102-基础文本分析模型之三：EM算法

│ │ │ ├─103-为什么需要Word2Vec算法？

│ │ │ ├─104-Word2Vec算法有哪些扩展模型？

│ │ │ ├─105-Word2Vec算法有哪些应用？

│ │ │ ├─106-序列建模的深度学习利器：RNN基础架构

│ │ │ ├─107-基于门机制的RNN架构：LSTM与GRU

│ │ │ ├─108-RNN在自然语言处理中有哪些应用场景？

│ │ │ ├─109-对话系统之经典的对话模型

│ │ │ ├─110-任务型对话系统有哪些技术要点？

│ │ │ ├─111-聊天机器人有哪些核心技术要点？

│ │ │ ├─112-什么是文档情感分类？

│ │ │ ├─113-如何来提取情感“实体”和“方面”呢？

│ │ │ ├─114-文本情感分析中如何做意见总结和搜索？

│ │ │ ├─115-什么是计算机视觉？

│ │ │ ├─116-掌握计算机视觉任务的基础模型和操作

│ │ │ ├─117-计算机视觉中的特征提取难在哪里？

│ │ │ ├─118-基于深度学习的计算机视觉技术（一）：深度神经网络入门

│ │ │ ├─119-基于深度学习的计算机视觉技术（二）：基本的深度学习模型

│ │ │ ├─120-基于深度学习的计算机视觉技术（三）：深度学习模型的优化

│ │ │ ├─121-计算机视觉领域的深度学习模型（一）：AlexNet

│ │ │ ├─122-计算机视觉领域的深度学习模型（二）：VGG&GoogleNet

│ │ │ ├─123-计算机视觉领域的深度学习模型（三）：ResNet

│ │ │ ├─124-计算机视觉高级话题（一）：图像物体识别和分割

│ │ │ ├─125-计算机视觉高级话题（二）：视觉问答

│ │ │ ├─126-计算机视觉高级话题（三）：产生式模型

│ │ │ ├─127-数据科学家基础能力之概率统计

│ │ │ ├─128-数据科学家基础能力之机器学习

│ │ │ ├─129-数据科学家基础能力之系统

│ │ │ ├─130-数据科学家高阶能力之分析产品

│ │ │ ├─131-数据科学家高阶能力之评估产品

│ │ │ ├─132-数据科学家高阶能力之如何系统提升产品性能

│ │ │ ├─133-职场话题：当数据科学家遇见产品团队

│ │ │ ├─134-职场话题：数据科学家应聘要具备哪些能力？

│ │ │ ├─135-职场话题：聊聊数据科学家的职场规划

│ │ │ ├─136-如何组建一个数据科学团队？

│ │ │ ├─137-数据科学团队养成：电话面试指南

│ │ │ ├─138-数据科学团队养成：Onsite面试面面观

│ │ │ ├─139-成为“香饽饽”的数据科学家，如何衡量他们的工作呢？

│ │ │ ├─140-人工智能领域知识体系更新周期只有5～6年，数据科学家如何培养？

│ │ │ ├─141-数据科学家团队组织架构：水平还是垂直，这是个问题

│ │ │ ├─142-数据科学家必备套路之一：搜索套路

│ │ │ ├─143-数据科学家必备套路之二：推荐套路

│ │ │ ├─144-数据科学家必备套路之三：广告套路

│ │ │ ├─145-如何做好人工智能项目的管理？

│ │ │ ├─146-数据科学团队必备的工程流程三部曲

│ │ │ ├─147-数据科学团队怎么选择产品和项目？

│ │ │ ├─148-曾经辉煌的雅虎研究院

│ │ │ ├─149-微软研究院：工业界研究机构的楷模

│ │ │ ├─150-聊一聊谷歌特立独行的混合型研究

│ │ │ ├─151-精读AlphaGoZero论文

│ │ │ ├─152-2017人工智能技术发展盘点

│ │ │ ├─153-如何快速学习国际顶级学术会议的内容？

│ │ │ ├─154-在人工智能领域，如何快速找到学习的切入点？

│ │ │ ├─155-人工智能技术选择，该从哪里获得灵感？

│ │ │ ├─156-近在咫尺，走进人工智能研究

│ │ │ ├─内参特刊-和你聊聊每个人都关心的人工智能热点话题

│ │ │ ├─复盘1-搜索核心技术模块

│ │ │ ├─复盘2-推荐系统核心技术模块

│ │ │ ├─复盘3-自然语言处理及文本处理核心技术模块

│ │ │ ├─复盘4-广告系统核心技术模块

│ │ │ ├─复盘5-计算机视觉核心技术模块

│ │ │ ├─复盘6-数据科学家与数据科学团队是怎么养成的？

│ │ │ ├─复盘7-一起来读人工智能国际顶级会议论文

│ │ │ ├─开篇词-你的360度人工智能信息助理

│ │ │ ├─结束语-雄关漫道真如铁，而今迈步从头越

│ │ │ └─结束语-雄关漫道真如铁，而今迈步从头越

│ │ ├─003-左耳听风

│ │ │ ├─003-左耳听风

│ │ │ ├─01-程序员如何用技术变现（上）

│ │ │ ├─02-程序员如何用技术变现（下）

│ │ │ ├─03-Equifax信息泄露始末

│ │ │ ├─04-从Equifax信息泄露看数据安全

│ │ │ ├─05-何为技术领导力？

│ │ │ ├─06-如何才能拥有技术领导力？

│ │ │ ├─07-推荐阅读：每个程序员都该知道的知识

│ │ │ ├─08-Go语言，Docker和新技术

│ │ │ ├─09-答疑解惑：渴望、热情和选择

│ │ │ ├─10-如何成为一个大家愿意追随的Leader？

│ │ │ ├─100-高效学习：面对枯燥和量大的知识

│ │ │ ├─101-高效沟通：Talk和Code同等重要

│ │ │ ├─102-高效沟通：沟通阻碍和应对方法

│ │ │ ├─103-高效沟通：沟通方式及技巧

│ │ │ ├─104-高效沟通：沟通技术

│ │ │ ├─105-高效沟通：好老板要善于提问

│ │ │ ├─106-高效沟通：好好说话的艺术

│ │ │ ├─107-Go编程模式：切片、接口、时间和性能

│ │ │ ├─108-Go编程模式：错误处理

│ │ │ ├─109-Go编程模式：FunctionalOptions

│ │ │ ├─11-程序中的错误处理：错误返回码和异常捕捉

│ │ │ ├─110-Go编程模式：委托和反转控制

│ │ │ ├─111-Go编程模式：Map-Reduce

│ │ │ ├─112-Go编程模式：GoGeneration

│ │ │ ├─113-Go编程模式：修饰器

│ │ │ ├─114-Go编程模式：Pipeline

│ │ │ ├─115-Go编程模式：KubernetesVisitor模式

│ │ │ ├─12-程序中的错误处理：异步编程以及我的最佳实践

│ │ │ ├─13-魔数0x5f3759df

│ │ │ ├─14-推荐阅读：机器学习101

│ │ │ ├─15-时间管理：同扭曲时间的事儿抗争

│ │ │ ├─16-时间管理：如何利用好自己的时间？

│ │ │ ├─17-故障处理最佳实践：应对故障

│ │ │ ├─18-故障处理最佳实践：故障改进

│ │ │ ├─19-答疑解惑：我们应该能够识别的表象和本质

│ │ │ ├─20-Git协同工作流，你该怎么选？

│ │ │ ├─21-分布式系统架构的冰与火

│ │ │ ├─22-从亚马逊的实践，谈分布式系统的难点

│ │ │ ├─23-分布式系统的技术栈

│ │ │ ├─24-分布式系统关键技术：全栈监控

│ │ │ ├─25-分布式系统关键技术：服务调度

│ │ │ ├─26-分布式系统关键技术：流量与数据调度

│ │ │ ├─27-洞悉PaaS平台的本质

│ │ │ ├─28-推荐阅读：分布式系统架构经典资料

│ │ │ ├─29-推荐阅读：分布式数据调度相关论文

│ │ │ ├─30-编程范式游记（1）-起源

│ │ │ ├─31-编程范式游记（2）-泛型编程

│ │ │ ├─32-编程范式游记（3）-类型系统和泛型的本质

│ │ │ ├─33-编程范式游记（4）-函数式编程

│ │ │ ├─34-编程范式游记（5）-修饰器模式

│ │ │ ├─35-编程范式游记（6）-面向对象编程

│ │ │ ├─36-编程范式游记（7）-基于原型的编程范式

│ │ │ ├─37-编程范式游记（8）-Go语言的委托模式

│ │ │ ├─38-编程范式游记（9）-编程的本质

│ │ │ ├─39-编程范式游记（10）-逻辑编程范式

│ │ │ ├─40-编程范式游记（11）-程序世界里的编程范式

│ │ │ ├─41-弹力设计篇之“认识故障和弹力设计”

│ │ │ ├─42-弹力设计篇之“隔离设计”

│ │ │ ├─43-弹力设计篇之“异步通讯设计”

│ │ │ ├─44-弹力设计篇之“幂等性设计”

│ │ │ ├─45-弹力设计篇之“服务的状态”

│ │ │ ├─46-弹力设计篇之“补偿事务”

│ │ │ ├─47-弹力设计篇之“重试设计”

│ │ │ ├─48-弹力设计篇之“熔断设计”

│ │ │ ├─49-弹力设计篇之“限流设计”

│ │ │ ├─50-弹力设计篇之“降级设计”

│ │ │ ├─51-弹力设计篇之“弹力设计总结”

│ │ │ ├─52-管理设计篇之“分布式锁”

│ │ │ ├─53-管理设计篇之“配置中心”

│ │ │ ├─54-管理设计篇之“边车模式”

│ │ │ ├─55-管理设计篇之“服务网格”

│ │ │ ├─56-管理设计篇之“网关模式”

│ │ │ ├─57-管理设计篇之“部署升级策略”

│ │ │ ├─58-性能设计篇之“缓存”

│ │ │ ├─59-性能设计篇之“异步处理”

│ │ │ ├─60-性能设计篇之“数据库扩展”

│ │ │ ├─61-性能设计篇之“秒杀”

│ │ │ ├─62-性能设计篇之“边缘计算”

│ │ │ ├─63-区块链技术的本质

│ │ │ ├─64-区块链技术细节：哈希算法(1)

│ │ │ ├─64-区块链技术细节：哈希算法

│ │ │ ├─65-区块链技术细节：加密和挖矿

│ │ │ ├─66-区块链技术细节：去中心化的共识机制

│ │ │ ├─67-区块链技术细节：智能合约

│ │ │ ├─68-区块链技术-传统金融和虚拟货币

│ │ │ ├─69-程序员练级攻略：开篇词

│ │ │ ├─70-程序员练级攻略：零基础启蒙

│ │ │ ├─71-程序员练级攻略：正式入门

│ │ │ ├─72-程序员练级攻略：程序员修养

│ │ │ ├─73-程序员练级攻略：编程语言

│ │ │ ├─74-程序员练级攻略：理论学科

│ │ │ ├─75-程序员练级攻略：系统知识

│ │ │ ├─76-程序员练级攻略：软件设计

│ │ │ ├─77-程序员练级攻略：Linux系统、内存和网络

│ │ │ ├─78-程序员练级攻略：异步I-O模型和Lock-Free编程

│ │ │ ├─79-程序员练级攻略：Java底层知识

│ │ │ ├─80-程序员练级攻略：数据库

│ │ │ ├─81-程序员练级攻略：分布式架构入门

│ │ │ ├─82-程序员练级攻略：分布式架构经典图书和论文

│ │ │ ├─83-程序员练级攻略：分布式架构工程设计

│ │ │ ├─84-程序员练级攻略：微服务

│ │ │ ├─85-程序员练级攻略：容器化和自动化运维

│ │ │ ├─86-程序员练级攻略：机器学习和人工智能

│ │ │ ├─87-程序员练级攻略：前端基础和底层原理

│ │ │ ├─88-程序员练级攻略：前端性能优化和框架

│ │ │ ├─89-程序员练级攻略：UI-UX设计

│ │ │ ├─90-程序员练级攻略：技术资源集散地

│ │ │ ├─91-程序员练级攻略的正确打开方式

│ │ │ ├─92-程序员面试攻略：面试前的准备

│ │ │ ├─93-程序员面试攻略：面试中的技巧

│ │ │ ├─94-程序员面试攻略：面试风格

│ │ │ ├─95-程序员面试攻略：实力才是王中王

│ │ │ ├─96-高效学习：端正学习态度

│ │ │ ├─97-高效学习：源头、原理和知识地图

│ │ │ ├─98-高效学习：深度，归纳和坚持实践

│ │ │ ├─99-高效学习：如何学习和阅读代码

│ │ │ ├─加餐-谈谈我的“三观”

│ │ │ ├─开篇词-洞悉技术的本质，享受科技的乐趣

│ │ │ ├─结束语-业精于勤，行成于思

│ │ │ ├─课程迭代｜全新交付117讲音频

│ │ │ └─课程迭代｜全新交付117讲音频

│ │ ├─004-朱赟的技术管理课

│ │ │ ├─004-朱赟的技术管理课

│ │ │ ├─01-职场分身术：从给答案到做引导

│ │ │ ├─02-Bug引发事故，该不该追究责任？

│ │ │ ├─03-每个工程师都应该了解的：A-B测试

│ │ │ ├─04-如何帮助团队成员成长

│ │ │ ├─05-当我们给别人提意见时，要注意些什么？

│ │ │ ├─06-每个工程师都应该了解的：聊聊幂等

│ │ │ ├─07-当别人给我们提意见时，该如何应对？

│ │ │ ├─08-说说硅谷公司中的一对一沟通

│ │ │ ├─09-每个工程师都应该了解的：大数据时代的算法

│ │ │ ├─10-项目延期了，作为负责人该怎么办？

│ │ │ ├─11-管理和被管理：期望值差异

│ │ │ ├─12-每个工程师都应该了解的：数据库知识

│ │ │ ├─13-管理者在进行工作分配时，会考虑哪些问题？

│ │ │ ├─14-硅谷人到底忙不忙？

│ │ │ ├─15-每个工程师都应该了解的：系统拆分

│ │ │ ├─16-技术人如何建立个人影响力

│ │ │ ├─17-管理者不用亲力亲为：关键是什么？

│ │ │ ├─18-每个工程师都应该了解的：API的设计和实现

│ │ │ ├─19-硅谷面试：那些你应该知道的事儿

│ │ │ ├─20-项目管理中的三个技巧

│ │ │ ├─21-每个工程师都应该了解的：中美在支付技术和大环境下的差异

│ │ │ ├─22-不要做微观的管理者

│ │ │ ├─23-如何处理工作中的人际关系？

│ │ │ ├─24-编程语言漫谈

│ │ │ ├─25-兼容并包的领导方式

│ │ │ ├─26-如何做自己的职场规划？

│ │ │ ├─27-小议Java语言

│ │ │ ├─28-如何激发团队人员的责任心

│ │ │ ├─29-说说硅谷互联网公司的开发流程

│ │ │ ├─30-编程马拉松

│ │ │ ├─31-工程师、产品经理、数据工程师是如何一起工作的？

│ │ │ ├─32-硅谷人如何做CodeReview

│ │ │ ├─33-技术人的犯错成本

│ │ │ ├─34-如何从错误中成长？

│ │ │ ├─35-理解并建立自己的工作弹性

│ │ │ ├─36-如何对更多的工作说“不”

│ │ │ ├─尾声：成长不是顿悟，而是练习

│ │ │ ├─开篇词-从工程师到管理者，我的思考与实践

│ │ │ ├─新书-《跃迁：从技术到管理的硅谷路径》

│ │ │ └─新书-《跃迁：从技术到管理的硅谷路径》

│ │ ├─005-邱岳的产品手记

│ │ │ ├─005-邱岳的产品手记

│ │ │ ├─01-验证码是个好设计吗？

│ │ │ ├─02-产品经理工具指南

│ │ │ ├─03-产品案例分析·Trigraphy的设计哲学

│ │ │ ├─04-如何当好AI时代的产品经理？（学习篇）

│ │ │ ├─05-如何当好AI时代的产品经理？（实践篇）

│ │ │ ├─06-产品案例分析·TheGuardian的文本之美

│ │ │ ├─07-关于需求变更（上）：需求背后的需求

│ │ │ ├─08-关于需求变更（下）-化变更于无形

│ │ │ ├─09-产品案例分析：Hopper的“人工智能”

│ │ │ ├─10-产品被抄袭了，怎么办？

│ │ │ ├─11-如何借鉴灵感？

│ │ │ ├─12-产品案例分析：LabRdr的设计实验

│ │ │ ├─13-无用却必要：产品规划（上）

│ │ │ ├─14-留白与节奏：产品规划（下）

│ │ │ ├─15-产品案例分析：Mimo与LearnPython的导学之趣

│ │ │ ├─16-在内部产品中找到产品经理的价值

│ │ │ ├─17-产品经理如何获得非权力性的影响力？

│ │ │ ├─18-产品案例分析：WWFTogether的情怀设计

│ │ │ ├─19-产品经理如何与开发打交道（上）：打破思维的边界

│ │ │ ├─20-产品经理如何与开发打交道（下）：合作与共赢

│ │ │ ├─21-产品案例分析：Fabulous的精致养成

│ │ │ ├─22-产品经理的图文基本功（上）：产品文档

│ │ │ ├─23-产品经理的图文基本功（下）：产品图例

│ │ │ ├─24-产品案例分析：PathSource的混乱与直观

│ │ │ ├─25-产品世界的暗黑模式：操纵的诱惑

│ │ │ ├─26-写好产品文档的诀窍

│ │ │ ├─27-产品案例分析：Quartz&Hooked的对话式交互

│ │ │ ├─28-产品分析的套路（上）：谁是利益相关者？

│ │ │ ├─29-产品分析的套路（中）：解决什么问题？

│ │ │ ├─30-产品案例分析：Primer的扑克牌交互

│ │ │ ├─31-产品分析的套路（下）：如何出解决方案？

│ │ │ ├─32-从受众规模、需求频率和强度出发：排定需求优先级的方法（上）

│ │ │ ├─33-产品案例分析：Arts&Culture的架构之美

│ │ │ ├─34-价值曲线分析：排定需求优先级的方法（下）

│ │ │ ├─35-答疑时间：关于产品经理的12个问题

│ │ │ ├─36-产品案例分析：解读知识星球

│ │ │ ├─37-如何做好需求评审（上）：需求评审不只是一次会议

│ │ │ ├─38-如何做好需求评审（下）：在评审中控住全场

│ │ │ ├─39-产品案例分析：SeatGeek的订票设计

│ │ │ ├─40-新年给产品经理的几碗鸡汤

│ │ │ ├─41-产品经理的项目管理心得

│ │ │ ├─42-产品案例分析：Unread的阅读体验

│ │ │ ├─43-“玩”的力量：从游戏设计中学习产品设计（上）

│ │ │ ├─44-“玩”的启示：从游戏设计中学习产品设计（下）

│ │ │ ├─45-产品案例分析：Chartistic的“复杂”图表

│ │ │ ├─【第二季回归】二爷归来，再次扬帆起航

│ │ │ ├─尾声：你的快乐是哪一种

│ │ │ ├─开篇词-产品经理的世界没有对错

│ │ │ └─结课测试-关于产品的这些知识，你都掌握了吗？

│ │ ├─006-人工智能基础课

│ │ │ ├─006-人工智能基础课

│ │ │ ├─01数学基础-九层之台，起于累土：线性代数

│ │ │ ├─02数学基础-月有阴晴圆缺，此事古难全：概率论

│ │ │ ├─03数学基础-窥一斑而知全豹：数理统计

│ │ │ ├─04数学基础-不畏浮云遮望眼：最优化方法

│ │ │ ├─05数学基础-万物皆数，信息亦然：信息论

│ │ │ ├─06数学基础-明日黄花迹难寻：形式逻辑

│ │ │ ├─07机器学习-数山有路，学海无涯：机器学习概论

│ │ │ ├─08机器学习-简约而不简单：线性回归

│ │ │ ├─09机器学习-大道至简：朴素贝叶斯方法

│ │ │ ├─10机器学习-衍化至繁：逻辑回归

│ │ │ ├─11机器学习-步步为营，有章可循：决策树

│ │ │ ├─12机器学习-穷则变，变则通：支持向量机

│ │ │ ├─13机器学习-三个臭皮匠，赛过诸葛亮：集成学习

│ │ │ ├─14机器学习-物以类聚，人以群分：聚类分析

│ │ │ ├─15机器学习-好钢用在刀刃上：降维学习

│ │ │ ├─16人工神经网络-道法自然，久藏玄冥：神经网络的生理学背景

│ │ │ ├─17人工神经网络-一个青年才俊的意外死亡：神经元与感知器

│ │ │ ├─18人工神经网络-左手信号，右手误差：多层感知器

│ │ │ ├─19人工神经网络-各人自扫门前雪：径向基函数神经网络

│ │ │ ├─20人工神经网络-看不见的手：自组织特征映射

│ │ │ ├─21人工神经网络-水无至清，人莫至察：模糊神经网络

│ │ │ ├─22深度学习-空山鸣响，静水流深：深度学习概述

│ │ │ ├─23深度学习-前方有路，未来可期：深度前馈网络

│ │ │ ├─24深度学习-小树不修不直溜：深度学习中的正则化

│ │ │ ├─25深度学习-玉不琢不成器：深度学习中的优化

│ │ │ ├─26深度学习-空竹里的秘密：自编码器

│ │ │ ├─27深度学习-困知勉行者勇：深度强化学习

│ │ │ ├─28深度学习框架下的神经网络-枯木逢春：深度信念网络

│ │ │ ├─29深度学习框架下的神经网络-见微知著：卷积神经网络

│ │ │ ├─30深度学习框架下的神经网络-昨日重现：循环神经网络

│ │ │ ├─31深度学习框架下的神经网络-左右互搏：生成式对抗网络

│ │ │ ├─32深度学习框架下的神经网络-三重门：长短期记忆网络

│ │ │ ├─33深度学习之外的人工智能-一图胜千言：概率图模型

│ │ │ ├─34深度学习之外的人工智能-乌合之众的逆袭：集群智能

│ │ │ ├─35深度学习之外的人工智能-授人以鱼不如授人以渔：迁移学习

│ │ │ ├─36深度学习之外的人工智能-滴水藏海：知识图谱

│ │ │ ├─37应用场景-你是我的眼：计算机视觉

│ │ │ ├─38应用场景-嘿,Siri：语音处理

│ │ │ ├─39应用场景-心有灵犀一点通：对话系统

│ │ │ ├─40应用场景-数字巴别塔：机器翻译

│ │ │ ├─一键到达-人工神经网络复习课

│ │ │ ├─一键到达-应用场景复习课

│ │ │ ├─一键到达-数学基础复习课

│ │ │ ├─一键到达-机器学习复习课

│ │ │ ├─一键到达-深度学习之外的人工智能复习课

│ │ │ ├─一键到达-深度学习复习课

│ │ │ ├─一键到达-深度学习框架下的神经网络复习课

│ │ │ ├─开篇词-人工智能：新时代的必修课

│ │ │ ├─推荐阅读-我与人工智能的故事

│ │ │ ├─新书-《裂变：秒懂人工智能的基础课》

│ │ │ ├─直播回顾-机器学习必备的数学基础

│ │ │ ├─第2季回归-这次我们来聊聊机器学习

│ │ │ ├─结课-溯洄从之，道阻且长

│ │ │ ├─结课测试-这些人工智能的知识你都掌握了吗？

│ │ │ ├─课外谈-“人工智能基础课”之二三闲话

│ │ │ ├─（课外辅导）人工神经网络-拓展阅读参考书

│ │ │ ├─（课外辅导）数学基础-拓展阅读参考书

│ │ │ ├─（课外辅导）机器学习-拓展阅读参考书

│ │ │ └─（课外辅导）深度学习-拓展阅读参考书

│ │ ├─007-赵成的运维体系管理课

│ │ │ ├─007-赵成的运维体系管理课

│ │ │ ├─01-为什么Netflix没有运维岗位？

│ │ │ ├─02-微服务架构时代，运维体系建设为什么要以“应用”为核心？

│ │ │ ├─03-标准化体系建设（上）：如何建立应用标准化体系和模型？

│ │ │ ├─04-标准化体系建设（下）：如何建立基础架构标准化及服务化体系？

│ │ │ ├─05-如何从生命周期的视角看待应用运维体系建设？

│ │ │ ├─06-聊聊CMDB的前世今生

│ │ │ ├─07-有了CMDB，为什么还需要应用配置管理？

│ │ │ ├─08-如何在CMDB中落地应用的概念？

│ │ │ ├─09-如何打造运维组织架构？

│ │ │ ├─10-谷歌SRE运维模式解读

│ │ │ ├─11-从谷歌CRE谈起，运维如何培养服务意识？

│ │ │ ├─12-持续交付知易行难，想做成这事你要理解这几个关键点

│ │ │ ├─13-持续交付的第一关键点：配置管理

│ │ │ ├─14-如何做好持续交付中的多环境配置管理？

│ │ │ ├─15-开发和测试争抢环境？是时候进行多环境建设了

│ │ │ ├─16-线上环境建设，要扛得住真刀真枪的考验

│ │ │ ├─17-人多力量大vs

│ │ │ ├─18-持续交付流水线软件构建难吗？有哪些关键问题？

│ │ │ ├─19-持续交付中流水线构建完成后就大功告成了吗？别忘了质量保障

│ │ │ ├─20-做持续交付概念重要还是场景重要？看“笨办法”如何找到最佳方案

│ │ │ ├─21-极端业务场景下，我们应该如何做好稳定性保障？

│ │ │ ├─22-稳定性实践：容量规划之业务场景分析

│ │ │ ├─23-稳定性实践：容量规划之压测系统建设

│ │ │ ├─24-稳定性实践：限流降级

│ │ │ ├─25-稳定性实践：开关和预案

│ │ │ ├─26-稳定性实践：全链路跟踪系统，技术运营能力的体现

│ │ │ ├─27-故障管理：谈谈我对故障的理解

│ │ │ ├─28-故障管理：故障定级和定责

│ │ │ ├─29-故障管理：鼓励做事，而不是处罚错误

│ │ │ ├─30-故障管理：故障应急和故障复盘

│ │ │ ├─31-唇亡齿寒，运维与安全

│ │ │ ├─32-为什么蘑菇街会选择上云？是被动选择还是主动出击？

│ │ │ ├─33-为什么混合云是未来云计算的主流形态？

│ │ │ ├─34-SpringCloud：面向应用层的云架构解决方案

│ │ │ ├─35-以绝对优势立足：从CDN和云存储来聊聊云生态的崛起

│ │ │ ├─36-量体裁衣方得最优解：聊聊页面静态化架构和二级CDN建设

│ │ │ ├─37-云计算时代，我们所说的弹性伸缩，弹的到底是什么？

│ │ │ ├─38-我是如何走上运维岗位的？

│ │ │ ├─39-云计算和AI时代，运维应该如何做好转型？

│ │ │ ├─40-运维需要懂产品和运营吗？

│ │ │ ├─41-冷静下来想想，员工离职这事真能“防得住”吗？

│ │ │ ├─42-树立个人品牌意识：从背景调查谈谈职业口碑的重要性

│ │ │ ├─划重点：赵成的运维体系管理课精华（一）

│ │ │ ├─划重点：赵成的运维体系管理课精华（三）

│ │ │ ├─划重点：赵成的运维体系管理课精华（二）

│ │ │ ├─开篇词-带给你不一样的运维思考

│ │ │ ├─新书-《进化：运维技术变革与实践探索》

│ │ │ ├─特别放送｜我的2019：收获，静静等待

│ │ │ ├─结束语-学习的过程，多些耐心和脚踏实地

│ │ │ └─结束语-学习的过程，多些耐心和脚踏实地

│ │ ├─008-推荐系统三十六式

│ │ │ ├─008-推荐系统三十六式

│ │ │ ├─01-你真的需要个性化推荐系统吗

│ │ │ ├─02-个性化推荐系统有哪些绕不开的经典问题？

│ │ │ ├─03-这些你必须应该具备的思维模式

│ │ │ ├─04-画鬼容易画人难：用户画像的“能”和“不能”

│ │ │ ├─05-从文本到用户画像有多远

│ │ │ ├─06-超越标签的内容推荐系统

│ │ │ ├─07-人以群分，你是什么人就看到什么世界

│ │ │ ├─08-解密“看了又看”和“买了又买”

│ │ │ ├─09-协同过滤中的相似度计算方法有哪些

│ │ │ ├─10-那些在NetflixPrize中大放异彩的推荐算法

│ │ │ ├─11-Facebook是怎么为十亿人互相推荐好友的

│ │ │ ├─12-如果关注排序效果，那么这个模型可以帮到你

│ │ │ ├─13-经典模型融合办法：线性模型和树模型的组合拳

│ │ │ ├─14-一网打尽协同过滤、矩阵分解和线性模型

│ │ │ ├─15-深度和宽度兼具的融合模型WideandDeep

│ │ │ ├─16-简单却有效的Bandit算法

│ │ │ ├─17-结合上下文信息的Bandit算法

│ │ │ ├─18-如何将Bandit算法与协同过滤结合使用

│ │ │ ├─19-深度学习在推荐系统中的应用有哪些

│ │ │ ├─20-用RNN构建个性化音乐播单

│ │ │ ├─21-构建一个科学的排行榜体系

│ │ │ ├─22-实用的加权采样算法

│ │ │ ├─23-推荐候选池的去重策略

│ │ │ ├─24-典型的信息流架构是什么样的

│ │ │ ├─25-Netflix个性化推荐架构

│ │ │ ├─26-总览推荐架构和搜索、广告的关系

│ │ │ ├─27-巧妇难为无米之炊：数据采集关键要素

│ │ │ ├─28-让你的推荐系统反应更快：实时推荐

│ │ │ ├─29-让数据驱动落地，你需要一个实验平台

│ │ │ ├─30-推荐系统服务化、存储选型及API设计

│ │ │ ├─31-推荐系统的测试方法及常用指标介绍

│ │ │ ├─32-道高一尺魔高一丈：推荐系统的攻防

│ │ │ ├─33-和推荐系统有关的开源工具及框架介绍

│ │ │ ├─34-推荐系统在互联网产品商业链条中的地位

│ │ │ ├─35-说说信息流的前世今生

│ │ │ ├─36-组建推荐团队及工程师的学习路径

│ │ │ ├─加餐-推荐系统的参考阅读

│ │ │ ├─开篇词-用知识去对抗技术不平等

│ │ │ ├─结束语-遇“荐”之后，江湖再见

│ │ │ └─结课测试-推荐系统的这些知识，你都掌握了吗？

│ │ ├─009-深入浅出区块链

│ │ │ ├─009-深入浅出区块链

│ │ │ ├─尾声篇-授人以鱼，不如授人以渔

│ │ │ ├─开篇词-帮你从0到1深入学习区块链技术

│ │ │ ├─新书首发-《区块链第一课：深入浅出技术与应用》

│ │ │ ├─第10讲-深入区块链技术（二）：P2P网络

│ │ │ ├─第11讲-深入区块链技术（三）：共识算法与分布式一致性算法

│ │ │ ├─第12讲-深入区块链技术（四）：PoW共识

│ │ │ ├─第13讲-深入区块链技术（五）：PoS共识机制

│ │ │ ├─第14讲-深入区块链技术（六）：DPoS共识机制

│ │ │ ├─第15讲-深入区块链技术（七）：哈希与加密算法

│ │ │ ├─第16讲-深入区块链技术（八）：UTXO与普通账户模型

│ │ │ ├─第17讲-去中心化与区块链交易性能

│ │ │ ├─第18讲-智能合约与以太坊

│ │ │ ├─第19讲-上手搭建一条自己的智能合约

│ │ │ ├─第1讲-到底什么才是区块链？

│ │ │ ├─第20讲-区块链项目详解：比特股BTS

│ │ │ ├─第21讲-引人瞩目的区块链项目：EOS、IOTA、Cardano

│ │ │ ├─第22讲-国内区块链项目技术一览

│ │ │ ├─第23讲-联盟链和它的困境

│ │ │ ├─第24讲-比特币专题（一）历史与货币

│ │ │ ├─第25讲-比特币专题（二）：扩容之争、IFO与链上治理

│ │ │ ├─第26讲-数字货币和数字资产

│ │ │ ├─第27讲-弄懂数字货币交易平台（一）

│ │ │ ├─第28讲-弄懂数字货币交易平台（二）

│ │ │ ├─第29讲-互联网身份与区块链数字身份

│ │ │ ├─第2讲-区块链到底是怎么运行的？

│ │ │ ├─第30讲-区块链即服务BaaS

│ │ │ ├─第31讲-数字货币钱包服务

│ │ │ ├─第32讲-区块链与供应链（一）

│ │ │ ├─第33讲-区块链与供应链（二）

│ │ │ ├─第34讲-从业区块链需要了解什么？

│ │ │ ├─第35讲-搭建你的迷你区块链（设计篇）

│ │ │ ├─第36讲-搭建你的迷你区块链（实践篇）

│ │ │ ├─第3讲-浅说区块链共识机制

│ │ │ ├─第4讲-区块链的应用类型

│ │ │ ├─第5讲-如何理解数字货币？它与区块链又是什么样的关系？

│ │ │ ├─第6讲-理解区块链之前，先上手体验一把数字货币

│ │ │ ├─第7讲-区块链的常见误区

│ │ │ ├─第8讲-最主流区块链项目有哪些？

│ │ │ ├─第9讲-深入区块链技术（一）：技术基础

│ │ │ └─结课测试-“深入浅出区块链”100分试卷等你来挑战！

│ │ ├─010-技术领导力实战笔记

│ │ │ ├─010-技术领导力实战笔记

│ │ │ ├─大咖对话-万玉权：如何招到并培养核心人才

│ │ │ ├─大咖对话-万玉权：高效团队的关键，以目标为导向，用数据来说话

│ │ │ ├─大咖对话-不可替代的Java：生态与程序员是两道护城河

│ │ │ ├─大咖对话-从几个工程师到2000+个工程师的技术团队成长秘诀

│ │ │ ├─大咖对话-以产生价值判断工程师贡献——读者留言精选

│ │ │ ├─大咖对话-余沛：打造以最佳交付实践为目标的技术导向

│ │ │ ├─大咖对话-余沛：进阶CTO必备的素质与能力

│ │ │ ├─大咖对话-刘俊强：云计算时代技术管理者的应对之道

│ │ │ ├─大咖对话-刘俊强：谈谈我对2019年云计算趋势的看法

│ │ │ ├─大咖对话-创业就是把自己过去的经验快速的产品化

│ │ │ ├─大咖对话-如何打造自我驱动型的技术团队？

│ │ │ ├─大咖对话-如何高效管理8000+规模的技术团队

│ │ │ ├─大咖对话-季昕华：以不变的目的应对多变的技术浪潮

│ │ │ ├─大咖对话-对人才的长期投资是人才体系打造的根本

│ │ │ ├─大咖对话-张建锋：创业可以快而大，也可以小而美

│ │ │ ├─大咖对话-彭跃辉：保持高效迭代的团队是如何炼成的

│ │ │ ├─大咖对话-彭跃辉：解决用户痛点就是立足于市场的秘诀

│ │ │ ├─大咖对话-徐毅：如何提升员工的活力与动力？

│ │ │ ├─大咖对话-徐毅：打造高效研发团队的五个维度及相关实践

│ │ │ ├─大咖对话-技术人创业前衡量自我的3P3C模型

│ │ │ ├─大咖对话-技术人真正需要的是升维思考

│ │ │ ├─大咖对话-技术管理者应该向优秀的体育教练学习

│ │ │ ├─大咖对话-未来技术负责人与首席增长官将如何协作？

│ │ │ ├─大咖对话-李昊：创业公司如何做好技术团队绩效考核？

│ │ │ ├─大咖对话-李智慧：技术人如何应对“互联网寒冬”

│ │ │ ├─大咖对话-杨育斌：技术领导者要打造技术团队的最大化价值

│ │ │ ├─大咖对话-池建强：做产品不要执着于打造爆款

│ │ │ ├─大咖对话-焦烈焱：从四个维度更好的激发团队创造力

│ │ │ ├─大咖对话-玉攻：四个维度看小程序与App的区别

│ │ │ ├─大咖对话-王坚：我从不吃后悔药

│ │ │ ├─大咖对话-王平：从人、事、价值观、文化等维度看技术团队转型

│ │ │ ├─大咖对话-王平：如何快速搭建核心技术团队

│ │ │ ├─大咖对话-王鹏云：技术人创业该如何选择合伙人？

│ │ │ ├─大咖对话-王鹏云：管理方式的差异是为了更好地实现企业商业价值

│ │ │ ├─大咖对话-王龙：利用C端连接B端实现产业互联网是下半场的重中之重

│ │ │ ├─大咖对话-童剑：用合伙人管理结构打造完美团队

│ │ │ ├─大咖对话-管理者是首席铲屎官？

│ │ │ ├─大咖对话-胡哲人：技术人创业要跨过的思维坎

│ │ │ ├─大咖对话-袁店明：如何将打造自组织团队落诸实践

│ │ │ ├─大咖对话-袁店明：打造高效研发团队的五个要点

│ │ │ ├─大咖对话-让团队成员持续的enjoy

│ │ │ ├─大咖对话-谢孟军：技术人如何建立自己的个人品牌

│ │ │ ├─大咖对话-谭待：架构的本质是折中

│ │ │ ├─大咖对话-陈天石：AI芯片需要技术和资本的双重密集支撑

│ │ │ ├─大咖对话-陈斌：如何打造高创造力、高动力的技术团队

│ │ │ ├─大咖对话-陶真：技术人要爱上问问题，而不是自己的解决方案

│ │ │ ├─大咖对话-韩军：CTO转型CEO如何转变思路

│ │ │ ├─大咖对话-项目成功的秘诀——技术产品双头负责制

│ │ │ ├─大咖对话-顾旻曼：投资时我们更多地是在找优秀的团队

│ │ │ ├─大咖对话-高斌：过分渲染会过度拉高大众对人工智能的期望

│ │ │ ├─大咖问答-发现下一个小米，不是只能靠运气

│ │ │ ├─大咖问答-打造自己的个人品牌，你也可以

│ │ │ ├─开篇词-卓越的团队，必然有一个卓越的领导者

│ │ │ ├─新春特辑1-卓越CTO必备的能力与素质

│ │ │ ├─新春特辑2-如何成长为优秀的技术管理者？

│ │ │ ├─新春特辑3-如何打造高质效的技术团队？

│ │ │ ├─新春特辑4-如何打造高效的研发流程与文化？

│ │ │ ├─新春特辑5-如何做好人才的选育用留？

│ │ │ ├─温故而知新-一键直达，六大文章主题索引

│ │ │ ├─第100讲-徐裕键：团队文化建设，保持创业公司的战斗力

│ │ │ ├─第101讲-刘俊强：领导力提升指南之培养积极的态度

│ │ │ ├─第102讲-姚从磊：巧用AARRR模型，吸引优秀技术人才（一）

│ │ │ ├─第103讲-姚从磊：巧用AARRR模型，吸引优秀技术人才（二）

│ │ │ ├─第104讲-姚从磊：巧用AARRR模型，吸引优秀技术人才（三）

│ │ │ ├─第105讲-姚从磊：巧用AARRR模型，吸引优秀技术人才（四）

│ │ │ ├─第106讲-程军：技术人的「知行合一」（一）

│ │ │ ├─第107讲-刘俊强：消除压力的七种方法

│ │ │ ├─第108讲-谢呈：技术高手转身创业的坑和坡

│ │ │ ├─第109讲-谢呈：关于垂直互联网创业的一些经验之谈

│ │ │ ├─第10讲-创业公司CTO的认知升级

│ │ │ ├─第110讲-成敏：创业公司为什么会技术文化产品缺失

│ │ │ ├─第111讲-蔡锐涛：从0到1再到100，创业不同阶段的技术管理思考

│ │ │ ├─第112讲-刘俊强：必知绩效管理知识之绩效管理循环

│ │ │ ├─第113讲-程军：技术人的「知行合一」（二）

│ │ │ ├─第114讲-成敏：谈谈不同阶段技术公司的特点

│ │ │ ├─第115讲-成敏：打造优秀团队与文化的三个推手

│ │ │ ├─第116讲-刘俊强：必知绩效管理知识之绩效目标的制定

│ │ │ ├─第117讲-程军：技术人的「知行合一」（三）

│ │ │ ├─第118讲-吴铭：成本评估是技术leader的关键素质

│ │ │ ├─第119讲-汤力嘉：CTO如何进行产品决策（一）

│ │ │ ├─第11讲-最合适的技术才是最有价值的技术

│ │ │ ├─第120讲-刘俊强：必知绩效管理知识之绩效数据收集（上）

│ │ │ ├─第121讲-刘俊强：必知绩效管理知识之绩效数据收集（下）

│ │ │ ├─第122讲-黄伟坚：创业中那些永远回避不了的问题

│ │ │ ├─第123讲-黄伟坚：用系统性思维看待创业

│ │ │ ├─第124讲-刘俊强：必知绩效管理知识之评定绩效

│ │ │ ├─第125讲-洪强宁：从程序员到架构师，从架构师到CTO（一）

│ │ │ ├─第126讲-洪强宁：从程序员到架构师，从架构师到CTO（二）

│ │ │ ├─第127讲-刘俊强：必知绩效管理知识之绩效沟通（一）

│ │ │ ├─第128讲-王坚：年轻人永远是创新的主体

│ │ │ ├─第129讲-刘俊强：必知绩效管理知识之绩效沟通（二）

│ │ │ ├─第12讲-谈谈CTO在商业战略中的定位

│ │ │ ├─第130讲-刘俊强：必知绩效管理知识之绩效沟通（三）

│ │ │ ├─第131讲-汤力嘉：CTO如何在产品方面进行决策（二）

│ │ │ ├─第132讲-徐函秋：转型技术管理者初期的三大挑战（一）

│ │ │ ├─第133讲-徐函秋：转型技术管理者初期的三大挑战（二）

│ │ │ ├─第134讲-刘建国：我各方面做得都很好，就是做不好向上沟通

│ │ │ ├─第135讲-钮博彦：软件研发度量体系建设（一）

│ │ │ ├─第136讲-钮博彦：软件研发度量体系建设（二）

│ │ │ ├─第137讲-成敏：创业者不要成为自己公司产品技术文化的破坏者

│ │ │ ├─第138讲-于艺：以生存为核心，B端产品的定位心法

│ │ │ ├─第139讲-成敏：创业者应该具备的认知与思维方式

│ │ │ ├─第13讲-把脉高效执行的关键要素

│ │ │ ├─第140讲-袁店明：创业产品必须迈过的鸿沟

│ │ │ ├─第141讲-徐毅：五星级软件工程师的高效秘诀（一）

│ │ │ ├─第142讲-徐毅：五星级软件工程师的高效秘诀（二）

│ │ │ ├─第143讲-徐毅：技术Leader应该具备的能力或素质

│ │ │ ├─第144讲-于艺：如何提升自己的能力与动力

│ │ │ ├─第145讲-李列为：技术人员的商业思维

│ │ │ ├─第146讲-刘天胜：打造高效团队，关键在于平衡人、事和时间（一）

│ │ │ ├─第147讲-刘天胜：打造高效团队，关键在于平衡人、事和时间（二）

│ │ │ ├─第148讲-肖德时：创业团队技术领导者必备的十个领导力技能（上）

│ │ │ ├─第149讲-肖德时：创业团队技术领导者必备的十个领导力技能（下）

│ │ │ ├─第14讲-从零开始搭建轻量级研发团队

│ │ │ ├─第150讲-暨家愉：技术人如何快乐的自我成长（上）

│ │ │ ├─第151讲-暨家愉：技术人如何快乐的自我成长（下）

│ │ │ ├─第152讲-施翔：如何打造7-24高效交付通道（上）

│ │ │ ├─第153讲-施翔：如何打造7-24高效交付通道（下）

│ │ │ ├─第154讲-谢东升：说说技术管理者从外企到民企的挑战

│ │ │ ├─第155讲-王可光：如何搭建初创团队之人才关

│ │ │ ├─第156讲-成敏：技术人转型管理的两大秘诀

│ │ │ ├─第157讲-成敏：技术人才的管理公式

│ │ │ ├─第158讲-胡峰：人到中年：失业与恐惧

│ │ │ ├─第159讲-黄云：技术管理者如何科学的做好向上管理

│ │ │ ├─第15讲-定制高效研发流程

│ │ │ ├─第160讲-胡键：创业公司需要高凝聚力高绩效的技术团队

│ │ │ ├─第161讲-卢亿雷：企业发展的不同阶段，该如何打造高效的研发流程体系

│ │ │ ├─第162讲-王海亮：提升技术团队效率的5个提示（上）

│ │ │ ├─第163讲-王海亮：提升技术团队效率的5个提示（下）

│ │ │ ├─第164讲-陈崇磐：心理成熟度-创业公司识人利器

│ │ │ ├─第165讲-陈崇磐：管事与管人-如何避开创业公司组队陷阱

│ │ │ ├─第166讲-俞圆圆：合格CTO应该做好的5件事（上）

│ │ │ ├─第167讲-俞圆圆：合格CTO应该做好的5件事（下）

│ │ │ ├─第168讲-余加林：从技术人到创业合伙人必备的三个维度的改变

│ │ │ ├─第169讲-高琦：如何给研发打绩效不头疼而又公正？（上）

│ │ │ ├─第16讲-培养中层团队的管理认知

│ │ │ ├─第170讲-高琦：如何给研发打绩效不头疼而又公正？（下）

│ │ │ ├─第171讲-邱良军：如何有效地找到你心仪的人才

│ │ │ ├─第172讲-于人：研发团队人均产能3年提升3

│ │ │ ├─第173讲-于人：研发团队人均产能3年提升3

│ │ │ ├─第174讲-邱良军：打造高效技术团队，你准备好了吗！

│ │ │ ├─第175讲-邱良军：打造高效技术团队的人才招聘攻略

│ │ │ ├─第176讲-胡键：创业公司如何打造高凝聚力高绩效的技术团队：组织篇

│ │ │ ├─第177讲-胡键：创业公司如何打造高凝聚力高绩效的技术团队：工具篇

│ │ │ ├─第178讲-马连浩：用人的关键在于用人所长，而非改人之短

│ │ │ ├─第179讲-张矗：技术管理者必经的几个思维转变

│ │ │ ├─第17讲-团队成长要靠技巧和体系

│ │ │ ├─第180讲-钟忻：成为“温格”—聊聊如何当好CTO

│ │ │ ├─第181讲-姚威：技术团队管理中关于公平的五个核心准则

│ │ │ ├─第182讲-谢文杰：区块链的下一个十年

│ │ │ ├─第183讲-薛文植：技术管理的本质—要做尊重人性的管理

│ │ │ ├─第184讲-狼叔：2019年前端和Node的未来—大前端篇（上）

│ │ │ ├─第185讲-狼叔：2019年前端和Node的未来—大前端篇（下）

│ │ │ ├─第186讲-赵晓光：如何培养团队竞争力（上）

│ │ │ ├─第187讲-赵晓光：如何培养团队竞争力（下）

│ │ │ ├─第188讲-张嵩：从心理学角度看待小中型团队的管理

│ │ │ ├─第189讲-狼叔：2019年前端和Node的未来—Node

│ │ │ ├─第18讲-做到这四点，团队必定飞速成长

│ │ │ ├─第190讲-狼叔：2019年前端和Node的未来—Node

│ │ │ ├─第191讲-肖冰：如何建立高信任度的团队

│ │ │ ├─第192讲-崔俊涛：如何做好技术团队的激励（上）

│ │ │ ├─第193讲-崔俊涛：如何做好技术团队的激励（下）

│ │ │ ├─第194讲-刘俊强：2019年云计算趋势对技术人员的影响

│ │ │ ├─第195讲-吴晖：企业B2B服务打磨的秘诀—ESI

│ │ │ ├─第196讲-邱良军：关于做好技术团队管理的几点思考

│ │ │ ├─第197讲-邱良军：做好研发管理的3个关键

│ │ │ ├─第198讲-徐林：通过快速反馈建立充满信任的技术团队

│ │ │ ├─第199讲-宝玉：怎样平衡软件质量与时间成本范围的关系？

│ │ │ ├─第19讲-将企业打造成一所终身大学

│ │ │ ├─第1讲-你的能力模型决定你的职位

│ │ │ ├─第200讲-邱良军：沟通，沟通，还是沟通（上）

│ │ │ ├─第201讲-邱良军：沟通，沟通，还是沟通（下）

│ │ │ ├─第202讲-陈嘉佳：奈飞文化宣言（上）

│ │ │ ├─第203讲-陈嘉佳：奈飞文化宣言（下）

│ │ │ ├─第204讲-邱良军：从小处着眼，修炼文化价值观

│ │ │ ├─第205讲-邵浩：人工智能新技术如何快速发现及落地（上）

│ │ │ ├─第206讲-邵浩：人工智能新技术如何快速发现及落地（下）

│ │ │ ├─第207讲-许良：科创板来了，我该怎么办？

│ │ │ ├─第208讲-陈阳：科创板投资，未来哪些行业受益最大？

│ │ │ ├─第20讲-论团队管理与共同升级

│ │ │ ├─第21讲-绩效管理的目标不仅仅是绩效考核

│ │ │ ├─第22讲-验证研发团队价值的绩效考核机制

│ │ │ ├─第23讲-产品技术团队OKR使用法则

│ │ │ ├─第24讲-996、987，程序员加班文化你怎么看？

│ │ │ ├─第25讲-建立有效的员工淘汰机制

│ │ │ ├─第26讲-让细节的“病毒”感染你的团队

│ │ │ ├─第27讲-如何在不同组织文化下推行技术管理

│ │ │ ├─第28讲-业务高速增长期的团队管理：“知轻重、重绸缪、调缓急”

│ │ │ ├─第29讲-被80%的人误解的工程师文化

│ │ │ ├─第2讲-七位CTO纵论技术领导者核心能力

│ │ │ ├─第30讲-关于工程师文化的六个问题

│ │ │ ├─第31讲-五位技术领导者的文化构建实战

│ │ │ ├─第32讲-文化是管理的那只无形之手

│ │ │ ├─第33讲-选对的人，做正确的事情

│ │ │ ├─第34讲-打好技术团队搭建的基础

│ │ │ ├─第35讲-做个合格的技术岗位面试官

│ │ │ ├─第36讲-“高潜力人才”的内部培养

│ │ │ ├─第37讲-技术创业该如何选择赛道

│ │ │ ├─第38讲-CTO要掌握的产品哲学：理性与人性的权衡

│ │ │ ├─第39讲-从客户价值谈技术创新

│ │ │ ├─第3讲-CEO实话实说：我需要这样的CTO

│ │ │ ├─第40讲-技术人投身创业公司之前，应当考虑些什么？

│ │ │ ├─第41讲-技术人创业前要问自己的六个问题

│ │ │ ├─第42讲-团队激励之分配好你的奖金

│ │ │ ├─第43讲-通过积分考核提升技术团队的绩效

│ │ │ ├─第44讲-空降技术高管的“择业七计”

│ │ │ ├─第45讲-选好人生下一站——CTO空降上篇

│ │ │ ├─第46讲-走出“至暗时刻”——CTO空降下篇

│ │ │ ├─第47讲-空降领导者平稳落地要做的四道题（上）

│ │ │ ├─第48讲-空降领导者平稳落地要做的四道题（下）

│ │ │ ├─第49讲-打造高效的研发组织架构：高效研发流程那些事（一）

│ │ │ ├─第4讲-技术领导者不等于技术管理者

│ │ │ ├─第50讲-你的研发流程符合你的组织架构吗？谈高效研发流程那些事（二）

│ │ │ ├─第51讲-聊聊研发流程管理中的那些坑：高效研发流程那些事（三）

│ │ │ ├─第52讲-数据如何驱动研发高效运转？谈高效研发流程那些事（四）

│ │ │ ├─第53讲-如何打造高效且敏捷的组织文化？谈高效研发流程那些亊（五）

│ │ │ ├─第54讲-打造高速运转的迭代机器：现代研发流程体系打造（一）

│ │ │ ├─第55讲-用机器打造迭代机器：现代研发流程体系打造（二）

│ │ │ ├─第56讲-有了敏捷开发，那交付期限去哪儿了？

│ │ │ ├─第57讲-敏捷中的期限之殇，软件业该怎么做？

│ │ │ ├─第58讲-如何打造个人技术品牌？

│ │ │ ├─第59讲-技术演讲，有章可循

│ │ │ ├─第5讲-CTO的三重境界

│ │ │ ├─第60讲-正确对待技术演讲中的失误

│ │ │ ├─第61讲-刘俊强：技术最高决策者应该关注技术细节吗

│ │ │ ├─第62讲-张溪梦：技术领袖需要具备的商业价值思维

│ │ │ ├─第63讲-未来组织形态带来的领导力挑战

│ │ │ ├─第64讲-如何判断业务价值的高低

│ │ │ ├─第65讲-如何打造高效的分布式团队？

│ │ │ ├─第66讲-如何打造有活力、持续创新的研发团队？

│ │ │ ├─第67讲-如何打造独属自己的工程师文化？

│ │ │ ├─第68讲-如何打造一个自组织团队？

│ │ │ ├─第69讲-茹炳晟：QE团队向工程效能团队转型的实践之路

│ │ │ ├─第6讲-像CEO一样思考

│ │ │ ├─第70讲-技术、产品、管理的不同视角

│ │ │ ├─第71讲-什么样的人适合考虑管理角色

│ │ │ ├─第72讲-创业公司如何招到合适的人才

│ │ │ ├─第73讲-用数据来分析管理员工

│ │ │ ├─第74讲-为什么给了高工资，依然留不住核心员工？

│ │ │ ├─第75讲-刘俊强：一本正经教你如何毁掉一场技术演讲

│ │ │ ├─第76讲-内部技术会议的价值

│ │ │ ├─第79讲-程军：从0到1打造高效技术团队的方法论

│ │ │ ├─第7讲-要制定技术战略，先看清局面

│ │ │ ├─第80讲-技术Leader的持续成长

│ │ │ ├─第81讲-游舒帆：一流团队必备的商业思维能力

│ │ │ ├─第82讲-游舒帆：数据力，透过数据掌握公司经营大小事

│ │ │ ├─第83讲-游舒帆：运营力，让用户出现你期待的行为

│ │ │ ├─第84讲-游舒帆：策略力，让目标与行动具备高度一致性

│ │ │ ├─第85讲-游舒帆：敏捷力，拥抱不确定性，与VUCA共舞

│ │ │ ├─第86讲-刘俊强：管理者必备的高效会议指南（上）

│ │ │ ├─第87讲-刘俊强：管理者必备的高效会议指南（下）

│ │ │ ├─第88讲-刘俊强：做好一对一沟通的关键要素（上）

│ │ │ ├─第89讲-刘俊强：做好一对一沟通的关键要素（下）

│ │ │ ├─第8讲-技术领导力就是“成事”的能力

│ │ │ ├─第90讲-程军：打造高效技术团队之招人

│ │ │ ├─第91讲-程军：打造高效技术团队之做事

│ │ │ ├─第92讲-成敏：技术负责人如何做优先级决策

│ │ │ ├─第93讲-兰军：团队研发效率低下的要因分析

│ │ │ ├─第94讲-兰军：提升产品团队研发效率的实践（上）

│ │ │ ├─第95讲-兰军：提升产品团队研发效率的实践（下）

│ │ │ ├─第96讲-阿禅：工程师转型产品经理可能踩到的“坑”

│ │ │ ├─第97讲-阿禅：工程师转型产品经理的必备思维

│ │ │ ├─第98讲-徐裕键：业务高速增长过程中的团队迭代

│ │ │ ├─第99讲-徐裕键：业务高速增长过程中的技术演进

│ │ │ ├─第9讲-CTO是商业思维和技术思维交汇的那个点

│ │ │ ├─结束篇-即使远隔千山万水，也要乘风与你同往

│ │ │ └─结束篇-即使远隔千山万水，也要乘风与你同往

│ │ ├─011-硅谷产品实战36讲

│ │ │ ├─01-什么是优秀的产品经理？

│ │ │ ├─011-硅谷产品实战36讲

│ │ │ ├─02-硅谷的产品经理是什么样子的？

│ │ │ ├─03-科技巨头和初创公司的产品经理有什么不同？

│ │ │ ├─04-产品经理和项目经理有什么区别？

│ │ │ ├─05-硅谷产品经理每天在做什么？

│ │ │ ├─06-硅谷产品经理们都来自什么背景？

│ │ │ ├─07-如何寻找用户需求？

│ │ │ ├─08-目标客户和用户画像

│ │ │ ├─09-手把手教你写用例：优化微信加好友的功能

│ │ │ ├─10-什么是最小化可行产品（MVP）？

│ │ │ ├─11-案例：产品发布之前出了乱子，如何权衡取舍？

│ │ │ ├─12-制定产品成功指标

│ │ │ ├─13-如何撰写产品需求文档？

│ │ │ ├─14-如何用数据做出产品决定？

│ │ │ ├─15-如何组织有效的会议？

│ │ │ ├─16-如何和工程师有效沟通？

│ │ │ ├─17-如何与设计师有效沟通？

│ │ │ ├─18-如何搞定A-B测试？

│ │ │ ├─19-增长黑客的核心公式

│ │ │ ├─20-想要增长，你的团队需要高效的工作流

│ │ │ ├─21-换个按钮颜色，就能增长百万用户？

│ │ │ ├─22-硅谷高管的UIE（Understand,Identify,Execute）增长论

│ │ │ ├─23-增长的核心在于减少用户阻力

│ │ │ ├─24-产品增长的代价，如何权衡取舍？

│ │ │ ├─25-三分靠策略七分靠执行

│ │ │ ├─26-为什么加班很久但是没成果？产品开发流程有问题

│ │ │ ├─27-如何激励和管理比你资深的工程师、设计师？

│ │ │ ├─28-产品经理的晋升秘密

│ │ │ ├─29-你需要一个产品路线图

│ │ │ ├─30-如何制定产品优先级？

│ │ │ ├─31-好的产品经理和卓越的产品经理

│ │ │ ├─32-产品经理面试考察的是什么？

│ │ │ ├─33-如何提升产品感（productsense）？

│ │ │ ├─34-如何提升产品经理的综合素质？

│ │ │ ├─35-非计算机专业也能做产品经理？

│ │ │ ├─36-模拟一场硅谷的产品经理面试

│ │ │ ├─尾声-每个世界级的产品都有其使命

│ │ │ ├─开篇词-打造千万用户的世界级产品

│ │ │ ├─新书首发-《硅谷产品：36讲直通世界级产品经理》

│ │ │ └─结课测试-关于产品经理的这些知识点，你真的都掌握了吗？

│ │ ├─012-从0开始学架构

│ │ │ ├─01-架构到底是指什么？

│ │ │ ├─012-从0开始学架构

│ │ │ ├─02-架构设计的历史背景

│ │ │ ├─03-架构设计的目的

│ │ │ ├─04-复杂度来源：高性能

│ │ │ ├─05-复杂度来源：高可用

│ │ │ ├─06-复杂度来源：可扩展性

│ │ │ ├─07-复杂度来源：低成本、安全、规模

│ │ │ ├─08-架构设计三原则

│ │ │ ├─09-架构设计原则案例

│ │ │ ├─10-架构设计流程：识别复杂度

│ │ │ ├─11-架构设计流程：设计备选方案

│ │ │ ├─12-架构设计流程：评估和选择备选方案

│ │ │ ├─13-架构设计流程：详细方案设计

│ │ │ ├─14-高性能数据库集群：读写分离

│ │ │ ├─15-高性能数据库集群：分库分表

│ │ │ ├─16-高性能NoSQL

│ │ │ ├─17-高性能缓存架构

│ │ │ ├─18-单服务器高性能模式：PPC与TPC

│ │ │ ├─19-单服务器高性能模式：Reactor与Proactor

│ │ │ ├─20-高性能负载均衡：分类及架构

│ │ │ ├─21-高性能负载均衡：算法

│ │ │ ├─22-想成为架构师，你必须知道CAP理论

│ │ │ ├─23-想成为架构师，你必须掌握的CAP细节

│ │ │ ├─24-FMEA方法，排除架构可用性隐患的利器

│ │ │ ├─25-高可用存储架构：双机架构

│ │ │ ├─26-高可用存储架构：集群和分区

│ │ │ ├─27-如何设计计算高可用架构？

│ │ │ ├─28-业务高可用的保障：异地多活架构

│ │ │ ├─29-异地多活设计4大技巧

│ │ │ ├─30-异地多活设计4步走

│ │ │ ├─31-如何应对接口级的故障？

│ │ │ ├─32-可扩展架构的基本思想和模式

│ │ │ ├─33-传统的可扩展架构模式：分层架构和SOA

│ │ │ ├─34-深入理解微服务架构：银弹or焦油坑？

│ │ │ ├─35-微服务架构最佳实践-方法篇

│ │ │ ├─36-微服务架构最佳实践-基础设施篇

│ │ │ ├─37-微内核架构详解

│ │ │ ├─38-架构师应该如何判断技术演进的方向？

│ │ │ ├─39-互联网技术演进的模式

│ │ │ ├─40-互联网架构模板：“存储层”技术

│ │ │ ├─41-互联网架构模板：“开发层”和“服务层”技术

│ │ │ ├─42-互联网架构模板：“网络层”技术

│ │ │ ├─43-互联网架构模板：“用户层”和“业务层”技术

│ │ │ ├─44-互联网架构模板：“平台”技术

│ │ │ ├─45-架构重构内功心法第一式：有的放矢

│ │ │ ├─46-架构重构内功心法第二式：合纵连横

│ │ │ ├─47-架构重构内功心法第三式：运筹帷幄

│ │ │ ├─48-再谈开源项目：如何选择、使用以及二次开发？

│ │ │ ├─49-谈谈App架构的演进

│ │ │ ├─50-架构实战：架构设计文档模板

│ │ │ ├─51-如何画出优秀的软件系统架构图？

│ │ │ ├─加餐｜业务架构实战营开营了

│ │ │ ├─加餐｜单服务器高性能模式性能对比

│ │ │ ├─加餐｜扒一扒中台皇帝的外衣

│ │ │ ├─如何高效地学习开源项目-“华仔，放学别走！”第3期

│ │ │ ├─开篇词-照着做，你也能成为架构师！

│ │ │ ├─新书首发-《从零开始学架构》

│ │ │ ├─架构专栏特别放送-“华仔，放学别走！”第1期

│ │ │ ├─架构专栏特别放送-“华仔，放学别走！”第2期

│ │ │ ├─架构师必读书单-“华仔，放学别走！”第5期

│ │ │ ├─架构师成长之路-“华仔，放学别走！”第4期

│ │ │ ├─第二季回归-照着做，你也能顺利晋升！

│ │ │ ├─结束语-坚持，成就你的技术梦想

│ │ │ ├─结课测试｜这些架构技能你都掌握了吗？

│ │ │ ├─致「从0开始学架构」专栏订阅用户

│ │ │ └─致「从0开始学架构」专栏订阅用户

│ │ ├─013-Java核心技术面试精讲

│ │ │ ├─013-Java核心技术面试精讲

│ │ │ ├─周末福利-一份Java工程师必读书单

│ │ │ ├─周末福利-谈谈我对Java学习和面试的看法

│ │ │ ├─开篇词-以面试题为切入点，有效提升你的Java内功

│ │ │ ├─第10讲-如何保证集合是线程安全的-ConcurrentHashMap如何实现高效地线程安全？

│ │ │ ├─第11讲-Java提供了哪些IO方式？NIO如何实现多路复用？(1)

│ │ │ ├─第11讲-Java提供了哪些IO方式？NIO如何实现多路复用？

│ │ │ ├─第12讲-Java有几种文件拷贝方式？哪一种最高效？

│ │ │ ├─第13讲-谈谈接口和抽象类有什么区别？

│ │ │ ├─第14讲-谈谈你知道的设计模式？

│ │ │ ├─第15讲-synchronized和ReentrantLock有什么区别呢？

│ │ │ ├─第16讲-synchronized底层如何实现？什么是锁的升级、降级？

│ │ │ ├─第17讲-一个线程两次调用start()方法会出现什么情况？

│ │ │ ├─第18讲-什么情况下Java程序会产生死锁？如何定位、修复？

│ │ │ ├─第19讲-Java并发包提供了哪些并发工具类？

│ │ │ ├─第1讲-谈谈你对Java平台的理解？

│ │ │ ├─第20讲-并发包中的ConcurrentLinkedQueue和LinkedBlockingQueue有什么区别？

│ │ │ ├─第21讲-Java并发类库提供的线程池有哪几种？分别有什么特点？

│ │ │ ├─第22讲-AtomicInteger底层实现原理是什么？如何在自己的产品代码中应用CAS操作？

│ │ │ ├─第23讲-请介绍类加载过程，什么是双亲委派模型？

│ │ │ ├─第24讲-有哪些方法可以在运行时动态生成一个Java类？

│ │ │ ├─第25讲-谈谈JVM内存区域的划分，哪些区域可能发生OutOfMemoryError

│ │ │ ├─第26讲-如何监控和诊断JVM堆内和堆外内存使用？

│ │ │ ├─第27讲-Java常见的垃圾收集器有哪些？

│ │ │ ├─第28讲-谈谈你的GC调优思路

│ │ │ ├─第29讲-Java内存模型中的happen-before是什么？

│ │ │ ├─第2讲-Exception和Error有什么区别？

│ │ │ ├─第30讲-Java程序运行在Docker等容器环境有哪些新问题？

│ │ │ ├─第31讲-你了解Java应用开发中的注入攻击吗？

│ │ │ ├─第32讲-如何写出安全的Java代码？

│ │ │ ├─第33讲-后台服务出现明显“变慢”，谈谈你的诊断思路？

│ │ │ ├─第34讲-有人说“Lambda能让Java程序慢30倍”，你怎么看？

│ │ │ ├─第35讲-JVM优化Java代码时都做了什么？

│ │ │ ├─第36讲-谈谈MySQL支持的事务隔离级别，以及悲观锁和乐观锁的原理和应用场景？

│ │ │ ├─第37讲-谈谈SpringBean的生命周期和作用域？

│ │ │ ├─第38讲-对比Java标准NIO类库，你知道Netty是如何实现更高性能的吗？

│ │ │ ├─第39讲-谈谈常用的分布式ID的设计方案？Snowflake是否受冬令时切换影响？

│ │ │ ├─第3讲-谈谈final、finally、finalize有什么不同？

│ │ │ ├─第4讲-强引用、软引用、弱引用、幻象引用有什么区别？

│ │ │ ├─第5讲-String、StringBuffer、StringBuilder有什么区别？

│ │ │ ├─第6讲-动态代理是基于什么原理？

│ │ │ ├─第7讲-int和Integer有什么区别？

│ │ │ ├─第8讲-对比Vector、ArrayList、LinkedList有何区别？

│ │ │ ├─第9讲-对比Hashtable、HashMap、TreeMap有什么不同？

│ │ │ ├─结束语-技术没有终点

│ │ │ └─结课测试-Java核心技术的这些知识，你真的掌握了吗？

│ │ ├─014-趣谈网络协议

│ │ │ ├─014-趣谈网络协议

│ │ │ ├─加餐1-创作故事：我是如何创作“趣谈网络协议”专栏的？

│ │ │ ├─加餐2-“趣谈网络协议”专栏食用指南

│ │ │ ├─协议专栏特别福利-答疑解惑第一期

│ │ │ ├─协议专栏特别福利-答疑解惑第三期

│ │ │ ├─协议专栏特别福利-答疑解惑第二期

│ │ │ ├─协议专栏特别福利-答疑解惑第五期

│ │ │ ├─协议专栏特别福利-答疑解惑第四期

│ │ │ ├─开篇词-想成为技术牛人？先搞定网络协议！

│ │ │ ├─第10讲-UDP协议：因性善而简单，难免碰到“城会玩”

│ │ │ ├─第11讲-TCP协议（上）：因性恶而复杂，先恶后善反轻松

│ │ │ ├─第12讲-TCP协议（下）：西行必定多妖孽，恒心智慧消磨难

│ │ │ ├─第13讲-套接字Socket：Talkischeap,showmethecode

│ │ │ ├─第14讲-HTTP协议：看个新闻原来这么麻烦

│ │ │ ├─第15讲-HTTPS协议：点外卖的过程原来这么复杂

│ │ │ ├─第16讲-流媒体协议：如何在直播里看到美女帅哥？

│ │ │ ├─第17讲-P2P协议：我下小电影，99%急死你

│ │ │ ├─第18讲-DNS协议：网络世界的地址簿

│ │ │ ├─第19讲-HttpDNS：网络世界的地址簿也会指错路

│ │ │ ├─第1讲-为什么要学习网络协议？

│ │ │ ├─第20讲-CDN：你去小卖部取过快递么？

│ │ │ ├─第21讲-数据中心：我是开发商，自己拿地盖别墅

│ │ │ ├─第22讲-VPN：朝中有人好做官

│ │ │ ├─第23讲-移动网络：去巴塞罗那，手机也上不了脸书

│ │ │ ├─第24讲-云中网络：自己拿地成本高，购买公寓更灵活

│ │ │ ├─第25讲-软件定义网络：共享基础设施的小区物业管理办法

│ │ │ ├─第26讲-云中的网络安全：虽然不是土豪，也需要基本安全和保障

│ │ │ ├─第27讲-云中的网络QoS：邻居疯狂下电影，我该怎么办？

│ │ │ ├─第28讲-云中网络的隔离GRE、VXLAN：虽然住一个小区，也要保护隐私

│ │ │ ├─第29讲-容器网络：来去自由的日子，不买公寓去合租

│ │ │ ├─第2季回归-这次我们来“趣谈Linux操作系统”

│ │ │ ├─第2讲-网络分层的真实含义是什么？

│ │ │ ├─第30讲-容器网络之Flannel：每人一亩三分地

│ │ │ ├─第31讲-容器网络之Calico：为高效说出善意的谎言

│ │ │ ├─第32讲-RPC协议综述：远在天边，近在眼前

│ │ │ ├─第33讲-基于XML的SOAP协议：不要说NBA，请说美国职业篮球联赛

│ │ │ ├─第34讲-基于JSON的RESTful接口协议：我不关心过程，请给我结果

│ │ │ ├─第35讲-二进制类RPC协议：还是叫NBA吧，总说全称多费劲

│ │ │ ├─第36讲-跨语言类RPC协议：交流之前，双方先来个专业术语表

│ │ │ ├─第37讲-知识串讲：用双十一的故事串起碎片的网络协议（上）

│ │ │ ├─第38讲-知识串讲：用双十一的故事串起碎片的网络协议（中）

│ │ │ ├─第39讲-知识串讲：用双十一的故事串起碎片的网络协议（下）

│ │ │ ├─第3讲-ifconfig：最熟悉又陌生的命令行

│ │ │ ├─第40讲-搭建一个网络实验环境：授人以鱼不如授人以渔

│ │ │ ├─第4讲-DHCP与PXE：IP是怎么来的，又是怎么没的？

│ │ │ ├─第5讲-从物理层到MAC层：如何在宿舍里自己组网玩联机游戏？

│ │ │ ├─第6讲-交换机与VLAN：办公室太复杂，我要回学校

│ │ │ ├─第7讲-ICMP与ping：投石问路的侦察兵

│ │ │ ├─第8讲-世界这么大，我想出网关：欧洲十国游与玄奘西行

│ │ │ ├─第9讲-路由协议：西出网关无故人，敢问路在何方

│ │ │ ├─结束语-放弃完美主义，执行力就是限时限量认真完成

│ │ │ └─结课测试-这些网络协议你都掌握了吗？

│ │ ├─015-从0开始学游戏开发

│ │ │ ├─015-从0开始学游戏开发

│ │ │ ├─复习课-带你梳理客户端开发的三个重点

│ │ │ ├─开篇词-跟我学，你也可以开发一款游戏！

│ │ │ ├─第10讲-如何载入“飞机”和“敌人”？

│ │ │ ├─第11讲-如何设置图像的前后遮挡？

│ │ │ ├─第12讲-如何设置精灵的变形、放大和缩小？

│ │ │ ├─第13讲-如何设置淡入淡出和碰撞检测？

│ │ │ ├─第14讲-如何制作游戏资源包和保存机制？

│ │ │ ├─第15讲-如何载入背景音乐和音效？

│ │ │ ├─第16讲-如何在游戏中载入UI和菜单？

│ │ │ ├─第17讲-如何用鼠标和键盘来操作游戏？

│ │ │ ├─第18讲-如何判断客户端的网络连接？

│ │ │ ├─第19讲-如何嵌入脚本语言？

│ │ │ ├─第1讲-游戏开发需要了解哪些背景知识？

│ │ │ ├─第20讲-脚本语言在游戏开发中有哪些应用？

│ │ │ ├─第21讲-如何使用脚本语言编写周边工具？

│ │ │ ├─第22讲-如何选择合适的开发语言？

│ │ │ ├─第23讲-如何定制合适的开发协议？

│ │ │ ├─第24讲-不可忽视的多线程及并发问题

│ │ │ ├─第25讲-如何判断心跳包是否离线？

│ │ │ ├─第26讲-如何用网关服务器进行负载均衡？

│ │ │ ├─第27讲-如何制作游戏内容保存和缓存处理？

│ │ │ ├─第28讲-热点剖析（一）：HTML5技术是如何取代Flash的？

│ │ │ ├─第29讲-热点剖析（二）：如何选择一款HTML5引擎？

│ │ │ ├─第2讲-2D游戏和3D游戏有什么区别？

│ │ │ ├─第30讲-热点剖析（三）：试试看，你也可以编写一款HTML5小游戏！

│ │ │ ├─第31讲-热点剖析（四）：安卓端和苹果端游戏开发有什么区别？

│ │ │ ├─第32讲-热点剖析（五）：如何选择移动端的游戏引擎？

│ │ │ ├─第33讲-热点剖析（六）：AR和人工智能在游戏领域有哪些应用？

│ │ │ ├─第34讲-热点剖析（七）：谈谈微信小游戏的成功点

│ │ │ ├─第35讲-热点剖析（八）：谈谈移动游戏的未来发展

│ │ │ ├─第36讲-热点剖析（九）：谈谈独立开发者的未来发展

│ │ │ ├─第3讲-游戏的发动机：游戏引擎

│ │ │ ├─第4讲-底层绘图接口的妙用

│ │ │ ├─第5讲-构建游戏场景的武器：地图编辑器

│ │ │ ├─第6讲-从0开始整理开发流程

│ │ │ ├─第7讲-如何建立一个Windows窗体？

│ │ │ ├─第8讲-如何区分图形和图像？

│ │ │ ├─第9讲-如何绘制游戏背景？

│ │ │ ├─结束语-做游戏的过程就像是在雕琢一件艺术品

│ │ │ ├─结课测试｜“从0开始学游戏开发”100分试卷等你来挑战？

│ │ │ ├─课后阅读-游戏开发工程师学习路径（上）

│ │ │ ├─课后阅读-游戏开发工程师学习路径（下）

│ │ │ └─课后阅读-游戏开发工程师学习路径（下）

│ │ ├─016-机器学习40讲

│ │ │ ├─01-频率视角下的机器学习

│ │ │ ├─016-机器学习40讲

│ │ │ ├─02-贝叶斯视角下的机器学习

│ │ │ ├─03-学什么与怎么学

│ │ │ ├─04-计算学习理论

│ │ │ ├─05-模型的分类方式

│ │ │ ├─06-模型的设计准则

│ │ │ ├─07-模型的验证方法

│ │ │ ├─08-模型的评估指标

│ │ │ ├─09-实验设计

│ │ │ ├─10-特征预处理

│ │ │ ├─11-基础线性回归：一元与多元

│ │ │ ├─12-正则化处理：收缩方法与边际化

│ │ │ ├─13-线性降维：主成分的使用

│ │ │ ├─14-非线性降维：流形学习

│ │ │ ├─15-从回归到分类：联系函数与降维

│ │ │ ├─16-建模非正态分布：广义线性模型

│ │ │ ├─17-几何角度看分类：支持向量机

│ │ │ ├─18-从全局到局部：核技巧

│ │ │ ├─19-非参数化的局部模型：K近邻

│ │ │ ├─20-基于距离的学习：聚类与度量学习

│ │ │ ├─21-基函数扩展：属性的非线性化

│ │ │ ├─22-自适应的基函数：神经网络

│ │ │ ├─23-层次化的神经网络：深度学习

│ │ │ ├─24-深度编解码：表示学习

│ │ │ ├─25-基于特征的区域划分：树模型

│ │ │ ├─26-集成化处理：Boosting与Bagging

│ │ │ ├─27-万能模型：梯度提升与随机森林

│ │ │ ├─28-最简单的概率图：朴素贝叶斯

│ │ │ ├─29-有向图模型：贝叶斯网络

│ │ │ ├─30-无向图模型：马尔可夫随机场

│ │ │ ├─31-建模连续分布：高斯网络

│ │ │ ├─32-从有限到无限：高斯过程

│ │ │ ├─33-序列化建模：隐马尔可夫模型

│ │ │ ├─34-连续序列化模型：线性动态系统

│ │ │ ├─35-精确推断：变量消除及其拓展

│ │ │ ├─36-确定近似推断：变分贝叶斯

│ │ │ ├─37-随机近似推断：MCMC

│ │ │ ├─38-完备数据下的参数学习：有向图与无向图

│ │ │ ├─39-隐变量下的参数学习：EM方法与混合模型

│ │ │ ├─40-结构学习：基于约束与基于评分

│ │ │ ├─如何成为机器学习工程师？

│ │ │ ├─开篇词-打通修炼机器学习的任督二脉

│ │ │ ├─总结课-机器学习的模型体系

│ │ │ ├─总结课-贝叶斯学习的模型体系

│ │ │ ├─结课-终有一天，你将为今天的付出骄傲

│ │ │ └─结课测试-这些机器学习知识你都掌握了吗？

│ │ ├─017-软件测试52讲

│ │ │ ├─01-你真的懂测试吗？从“用户登录”测试谈起

│ │ │ ├─017-软件测试52讲

│ │ │ ├─02-如何设计一个“好的”测试用例？

│ │ │ ├─03-什么是单元测试？如何做好单元测试？

│ │ │ ├─04-为什么要做自动化测试？什么样的项目适合做自动化测试？

│ │ │ ├─05-你知道软件开发各阶段都有哪些自动化测试技术吗？

│ │ │ ├─06-你真的懂测试覆盖率吗？

│ │ │ ├─07-如何高效填写软件缺陷报告？

│ │ │ ├─08-以终为始，如何才能做好测试计划？

│ │ │ ├─09-软件测试工程师的核心竞争力是什么？

│ │ │ ├─10-软件测试工程师需要掌握的非测试知识有哪些？

│ │ │ ├─11-互联网产品的测试策略应该如何设计？

│ │ │ ├─12-从0到1：你的第一个GUI自动化测试

│ │ │ ├─13-效率为王：脚本与数据的解耦+PageObject模型

│ │ │ ├─14-更接近业务的抽象：让自动化测试脚本更好地描述业务

│ │ │ ├─15-过不了的坎：聊聊GUI自动化过程中的测试数据

│ │ │ ├─16-脑洞大开：GUI测试还能这么玩（PageCodeGen+DataGen+Headless）？

│ │ │ ├─17-精益求精：聊聊提高GUI测试稳定性的关键技术

│ │ │ ├─18-眼前一亮：带你玩转GUI自动化的测试报告

│ │ │ ├─19-真实的战场：如何在大型项目中设计GUI自动化测试策略

│ │ │ ├─20-与时俱进：浅谈移动应用测试方法与思路

│ │ │ ├─21-移动测试神器：带你玩转Appium

│ │ │ ├─22-从0到1：API测试怎么做？常用API测试工具简介

│ │ │ ├─23-知其然知其所以然：聊聊API自动化测试框架的前世今生

│ │ │ ├─24-紧跟时代步伐：微服务模式下API测试要怎么做？

│ │ │ ├─25-不破不立：掌握代码级测试的基本理念与方法

│ │ │ ├─26-深入浅出之静态测试方法

│ │ │ ├─27-深入浅出之动态测试方法

│ │ │ ├─28-带你一起解读不同视角的软件性能与性能指标

│ │ │ ├─29-聊聊性能测试的基本方法与应用领域

│ │ │ ├─30-工欲善其事必先利其器：后端性能测试工具原理与行业常用工具简介

│ │ │ ├─31-工欲善其事必先利其器：前端性能测试工具原理与行业常用工具简介

│ │ │ ├─32-无实例无真相：基于LoadRunner实现企业级服务器端性能测试的实践（上）

│ │ │ ├─33-无实例无真相：基于LoadRunner实现企业级服务器端性能测试的实践（下）

│ │ │ ├─34-站在巨人的肩膀：企业级实际性能测试案例与经验分享

│ │ │ ├─35-如何准备测试数据？

│ │ │ ├─36-浅谈测试数据的痛点

│ │ │ ├─37-测试数据的“银弹”-统一测试数据平台（上）

│ │ │ ├─38-测试数据的“银弹”-统一测试数据平台（下）

│ │ │ ├─39-从小作坊到工厂：什么是SeleniumGrid？如何搭建SeleniumGrid？

│ │ │ ├─40-从小工到专家：聊聊测试执行环境的架构设计（上）

│ │ │ ├─41-从小工到专家：聊聊测试执行环境的架构设计（下）

│ │ │ ├─42-实战：大型全球化电商的测试基础架构设计

│ │ │ ├─43-发挥人的潜能：探索式测试

│ │ │ ├─44-测试先行：测试驱动开发(TDD)

│ │ │ ├─45-打蛇打七寸：精准测试

│ │ │ ├─46-安全第一：渗透测试

│ │ │ ├─47-用机器设计测试用例：基于模型的测试

│ │ │ ├─48-优秀的测试工程师为什么要懂大型网站的架构设计？

│ │ │ ├─49-深入浅出网站高性能架构设计

│ │ │ ├─50-深入浅出网站高可用架构设计

│ │ │ ├─51-深入浅出网站伸缩性架构设计

│ │ │ ├─52-深入浅出网站可扩展性架构设计

│ │ │ ├─开篇词-从“小工”到“专家”，我的软件测试修炼之道

│ │ │ ├─测一测-这些软件测试题目，你都掌握了吗？

│ │ │ ├─测试专栏特别放送-浅谈全链路压测

│ │ │ ├─测试专栏特别放送-答疑解惑第一期

│ │ │ ├─测试专栏特别放送-答疑解惑第七期

│ │ │ ├─测试专栏特别放送-答疑解惑第三期

│ │ │ ├─测试专栏特别放送-答疑解惑第二期

│ │ │ ├─测试专栏特别放送-答疑解惑第五期

│ │ │ ├─测试专栏特别放送-答疑解惑第六期

│ │ │ ├─测试专栏特别放送-答疑解惑第四期

│ │ │ ├─结束语-不是结束，而是开始

│ │ │ └─结束语-不是结束，而是开始

│ │ ├─018-持续交付36讲

│ │ │ ├─01-持续交付到底有什么价值？

│ │ │ ├─018-持续交付36讲

│ │ │ ├─02-影响持续交付的因素有哪些？

│ │ │ ├─03-持续交付和DevOps是一对好基友

│ │ │ ├─04-一切的源头，代码分支策略的选择

│ │ │ ├─05-手把手教你依赖管理

│ │ │ ├─06-代码回滚，你真的理解吗？

│ │ │ ├─07-“两个披萨”团队的代码管理实际案例

│ │ │ ├─08-测试环境要多少？从现实需求说起

│ │ │ ├─09-测试环境要多少？从成本与效率说起

│ │ │ ├─10-让环境自己说话，论环境自描述的重要性

│ │ │ ├─11-“配置”是把双刃剑，带你了解各种配置方法

│ │ │ ├─12-极限挑战，如何做到分钟级搭建环境？

│ │ │ ├─13-容器技术真的是环境管理的救星吗？

│ │ │ ├─14-如何做到构建的提速，再提速！

│ │ │ ├─15-构建检测，无规矩不成方圆

│ │ │ ├─16-构建资源的弹性伸缩

│ │ │ ├─17-容器镜像构建的那些事儿

│ │ │ ├─18-如何做好容器镜像的个性化及合规检查？

│ │ │ ├─19-发布是持续交付的最后一公里

│ │ │ ├─20-Immutable！任何变更都需要发布

│ │ │ ├─21-发布系统一定要注意用户体验

│ │ │ ├─22-发布系统的核心架构和功能设计

│ │ │ ├─23-业务及系统架构对发布的影响

│ │ │ ├─24-如何利用监控保障发布质量？

│ │ │ ├─25-代码静态检查实践

│ │ │ ├─26-越来越重要的破坏性测试

│ │ │ ├─27-利用Mock与回放技术助力自动化回归

│ │ │ ├─28-持续交付为什么要平台化设计？

│ │ │ ├─29-计算资源也是交付的内容

│ │ │ ├─30-持续交付中有哪些宝贵数据？

│ │ │ ├─31-了解移动App的持续交付生命周期

│ │ │ ├─32-细谈移动APP的交付流水线（pipeline）

│ │ │ ├─33-进阶，如何进一步提升移动APP的交付效率？

│ │ │ ├─34-快速构建持续交付系统（一）：需求分析

│ │ │ ├─35-快速构建持续交付系统（二）：GitLab解决代码管理问题

│ │ │ ├─36-快速构建持续交付系统（三）：Jenkins解决集成打包问题

│ │ │ ├─37-快速构建持续交付系统（四）：Ansible解决自动部署问题

│ │ │ ├─开篇词-量身定制你的持续交付体系

│ │ │ ├─持续交付专栏特别放送-答疑解惑

│ │ │ ├─持续交付专栏特别放送-高效学习指南

│ │ │ ├─结束语-越痛苦的事，越要经常做

│ │ │ └─结课测试｜这些持续交付的相关知识，你都掌握了吗？

│ │ ├─019-深入拆解Java虚拟机

│ │ │ ├─01-Java代码是怎么运行的？

│ │ │ ├─019-深入拆解Java虚拟机

│ │ │ ├─02-Java的基本类型

│ │ │ ├─03-Java虚拟机是如何加载Java类的

│ │ │ ├─04-JVM是如何执行方法调用的？（上）

│ │ │ ├─05-JVM是如何执行方法调用的？（下）

│ │ │ ├─06-JVM是如何处理异常的？

│ │ │ ├─07-JVM是如何实现反射的？

│ │ │ ├─08-JVM是怎么实现invokedynamic的？（上）

│ │ │ ├─09-JVM是怎么实现invokedynamic的？（下）

│ │ │ ├─10-Java对象的内存布局

│ │ │ ├─11-垃圾回收（上）

│ │ │ ├─12-垃圾回收（下）

│ │ │ ├─13-Java内存模型

│ │ │ ├─14-Java虚拟机是怎么实现synchronized的？

│ │ │ ├─15-Java语法糖与Java编译器

│ │ │ ├─16-即时编译（上）

│ │ │ ├─17-即时编译（下）

│ │ │ ├─18-即时编译器的中间表达形式

│ │ │ ├─19-Java字节码（基础篇）

│ │ │ ├─20-方法内联（上）

│ │ │ ├─21-方法内联（下）

│ │ │ ├─22-HotSpot虚拟机的intrinsic

│ │ │ ├─23-逃逸分析

│ │ │ ├─24-字段访问相关优化

│ │ │ ├─25-循环优化

│ │ │ ├─26-向量化

│ │ │ ├─27-注解处理器

│ │ │ ├─28-基准测试框架JMH（上）

│ │ │ ├─29-基准测试框架JMH（下）

│ │ │ ├─30-Java虚拟机的监控及诊断工具（命令行篇）

│ │ │ ├─31-Java虚拟机的监控及诊断工具（GUI篇）

│ │ │ ├─32-JNI的运行机制

│ │ │ ├─33-JavaAgent与字节码注入

│ │ │ ├─34-Graal：用Java编译Java

│ │ │ ├─35-Truffle：语言实现框架

│ │ │ ├─36-SubstrateVM：AOT编译框架

│ │ │ ├─【工具篇】常用工具介绍

│ │ │ ├─尾声-道阻且长，努力加餐

│ │ │ ├─开篇词-为什么我们要学习Java虚拟机？

│ │ │ └─结课测试-这些Java虚拟机的知识你都掌握了吗？

│ │ ├─020-邱岳的产品实战

│ │ │ ├─01-如何验证你的产品创意？

│ │ │ ├─02-如何锤炼你的产品创意

│ │ │ ├─020-邱岳的产品实战

│ │ │ ├─03-要不要相信你的调查问卷

│ │ │ ├─04-用最少的资源给你的产品试试水

│ │ │ ├─05-如何快速利用MVP思想

│ │ │ ├─06-如何做好产品立项

│ │ │ ├─07-产品发布的那些坑儿

│ │ │ ├─08-产品增长越来越难，到底应该怎么办？

│ │ │ ├─09-产品增长的核心，究竟是什么？

│ │ │ ├─10-你需要组建增长团队吗，应该如何组建呢？

│ │ │ ├─11-产品增长有哪些业务公式与关键指标？（上）

│ │ │ ├─12-产品增长有哪些业务公式与关键指标？（下）

│ │ │ ├─13-产品做增长的过程中，有哪些关键套路？

│ │ │ ├─14-实战增长，我们要知道哪些事儿？

│ │ │ ├─15-增长执行时，需要哪些关键的能力

│ │ │ ├─16-当钩子靠不住时，如何提高用户留存？（上）

│ │ │ ├─17-当钩子靠不住时，如何提高用户留存？（下）

│ │ │ ├─18-如何把你的新用户转化为忠实的长期用户？

│ │ │ ├─19-满眼尽是“病毒”“裂变”，到底什么是传播和获客的正确姿势？（上）

│ │ │ ├─20-满眼尽是“病毒”“裂变”，到底什么是传播和获客的正确姿势？（下）

│ │ │ ├─21-增长黑客的阴暗面

│ │ │ ├─22-产品经理需要具备哪些基本的数据能力和意识？

│ │ │ ├─23-突发式流量数据暴跌，产品经理应该如何应对？【分析篇】

│ │ │ ├─24-突发式流量数据暴跌，产品经理应该如何应对？【拆解篇】

│ │ │ ├─25-突发式流量数据暴跌，产品经理应该如何应对？【处理篇】

│ │ │ ├─26-当收集数据的前后，我们应该做什么？

│ │ │ ├─27-从具体业务出发，如何利用数据辅助你的决策？

│ │ │ ├─28-那些数据不能告诉你的事儿：尽信“数”不如无“数”

│ │ │ ├─29-每个产品经理都要掌握的基本商业概念是什么？

│ │ │ ├─30-如何提高你的商业产品收入？（上）

│ │ │ ├─31-如何提高你的商业产品收入（下）

│ │ │ ├─32-“烧钱获客”中有哪些值得学习的商业逻辑？

│ │ │ ├─33-“烧钱获客”的正确姿势有哪些？

│ │ │ ├─34-如何具备赚钱的意识与能力？

│ │ │ ├─35-对产品经理来说，做小程序有什么价值？

│ │ │ ├─36-如何利用小程序去做传播？

│ │ │ ├─37-关于小程序，一些你应该知道的事儿

│ │ │ ├─产品会客厅-一次简洁并有效的产品分析需要怎么做？

│ │ │ ├─产品会客厅-专栏销量过万是一种什么样的感受？

│ │ │ ├─产品会客厅-产品经理如何上手体验一个App（下）

│ │ │ ├─产品会客厅-产品经理如何上手体验一个App？（上）

│ │ │ ├─产品会客厅-产品经理的职业发展，你在哪个阶段？

│ │ │ ├─产品会客厅-产品经理面试究竟考什么？

│ │ │ ├─产品会客厅-从“分享有赏”案例讲起，如何做关键决策？

│ │ │ ├─产品会客厅-从“极客时间”App的信息架构上，我们能学到什么？

│ │ │ ├─产品会客厅-从案例出发，如何利用数据分析来验证新功能的效果？

│ │ │ ├─产品会客厅-从流量型平台转到资源匮乏平台，如何应对业务变化？

│ │ │ ├─产品会客厅-千万级用户的产品是如何打造的？

│ │ │ ├─产品会客厅-在产品的获客与传播上，“极客时间”做了些什么？

│ │ │ ├─产品会客厅-未来的产品会有怎样的发展趋势？

│ │ │ ├─产品会客厅-极客时间产品规划大揭秘

│ │ │ ├─产品会客厅-没有项目管理经验，如何推动团队一起完成任务？

│ │ │ ├─产品会客厅-需求评审怎么做，如何区分什么是真的用户需求？

│ │ │ ├─产品会客厅-面向大众的通用型产品VS受众面少的垂直领域，二者如何博弈？（上）

│ │ │ ├─产品会客厅-面向大众的通用型产品VS受众面少的垂直领域，二者如何博弈？（下）

│ │ │ ├─尾声-祝你胸怀远大，心狠手辣

│ │ │ ├─开篇词-和自己较劲，一个产品经理的实战历程

│ │ ├─021-程序员进阶攻略

│ │ │ ├─01-初心：为什么成为一名程序员？

│ │ │ ├─02-初惑：技术方向的选择

│ │ │ ├─021-程序员进阶攻略

│ │ │ ├─03-初程：带上一份技能地图

│ │ │ ├─04-初感：别了校园，入了江湖

│ │ │ ├─05-架构与实现：它们的连接与分界？

│ │ │ ├─06-模式与框架：它们的关系与误区？

│ │ │ ├─07-多维与视图：系统设计的思考维度与展现视图

│ │ │ ├─08-代码与分类：工业级编程的代码分类与特征

│ │ │ ├─09-粗放与精益：编程的两种思路与方式

│ │ │ ├─10-炫技与克制：代码的两种味道与态度

│ │ │ ├─11-三阶段进化：调试，编写与运行代码

│ │ │ ├─12-Bug的空间属性：环境依赖与过敏反应

│ │ │ ├─13-Bug的时间属性：周期特点与非规律性

│ │ │ ├─14-Bug的反复出现：重蹈覆辙与吸取教训

│ │ │ ├─15-根源：计划的愿景——仰望星空

│ │ │ ├─16-方式：计划的方法——脚踏实地

│ │ │ ├─17-检视：计划的可行——时间与承诺

│ │ │ ├─18-评估：计划的收获——成本与收益

│ │ │ ├─19-障碍：从计划到坚持，再到坚持不下去的时候

│ │ │ ├─20-执行：从坚持到持续，再到形成自己的节奏

│ │ │ ├─21-信息：过载与有效

│ │ │ ├─22-领域：知识与体系

│ │ │ ├─23-转化：能力与输出

│ │ │ ├─24-并行：工作与学习

│ │ │ ├─25-时间：塑造基石习惯（上）——感知与测量

│ │ │ ├─26-时间：塑造基石习惯（下）——切割与构建

│ │ │ ├─27-试试：一种“坏”习惯

│ │ │ ├─28-提问：从技术到人生的习惯

│ │ │ ├─29-偏好：个人习惯的局限与反思

│ │ │ ├─30-写作：写字如编码

│ │ │ ├─31-画图：一图胜千言

│ │ │ ├─32-演讲：表达的技术

│ │ │ ├─33-定义：阶梯与级别

│ │ │ ├─34-晋升：评定与博弈

│ │ │ ├─35-关系：学徒与导师

│ │ │ ├─36-核心：安全与效率——工程技术的两个核心维度

│ │ │ ├─37-过程：规模与协作——规模化的过程方法

│ │ │ ├─38-思维：科学与系统——两类问题的两种思维解法

│ │ │ ├─39-职业倦怠：如何面对？

│ │ │ ├─40-局部最优：如何逃离？

│ │ │ ├─41-沟通之痛：如何改变？

│ │ │ ├─42-技术停滞：如何更新？

│ │ │ ├─43-无法实现：困扰与反思

│ │ │ ├─44-完成作品：理想与现实

│ │ │ ├─45-代码评审：寄望与哀伤

│ │ │ ├─46-人到中年：失业与恐惧

│ │ │ ├─47-该不该去创业公司？

│ │ │ ├─48-该不该接外包？

│ │ │ ├─49-技术干货那么多，如何选？

│ │ │ ├─50-技术分歧，如何决策？

│ │ │ ├─51-技术债务，有意或无意的选择？

│ │ │ ├─52-选择从众，还是唯一？

│ │ │ ├─53-选择工作，还是生活？

│ │ │ ├─54-侠客行：一技压身，天下行走

│ │ │ ├─55-江湖路：刀剑相接，战场升级

│ │ │ ├─56-御剑流：一击必杀，万剑归心

│ │ │ ├─57-三维度：专业、展现与连接

│ │ │ ├─58-三人行：前辈、平辈与后辈

│ │ │ ├─59-三角色：程序员、技术主管与架构师

│ │ │ ├─60-三视角：定位、自省与多维

│ │ │ ├─61-工作之余，专业之外

│ │ │ ├─62-跨越断层，突破边界

│ │ │ ├─63-成长蓝图，进化跃迁

│ │ │ ├─尾声-始于知，终于行

│ │ │ ├─开篇词-程序行知：走在同样的路上，遇见自己的风景

│ │ │ └─开篇词-程序行知：走在同样的路上，遇见自己的风景

│ │ ├─022-Go语言核心36讲

│ │ │ ├─01-工作区和GOPATH

│ │ │ ├─02-命令源码文件

│ │ │ ├─022-Go语言核心36讲

│ │ │ ├─03-库源码文件

│ │ │ ├─04-程序实体的那些事儿（上）

│ │ │ ├─05-程序实体的那些事儿（中）

│ │ │ ├─06-程序实体的那些事儿（下）

│ │ │ ├─07-数组和切片

│ │ │ ├─08-container包中的那些容器

│ │ │ ├─09-字典的操作和约束

│ │ │ ├─10-通道的基本操作

│ │ │ ├─11-通道的高级玩法

│ │ │ ├─12-使用函数的正确姿势

│ │ │ ├─13-结构体及其方法的使用法门

│ │ │ ├─14-接口类型的合理运用

│ │ │ ├─15-关于指针的有限操作

│ │ │ ├─16-go语句及其执行规则（上）

│ │ │ ├─17-go语句及其执行规则（下）

│ │ │ ├─18-if语句、for语句和switch语句

│ │ │ ├─19-错误处理（上）

│ │ │ ├─20-错误处理（下）

│ │ │ ├─21-panic函数、recover函数以及defer语句（上）

│ │ │ ├─22-panic函数、recover函数以及defer语句（下）

│ │ │ ├─23-测试的基本规则和流程（上）

│ │ │ ├─24-测试的基本规则和流程（下）

│ │ │ ├─25-更多的测试手法

│ │ │ ├─26-sync

│ │ │ ├─27-条件变量sync

│ │ │ ├─28-条件变量sync

│ │ │ ├─29-原子操作（上）

│ │ │ ├─30-原子操作（下）

│ │ │ ├─31-sync

│ │ │ ├─32-context

│ │ │ ├─33-临时对象池sync

│ │ │ ├─34-并发安全字典sync

│ │ │ ├─35-并发安全字典sync

│ │ │ ├─36-unicode与字符编码

│ │ │ ├─37-strings包与字符串操作

│ │ │ ├─38-bytes包与字节串操作（上）

│ │ │ ├─39-bytes包与字节串操作（下）

│ │ │ ├─40-io包中的接口和工具（上）

│ │ │ ├─41-io包中的接口和工具（下）

│ │ │ ├─42-bufio包中的数据类型（上）

│ │ │ ├─43-bufio包中的数据类型（下）

│ │ │ ├─44-使用os包中的API（上）

│ │ │ ├─45-使用os包中的API（下）

│ │ │ ├─46-访问网络服务

│ │ │ ├─47-基于HTTP协议的网络服务

│ │ │ ├─48-程序性能分析基础（上）

│ │ │ ├─49-程序性能分析基础（下）

│ │ │ ├─导读-写给0基础入门的Go语言学习者

│ │ │ ├─导读-学习专栏的正确姿势

│ │ │ ├─尾声-愿你披荆斩棘，所向无敌

│ │ │ ├─开篇词-跟着学，你也能成为Go语言高手

│ │ │ ├─新年彩蛋-完整版思考题答案

│ │ │ └─结课测试-这些Go语言的知识你都掌握了吗？

│ │ ├─023-技术管理实战36讲

│ │ │ ├─01-多年前的那些工程师都去哪了？

│ │ │ ├─02-我要不要做管理呢？内心好纠结！

│ │ │ ├─023-技术管理实战36讲

│ │ │ ├─03-哪些人比较容易走上管理岗位？

│ │ │ ├─04-我要不要转回去做技术呢？

│ │ │ ├─05-作为技术管理者，我如何保持技术判断力？

│ │ │ ├─06-我这样的风格能做管理吗？

│ │ │ ├─07-我能做好管理吗，大家服我吗？

│ │ │ ├─08-管理到底都做哪些事儿？

│ │ │ ├─09-从工程师到管理者，角色都发生了哪些变化？

│ │ │ ├─10-新经理常踩的坑儿有哪些？

│ │ │ ├─11-我刚开始带团队，从哪里着手呢？

│ │ │ ├─12-如何界定我团队是干什么的呢？

│ │ │ ├─13-如何为团队设定合理的目标呢？

│ │ │ ├─14-如何来规划团队的组织结构呢？

│ │ │ ├─15-我都要申请哪些资源呢？

│ │ │ ├─16-团队建设该从哪里入手？

│ │ │ ├─17-如何提升员工的个人能力？

│ │ │ ├─18-如何提升员工的工作意愿和积极性？

│ │ │ ├─19-如何兼顾团队分工的稳定性和灵活性？

│ │ │ ├─20-有什么方法可以有效提升团队凝聚力吗？

│ │ │ ├─21-如何物色和培养核心人才？

│ │ │ ├─22-如何建设团队文化，营造团队氛围？

│ │ │ ├─23-如何和低绩效员工谈绩效？

│ │ │ ├─24-如何让团建活动不再“收效甚微”？

│ │ │ ├─25-多任务并行该如何应对？

│ │ │ ├─26-如何确保项目的有效执行？

│ │ │ ├─27-如何让流程机制得到有效的执行？

│ │ │ ├─28-管理沟通那些事儿

│ │ │ ├─29-沟通经常鸡同鸭讲，说不到一块怎么办？

│ │ │ ├─30-如何掌控自己的情绪，以及如何管理情绪化的员工？

│ │ │ ├─31-我各方面做得都很好，就是做不好向上沟通

│ │ │ ├─32-横向沟通和非职权影响力

│ │ │ ├─33-向下沟通的常见实例解析

│ │ │ ├─34-管理沟通上有哪些常见的坑儿呢？

│ │ │ ├─35-从空降谈管理方法论的积累

│ │ │ ├─36-走出自己的管理之路

│ │ │ ├─复习课（一）-管理方法论和角色认知

│ │ │ ├─复习课（三）-团队建设

│ │ │ ├─复习课（二）-管理规划

│ │ │ ├─复习课（五）-管理沟通

│ │ │ ├─复习课（四）-任务管理

│ │ │ ├─开篇词-你为什么需要学管理？

│ │ │ ├─新书首发-《知行：技术人的管理之路》

│ │ │ └─结课测试-这些管理知识你都掌握了吗？

│ │ ├─024-从0开始学微服务

│ │ │ ├─01-到底什么是微服务？

│ │ │ ├─02-从单体应用走向服务化

│ │ │ ├─024-从0开始学微服务

│ │ │ ├─03-初探微服务架构

│ │ │ ├─04-如何发布和引用服务？

│ │ │ ├─05-如何注册和发现服务？

│ │ │ ├─06-如何实现RPC远程服务调用？

│ │ │ ├─07-如何监控微服务调用？

│ │ │ ├─08-如何追踪微服务调用？

│ │ │ ├─09-微服务治理的手段有哪些？

│ │ │ ├─10-Dubbo框架里的微服务组件

│ │ │ ├─11-服务发布和引用的实践

│ │ │ ├─12-如何将注册中心落地？

│ │ │ ├─13-开源服务注册中心如何选型？

│ │ │ ├─14-开源RPC框架如何选型？

│ │ │ ├─15-如何搭建一个可靠的监控系统？

│ │ │ ├─16-如何搭建一套适合你的服务追踪系统？

│ │ │ ├─17-如何识别服务节点是否存活？

│ │ │ ├─18-如何使用负载均衡算法？

│ │ │ ├─19-如何使用服务路由？

│ │ │ ├─20-服务端出现故障时该如何应对？

│ │ │ ├─21-服务调用失败时有哪些处理手段？

│ │ │ ├─22-如何管理服务配置？

│ │ │ ├─23-如何搭建微服务治理平台？

│ │ │ ├─24-微服务架构该如何落地？

│ │ │ ├─25-微服务为什么要容器化？

│ │ │ ├─26-微服务容器化运维：镜像仓库和资源调度

│ │ │ ├─27-微服务容器化运维：容器调度和服务编排

│ │ │ ├─28-微服务容器化运维：微博容器运维平台DCP

│ │ │ ├─29-微服务如何实现DevOps？

│ │ │ ├─30-如何做好微服务容量规划？

│ │ │ ├─31-微服务多机房部署实践

│ │ │ ├─32-微服务混合云部署实践

│ │ │ ├─33-下一代微服务架构ServiceMesh

│ │ │ ├─34-Istio：ServiceMesh的代表产品

│ │ │ ├─35-微博ServiceMesh实践之路（上）

│ │ │ ├─36-微博ServiceMesh实践之路（下）

│ │ │ ├─开篇词-微服务，从放弃到入门

│ │ │ ├─微博技术解密（上）-微博信息流是如何实现的？

│ │ │ ├─微博技术解密（下）-微博存储的那些事儿

│ │ │ ├─结束语-微服务，从入门到精通

│ │ │ ├─结课测试｜这些微服务知识你都掌握了吗？

│ │ │ ├─阿忠伯的特别放送-答疑解惑01

│ │ │ ├─阿忠伯的特别放送-答疑解惑02

│ │ │ └─阿忠伯的特别放送-答疑解惑02

│ │ ├─025-深入剖析Kubernetes

│ │ │ ├─01-预习篇·小鲸鱼大事记（一）：初出茅庐

│ │ │ ├─02-预习篇·小鲸鱼大事记（二）：崭露头角

│ │ │ ├─025-深入剖析Kubernetes

│ │ │ ├─03-预习篇·小鲸鱼大事记（三）：群雄并起

│ │ │ ├─04-预习篇·小鲸鱼大事记（四）：尘埃落定

│ │ │ ├─05-白话容器基础（一）：从进程说开去

│ │ │ ├─06-白话容器基础（二）：隔离与限制

│ │ │ ├─07-白话容器基础（三）：深入理解容器镜像

│ │ │ ├─08-白话容器基础（四）：重新认识Docker容器

│ │ │ ├─09-从容器到容器云：谈谈Kubernetes的本质

│ │ │ ├─10-Kubernetes一键部署利器：kubeadm

│ │ │ ├─11-从0到1：搭建一个完整的Kubernetes集群

│ │ │ ├─12-牛刀小试：我的第一个容器化应用

│ │ │ ├─13-为什么我们需要Pod？

│ │ │ ├─14-深入解析Pod对象（一）：基本概念

│ │ │ ├─15-深入解析Pod对象（二）：使用进阶

│ │ │ ├─16-编排其实很简单：谈谈“控制器”模型

│ │ │ ├─17-经典PaaS的记忆：作业副本与水平扩展

│ │ │ ├─18-深入理解StatefulSet（一）：拓扑状态

│ │ │ ├─19-深入理解StatefulSet（二）：存储状态

│ │ │ ├─20-深入理解StatefulSet（三）：有状态应用实践

│ │ │ ├─21-容器化守护进程的意义：DaemonSet

│ │ │ ├─22-撬动离线业务：Job与CronJob

│ │ │ ├─23-声明式API与Kubernetes编程范式

│ │ │ ├─24-深入解析声明式API（一）：API对象的奥秘

│ │ │ ├─25-深入解析声明式API（二）：编写自定义控制器

│ │ │ ├─26-基于角色的权限控制：RBAC

│ │ │ ├─27-聪明的微创新：Operator工作原理解读

│ │ │ ├─28-PV、PVC、StorageClass，这些到底在说啥？

│ │ │ ├─29-PV、PVC体系是不是多此一举？从本地持久化卷谈起

│ │ │ ├─30-编写自己的存储插件：FlexVolume与CSI

│ │ │ ├─31-容器存储实践：CSI插件编写指南

│ │ │ ├─32-浅谈容器网络

│ │ │ ├─33-深入解析容器跨主机网络

│ │ │ ├─34-Kubernetes网络模型与CNI网络插件

│ │ │ ├─35-解读Kubernetes三层网络方案

│ │ │ ├─36-为什么说Kubernetes只有softmulti-tenancy？

│ │ │ ├─37-找到容器不容易：Service、DNS与服务发现

│ │ │ ├─38-从外界连通Service与Service调试“三板斧”

│ │ │ ├─39-谈谈Service与Ingress

│ │ │ ├─40-Kubernetes的资源模型与资源管理

│ │ │ ├─41-十字路口上的Kubernetes默认调度器

│ │ │ ├─42-Kubernetes默认调度器调度策略解析

│ │ │ ├─43-Kubernetes默认调度器的优先级与抢占机制

│ │ │ ├─44-KubernetesGPU管理与DevicePlugin机制

│ │ │ ├─45-幕后英雄：SIG-Node与CRI

│ │ │ ├─46-解读CRI与容器运行时

│ │ │ ├─47-绝不仅仅是安全：KataContainers与gVisor

│ │ │ ├─48-Prometheus、MetricsServer与Kubernetes监控体系

│ │ │ ├─49-CustomMetrics-让AutoScaling不再“食之无味”

│ │ │ ├─50-让日志无处可逃：容器日志收集与管理

│ │ │ ├─51-谈谈Kubernetes开源社区和未来走向

│ │ │ ├─52-答疑：在问题中解决问题，在思考中产生思考

│ │ │ ├─开篇词-打通“容器技术”的任督二脉

│ │ │ ├─特别放送-2019年，容器技术生态会发生些什么？

│ │ │ ├─特别放送-基于Kubernetes的云原生应用管理，到底应该怎么做？

│ │ │ ├─结束语-Kubernetes：赢开发者赢天下

│ │ │ └─结课测试｜这些Kubernetes的相关知识，你都掌握了吗？

│ │ ├─026-数据结构与算法之美

│ │ │ ├─01-为什么要学习数据结构和算法？

│ │ │ ├─02-如何抓住重点，系统高效地学习数据结构与算法？

│ │ │ ├─026-数据结构与算法之美

│ │ │ ├─03-复杂度分析（上）：如何分析、统计算法的执行效率和资源消耗？

│ │ │ ├─04-复杂度分析（下）：浅析最好、最坏、平均、均摊时间复杂度

│ │ │ ├─05-数组：为什么很多编程语言中数组都从0开始编号？

│ │ │ ├─06-链表（上）：如何实现LRU缓存淘汰算法

│ │ │ ├─07-链表（下）：如何轻松写出正确的链表代码？

│ │ │ ├─08-栈：如何实现浏览器的前进和后退功能？

│ │ │ ├─09-队列：队列在线程池等有限资源池中的应用

│ │ │ ├─10-递归：如何用三行代码找到“最终推荐人”？

│ │ │ ├─11-排序（上）：为什么插入排序比冒泡排序更受欢迎？

│ │ │ ├─12-排序（下）：如何用快排思想在O(n)内查找第K大元素？

│ │ │ ├─13-线性排序：如何根据年龄给100万用户数据排序？

│ │ │ ├─14-排序优化：如何实现一个通用的、高性能的排序函数？

│ │ │ ├─15-二分查找（上）：如何用最省内存的方式实现快速查找功能？

│ │ │ ├─16-二分查找（下）：如何快速定位IP对应的省份地址？

│ │ │ ├─17-跳表：为什么Redis一定要用跳表来实现有序集合？

│ │ │ ├─18-散列表（上）：Word文档中的单词拼写检查功能是如何实现的？

│ │ │ ├─19-散列表（中）：如何打造一个工业级水平的散列表？

│ │ │ ├─20-散列表（下）：为什么散列表和链表经常会一起使用？

│ │ │ ├─21-哈希算法（上）：如何防止数据库中的用户信息被脱库？

│ │ │ ├─22-哈希算法（下）：哈希算法在分布式系统中有哪些应用？

│ │ │ ├─23-二叉树基础（上）：什么样的二叉树适合用数组来存储？

│ │ │ ├─24-二叉树基础（下）：有了如此高效的散列表，为什么还需要二叉树？

│ │ │ ├─25-红黑树（上）：为什么工程中都用红黑树这种二叉树？

│ │ │ ├─26-红黑树（下）：掌握这些技巧，你也可以实现一个红黑树

│ │ │ ├─27-递归树：如何借助树来求解递归算法的时间复杂度？

│ │ │ ├─28-堆和堆排序：为什么说堆排序没有快速排序快？

│ │ │ ├─29-堆的应用：如何快速获取到Top10最热门的搜索关键词？

│ │ │ ├─30-图的表示：如何存储微博、微信等社交网络中的好友关系？

│ │ │ ├─31-深度和广度优先搜索：如何找出社交网络中的三度好友关系？

│ │ │ ├─32-字符串匹配基础（上）：如何借助哈希算法实现高效字符串匹配？

│ │ │ ├─33-字符串匹配基础（中）：如何实现文本编辑器中的查找功能？

│ │ │ ├─34-字符串匹配基础（下）：如何借助BM算法轻松理解KMP算法？

│ │ │ ├─35-Trie树：如何实现搜索引擎的搜索关键词提示功能？

│ │ │ ├─36-AC自动机：如何用多模式串匹配实现敏感词过滤功能？

│ │ │ ├─37-贪心算法：如何用贪心算法实现Huffman压缩编码？

│ │ │ ├─38-分治算法：谈一谈大规模计算框架MapReduce中的分治思想

│ │ │ ├─39-回溯算法：从电影《蝴蝶效应》中学习回溯算法的核心思想

│ │ │ ├─40-初识动态规划：如何巧妙解决“双十一”购物时的凑单问题？

│ │ │ ├─41-动态规划理论：一篇文章带你彻底搞懂最优子结构、无后效性和重复子问题

│ │ │ ├─42-动态规划实战：如何实现搜索引擎中的拼写纠错功能？

│ │ │ ├─43-拓扑排序：如何确定代码源文件的编译依赖关系？

│ │ │ ├─44-最短路径：地图软件是如何计算出最优出行路径的？

│ │ │ ├─45-位图：如何实现网页爬虫中的URL去重功能？

│ │ │ ├─46-概率统计：如何利用朴素贝叶斯算法过滤垃圾短信？

│ │ │ ├─47-向量空间：如何实现一个简单的音乐推荐系统？

│ │ │ ├─48-B+树：MySQL数据库索引是如何实现的？

│ │ │ ├─49-搜索：如何用A-搜索算法实现游戏中的寻路功能？

│ │ │ ├─50-索引：如何在海量数据中快速查找某个数据？

│ │ │ ├─51-并行算法：如何利用并行处理提高算法的执行效率？

│ │ │ ├─52-算法实战（一）：剖析Redis常用数据类型对应的数据结构

│ │ │ ├─53-算法实战（二）：剖析搜索引擎背后的经典数据结构和算法

│ │ │ ├─54-算法实战（三）：剖析高性能队列Disruptor背后的数据结构和算法

│ │ │ ├─55-算法实战（四）：剖析微服务接口鉴权限流背后的数据结构和算法

│ │ │ ├─56-算法实战（五）：如何用学过的数据结构和算法实现一个短网址系统？

│ │ │ ├─《数据结构与算法之美》学习指导手册

│ │ │ ├─不定期福利第一期-数据结构与算法学习书单

│ │ │ ├─不定期福利第三期-测一测你的算法阶段学习成果

│ │ │ ├─不定期福利第二期-王争：羁绊前行的，不是肆虐的狂风，而是内心的迷茫

│ │ │ ├─不定期福利第四期-刘超：我是怎么学习《数据结构与算法之美》的？

│ │ │ ├─开篇词-从今天起，跨过“数据结构与算法”这道坎

│ │ │ ├─总结课-在实际开发中，如何权衡选择使用哪种数据结构和算法？

│ │ │ ├─打卡召集令-60天攻克数据结构与算法

│ │ │ ├─打卡召集令-第一阶段知识总结

│ │ │ ├─打卡召集令-第三阶段知识总结

│ │ │ ├─打卡召集令-第二阶段知识总结

│ │ │ ├─打卡召集令-第四阶段知识总结

│ │ │ ├─春节7天练-Day1：数组和链表

│ │ │ ├─春节7天练-Day2：栈、队列和递归

│ │ │ ├─春节7天练-Day3：排序和二分查找

│ │ │ ├─春节7天练-Day4：散列表和字符串

│ │ │ ├─春节7天练-Day5：二叉树和堆

│ │ │ ├─春节7天练-Day6：图

│ │ │ ├─春节7天练-Day7：贪心、分治、回溯和动态规划

│ │ │ ├─用户故事-Jerry银银：这一年我的脑海里只有算法

│ │ │ ├─用户故事-zixuan：站在思维的高处，才有足够的视野和能力欣赏“美”

│ │ │ ├─第2季回归-这一次，我们一起拿下设计模式！

│ │ │ ├─结束语-送君千里，终须一别

│ │ │ ├─结课测试｜这些数据结构与算法，你真的掌握了吗？

│ │ │ ├─课程迭代｜全新交付71讲音频

│ │ │ └─课程迭代｜全新交付71讲音频

│ │ ├─027-如何设计一个秒杀系统

│ │ │ ├─01-设计秒杀系统时应该注意的5个架构原则

│ │ │ ├─02-如何才能做好动静分离？有哪些方案可选？

│ │ │ ├─027-如何设计一个秒杀系统

│ │ │ ├─03-二八原则：有针对性地处理好系统的“热点数据”

│ │ │ ├─04-流量削峰这事应该怎么做？

│ │ │ ├─05-影响性能的因素有哪些？又该如何提高系统的性能？

│ │ │ ├─06-秒杀系统“减库存”设计的核心逻辑

│ │ │ ├─07-准备PlanB：如何设计兜底方案

│ │ │ ├─08-答疑解惑：缓存失效的策略应该怎么定？

│ │ │ ├─开篇词-秒杀系统架构设计都有哪些关键点？(1)

│ │ │ ├─开篇词-秒杀系统架构设计都有哪些关键点？

│ │ │ └─结课测试-这些秒杀系统的设计知识你都掌握了吗？

│ │ ├─028-白话法律42讲

│ │ │ ├─01“老周，我想知道”-常见法律认知盲区（一）

│ │ │ ├─028-白话法律42讲

│ │ │ ├─02“老周，我想知道”-律师就在你身边（二）

│ │ │ ├─03“老周，我想知道”-律师就在你身边（三）

│ │ │ ├─04“老周，我想知道”-律师就在你身边（四）

│ │ │ ├─05-创业未捷老板跑，社保工资哪里讨？

│ │ │ ├─06-保密还是“卖身”，霸王条款怎么看？

│ │ │ ├─07-编造流言蹭热度？看守所里降温度！

│ │ │ ├─08-合同在手欠款难收，报警有用吗？

│ │ │ ├─09-致创业：谁动了我的股权？

│ │ │ ├─10-又见猝死！工“殇”究竟是不是工伤？

│ │ │ ├─11-期权的“前世今生”

│ │ │ ├─12-裁员面前，你能做的还有什么？

│ │ │ ├─13-抄袭、盗图为什么做不得？

│ │ │ ├─14-加班、工资、休假，你知道多少？

│ │ │ ├─15-受贿原来这么“容易”

│ │ │ ├─16-今天你用“VPN”了吗？

│ │ │ ├─17-漏洞在眼前，可以悄悄破解吗？

│ │ │ ├─18-“爬虫”真的合法吗？

│ │ │ ├─19-非法集资到底是个啥？

│ │ │ ├─20-黄色网站？不仅仅是“黄色”罪名

│ │ │ ├─21-谁修改了我的积分资产？

│ │ │ ├─22-外挂真能大吉大利吗？

│ │ │ ├─23-如何看待“从删库到跑路”？

│ │ │ ├─24-“伪基站”是你的避风港吗？

│ │ │ ├─25-“网络诈骗”真的离你很远吗？

│ │ │ ├─26-智斗中介：“北上广”租房图鉴

│ │ │ ├─27-买买买！买房的“避坑”指南

│ │ │ ├─28-闪婚又闪离，彩礼怎么理？

│ │ │ ├─29-离婚还想和平？你要这么做

│ │ │ ├─30-遗产继承的爱恨情仇

│ │ │ ├─31-骗术升级？假结婚、假离婚的那些事儿

│ │ │ ├─32-孩子学校受伤，谁之过？

│ │ │ ├─33-如何让欠债还钱真正“天经地义”？

│ │ │ ├─34-从透支到盗刷：人人须知的银行卡纠纷

│ │ │ ├─35-远离“套路贷”的套路大全

│ │ │ ├─36-危险！酒驾为什么被罚那么重？

│ │ │ ├─37-老人倒地，“扶”“不服”？

│ │ │ ├─38-“能动手就别吵吵”，代价你真的知道吗？

│ │ │ ├─39-发生交通事故，如何处理？

│ │ │ ├─40-交通事故综合法宝

│ │ │ ├─41-婚姻家庭综合法宝

│ │ │ ├─42-买卖房屋综合法宝

│ │ │ ├─一键直达-法律专栏“食用”指南

│ │ │ ├─加餐-“新冠肺炎”影响下，17个常见法律问题解答

│ │ │ ├─开篇词-这年头，你真应该懂点法律常识

│ │ │ ├─结束语-法律，不会终止的篇章

│ │ │ └─结课测试-这些法律知识，你都掌握了吗？

│ │ ├─029-从0开始学大数据

│ │ │ ├─029-从0开始学大数据

│ │ │ ├─04-移动计算比移动数据更划算

│ │ │ ├─05-从RAID看垂直伸缩到水平伸缩的演化

│ │ │ ├─06-新技术层出不穷，HDFS依然是存储的王者

│ │ │ ├─07-为什么说MapReduce既是编程模型又是计算框架？

│ │ │ ├─08-MapReduce如何让数据完成一次旅行？

│ │ │ ├─09-为什么我们管Yarn叫作资源调度框架？

│ │ │ ├─10-模块答疑：我们能从Hadoop学到什么？

│ │ │ ├─11-Hive是如何让MapReduce实现SQL操作的？

│ │ │ ├─12-我们并没有觉得MapReduce速度慢，直到Spark出现

│ │ │ ├─13-同样的本质，为何Spark可以更高效？

│ │ │ ├─14-BigTable的开源实现：HBase

│ │ │ ├─15-流式计算的代表：Storm、Flink、SparkStreaming

│ │ │ ├─16-ZooKeeper是如何保证数据一致性的？

│ │ │ ├─17-模块答疑：这么多技术，到底都能用在什么场景里？

│ │ │ ├─18-如何自己开发一个大数据SQL引擎？

│ │ │ ├─19-Spark的性能优化案例分析（上）

│ │ │ ├─20-Spark的性能优化案例分析（下）

│ │ │ ├─21-从阿里内部产品看海量数据处理系统的设计（上）：Doris的立项

│ │ │ ├─22-从阿里内部产品看海量数据处理系统的设计（下）：架构与创新

│ │ │ ├─23-大数据基准测试可以带来什么好处？

│ │ │ ├─24-从大数据性能测试工具Dew看如何快速开发大数据系统

│ │ │ ├─25-模块答疑：我能从大厂的大数据开发实践中学到什么？

│ │ │ ├─26-互联网产品+大数据产品=大数据平台

│ │ │ ├─27-大数据从哪里来？

│ │ │ ├─28-知名大厂如何搭建大数据平台？

│ │ │ ├─29-盘点可供中小企业参考的商业大数据平台

│ │ │ ├─30-当大数据遇上物联网

│ │ │ ├─31-模块答疑：为什么大数据平台至关重要？

│ │ │ ├─32-互联网运营数据指标与可视化监控

│ │ │ ├─33-一个电商网站订单下降的数据分析案例

│ │ │ ├─34-A-B测试与灰度发布必知必会

│ │ │ ├─35-如何利用大数据成为“增长黑客”？

│ │ │ ├─36-模块答疑：为什么说数据驱动运营？

│ │ │ ├─37-如何对数据进行分类和预测？

│ │ │ ├─38-如何发掘数据之间的关系？

│ │ │ ├─39-如何预测用户的喜好？

│ │ │ ├─40-机器学习的数学原理是什么？

│ │ │ ├─41-从感知机到神经网络算法

│ │ │ ├─42-模块答疑：软件工程师如何进入人工智能领域？

│ │ │ ├─开篇词-为什么说每个软件工程师都应该懂大数据技术？

│ │ │ ├─所有的不确定都是机会——智慧写给你的新年寄语

│ │ │ ├─第2季回归丨大数据之后，让我们回归后端

│ │ │ ├─结束语-未来的你，有无限可能

│ │ │ ├─结课测试-这些大数据的知识你都掌握了吗？

│ │ │ ├─预习01-大数据技术发展史：大数据的前世今生

│ │ │ ├─预习02-大数据应用发展史：从搜索引擎到人工智能

│ │ │ ├─预习03-大数据应用领域：数据驱动一切

│ │ │ └─预习03-大数据应用领域：数据驱动一切

│ │ ├─030-MySQL实战45讲

│ │ │ ├─01-基础架构：一条SQL查询语句是如何执行的？

│ │ │ ├─02-日志系统：一条SQL更新语句是如何执行的？

│ │ │ ├─03-事务隔离：为什么你改了我还看不见？

│ │ │ ├─030-MySQL实战45讲

│ │ │ ├─04-深入浅出索引（上）

│ │ │ ├─05-深入浅出索引（下）

│ │ │ ├─06-全局锁和表锁：给表加个字段怎么有这么多阻碍？

│ │ │ ├─07-行锁功过：怎么减少行锁对性能的影响？

│ │ │ ├─08-事务到底是隔离的还是不隔离的？

│ │ │ ├─09-普通索引和唯一索引，应该怎么选择？

│ │ │ ├─10-MySQL为什么有时候会选错索引？

│ │ │ ├─11-怎么给字符串字段加索引？

│ │ │ ├─12-为什么我的MySQL会“抖”一下？

│ │ │ ├─13-为什么表数据删掉一半，表文件大小不变？

│ │ │ ├─14-count(-)这么慢，我该怎么办？

│ │ │ ├─15-答疑文章（一）：日志和索引相关问题

│ │ │ ├─16-“orderby”是怎么工作的？

│ │ │ ├─17-如何正确地显示随机消息？

│ │ │ ├─18-为什么这些SQL语句逻辑相同，性能却差异巨大？

│ │ │ ├─19-为什么我只查一行的语句，也执行这么慢？

│ │ │ ├─20-幻读是什么，幻读有什么问题？

│ │ │ ├─21-为什么我只改一行的语句，锁这么多？

│ │ │ ├─22-MySQL有哪些“饮鸩止渴”提高性能的方法？

│ │ │ ├─23-MySQL是怎么保证数据不丢的？

│ │ │ ├─24-MySQL是怎么保证主备一致的？

│ │ │ ├─25-MySQL是怎么保证高可用的？

│ │ │ ├─26-备库为什么会延迟好几个小时？

│ │ │ ├─27-主库出问题了，从库怎么办？

│ │ │ ├─28-读写分离有哪些坑？

│ │ │ ├─29-如何判断一个数据库是不是出问题了？

│ │ │ ├─30-答疑文章（二）：用动态的观点看加锁

│ │ │ ├─31-误删数据后除了跑路，还能怎么办？

│ │ │ ├─32-为什么还有kill不掉的语句？

│ │ │ ├─33-我查这么多数据，会不会把数据库内存打爆？

│ │ │ ├─34-到底可不可以使用join？

│ │ │ ├─35-join语句怎么优化？

│ │ │ ├─36-为什么临时表可以重名？

│ │ │ ├─37-什么时候会使用内部临时表？

│ │ │ ├─38-都说InnoDB好，那还要不要使用Memory引擎？

│ │ │ ├─39-自增主键为什么不是连续的？

│ │ │ ├─40-insert语句的锁为什么这么多？

│ │ │ ├─41-怎么最快地复制一张表？

│ │ │ ├─42-grant之后要跟着flushprivileges吗？

│ │ │ ├─43-要不要使用分区表？

│ │ │ ├─44-答疑文章（三）：说一说这些好问题

│ │ │ ├─45-自增id用完怎么办？

│ │ │ ├─开篇词-这一次，让我们一起来搞懂MySQL

│ │ │ ├─直播回顾-林晓斌：我的MySQL心路历程

│ │ │ ├─结束语-点线网面，一起构建MySQL知识网络

│ │ │ └─结课测试｜这些MySQL知识你都掌握了吗？

│ │ ├─031-Linux性能优化实战

│ │ │ ├─01-如何学习Linux性能优化？

│ │ │ ├─02-基础篇：到底应该怎么理解“平均负载”？

│ │ │ ├─03-基础篇：经常说的CPU上下文切换是什么意思？（上）

│ │ │ ├─031-Linux性能优化实战

│ │ │ ├─04-基础篇：经常说的CPU上下文切换是什么意思？（下）

│ │ │ ├─05-基础篇：某个应用的CPU使用率居然达到100%，我该怎么办？

│ │ │ ├─06-案例篇：系统的CPU使用率很高，但为啥却找不到高CPU的应用？

│ │ │ ├─07-案例篇：系统中出现大量不可中断进程和僵尸进程怎么办？（上）

│ │ │ ├─08-案例篇：系统中出现大量不可中断进程和僵尸进程怎么办？（下）

│ │ │ ├─09-基础篇：怎么理解Linux软中断？

│ │ │ ├─10-案例篇：系统的软中断CPU使用率升高，我该怎么办？

│ │ │ ├─11-套路篇：如何迅速分析出系统CPU的瓶颈在哪里？

│ │ │ ├─12-套路篇：CPU性能优化的几个思路

│ │ │ ├─13-答疑（一）：无法模拟出RES中断的问题，怎么办？

│ │ │ ├─14-答疑（二）：如何用perf工具分析Java程序？

│ │ │ ├─15-基础篇：Linux内存是怎么工作的？

│ │ │ ├─16-基础篇：怎么理解内存中的Buffer和Cache？

│ │ │ ├─17-案例篇：如何利用系统缓存优化程序的运行效率？

│ │ │ ├─18-案例篇：内存泄漏了，我该如何定位和处理？

│ │ │ ├─19-案例篇：为什么系统的Swap变高了（上）

│ │ │ ├─20-案例篇：为什么系统的Swap变高了？（下）

│ │ │ ├─21-套路篇：如何“快准狠”找到系统内存的问题？

│ │ │ ├─22-答疑（三）：文件系统与磁盘的区别是什么？

│ │ │ ├─23-基础篇：Linux文件系统是怎么工作的？

│ │ │ ├─24-基础篇：Linux磁盘I-O是怎么工作的（上）

│ │ │ ├─25-基础篇：Linux磁盘I-O是怎么工作的（下）

│ │ │ ├─26-案例篇：如何找出狂打日志的“内鬼”？

│ │ │ ├─27-案例篇：为什么我的磁盘I-O延迟很高？

│ │ │ ├─28-案例篇：一个SQL查询要15秒，这是怎么回事？

│ │ │ ├─29-案例篇：Redis响应严重延迟，如何解决？

│ │ │ ├─30-套路篇：如何迅速分析出系统I-O的瓶颈在哪里？

│ │ │ ├─31-套路篇：磁盘I-O性能优化的几个思路

│ │ │ ├─32-答疑（四）：阻塞、非阻塞I-O与同步、异步I-O的区别和联系

│ │ │ ├─33-关于Linux网络，你必须知道这些（上）

│ │ │ ├─34-关于Linux网络，你必须知道这些（下）

│ │ │ ├─35-基础篇：C10K和C1000K回顾

│ │ │ ├─36-套路篇：怎么评估系统的网络性能？

│ │ │ ├─37-案例篇：DNS解析时快时慢，我该怎么办？

│ │ │ ├─38-案例篇：怎么使用tcpdump和Wireshark分析网络流量？

│ │ │ ├─39-案例篇：怎么缓解DDoS攻击带来的性能下降问题？

│ │ │ ├─40-案例篇：网络请求延迟变大了，我该怎么办？

│ │ │ ├─41-案例篇：如何优化NAT性能？（上）

│ │ │ ├─42-案例篇：如何优化NAT性能？（下）

│ │ │ ├─43-套路篇：网络性能优化的几个思路（上）

│ │ │ ├─44-套路篇：网络性能优化的几个思路（下）

│ │ │ ├─45-答疑（五）：网络收发过程中，缓冲区位置在哪里？

│ │ │ ├─46-案例篇：为什么应用容器化后，启动慢了很多？

│ │ │ ├─47-案例篇：服务器总是时不时丢包，我该怎么办？（上）

│ │ │ ├─48-案例篇：服务器总是时不时丢包，我该怎么办？（下）

│ │ │ ├─49-案例篇：内核线程CPU利用率太高，我该怎么办？

│ │ │ ├─50-案例篇：动态追踪怎么用？（上）

│ │ │ ├─51-案例篇：动态追踪怎么用？（下）

│ │ │ ├─52-案例篇：服务吞吐量下降很厉害，怎么分析？

│ │ │ ├─53-套路篇：系统监控的综合思路

│ │ │ ├─54-套路篇：应用监控的一般思路

│ │ │ ├─55-套路篇：分析性能问题的一般步骤

│ │ │ ├─56-套路篇：优化性能问题的一般方法

│ │ │ ├─57-套路篇：Linux性能工具速查

│ │ │ ├─58-答疑（六）：容器冷启动如何性能分析？

│ │ │ ├─加餐（一）-书单推荐：性能优化和Linux系统原理

│ │ │ ├─加餐（二）-书单推荐：网络原理和Linux内核实现

│ │ │ ├─开篇词-别再让Linux性能问题成为你的绊脚石

│ │ │ ├─用户故事-“半路出家”，也要顺利拿下性能优化！

│ │ │ ├─用户故事-运维和开发工程师们怎么说？

│ │ │ ├─结束语-愿你攻克性能难关

│ │ │ └─结课测试｜这些Linux性能知识你都掌握了吗？

│ │ ├─032-Android开发高手课

│ │ │ ├─01-崩溃优化（上）：关于“崩溃”那些事儿

│ │ │ ├─02-崩溃优化（下）：应用崩溃了，你应该如何去分析？

│ │ │ ├─03-内存优化（上）：4GB内存时代，再谈内存优化

│ │ │ ├─032-Android开发高手课

│ │ │ ├─04-内存优化（下）：内存优化这件事，应该从哪里着手？

│ │ │ ├─05-卡顿优化（上）：你要掌握的卡顿分析方法

│ │ │ ├─06-卡顿优化（下）：如何监控应用卡顿？

│ │ │ ├─06补充篇-卡顿优化：卡顿现场与卡顿分析

│ │ │ ├─07-启动优化（上）：从启动过程看启动速度优化

│ │ │ ├─08-启动优化（下）：优化启动速度的进阶方法

│ │ │ ├─09-I-O优化（上）：开发工程师必备的I-O优化知识

│ │ │ ├─10-I-O优化（中）：不同I-O方式的使用场景是什么？

│ │ │ ├─11-I-O优化（下）：如何监控线上I-O操作？

│ │ │ ├─12-存储优化（上）：常见的数据存储方法有哪些？

│ │ │ ├─13-存储优化（中）：如何优化数据存储？

│ │ │ ├─14-存储优化（下）：数据库SQLite的使用和优化

│ │ │ ├─15-网络优化（上）：移动开发工程师必备的网络优化知识

│ │ │ ├─16-网络优化（中）：复杂多变的移动网络该如何优化？

│ │ │ ├─17-网络优化（下）：大数据下网络该如何监控？

│ │ │ ├─18-耗电优化（上）：从电量优化的演进看耗电分析

│ │ │ ├─19-耗电优化（下）：耗电的优化方法与线上监控

│ │ │ ├─20-UI优化（上）：UI渲染的几个关键概念

│ │ │ ├─21-UI优化（下）：如何优化UI渲染？

│ │ │ ├─22-包体积优化（上）：如何减少安装包大小？

│ │ │ ├─23-包体积优化（下）：资源优化的进阶实践

│ │ │ ├─24-想成为Android高手，你需要先搞定这三个问题

│ │ │ ├─25-如何提升组织与个人的研发效能？

│ │ │ ├─26-关于编译，你需要了解什么？

│ │ │ ├─27-编译插桩的三种方法：AspectJ、ASM、ReDex

│ │ │ ├─28-大数据与AI，如何高效地测试？

│ │ │ ├─29-从每月到每天，如何给版本发布提速？

│ │ │ ├─30-数据评估（上）：如何实现高可用的上报组件？

│ │ │ ├─31-数据评估（下）：什么是大数据平台？

│ │ │ ├─32-线上疑难问题该如何排查和跟踪？

│ │ │ ├─33-做一名有高度的移动开发工程师

│ │ │ ├─34-聊聊重构：优秀的架构都是演进而来的

│ │ │ ├─35-NativeHook技术，天使还是魔鬼？

│ │ │ ├─36-跨平台开发的现状与应用

│ │ │ ├─37-移动开发新大陆：工作三年半，移动开发转型手游开发

│ │ │ ├─38-移动开发新大陆：Android音视频开发

│ │ │ ├─39-移动开发新大陆：边缘智能计算的趋势

│ │ │ ├─40-动态化实践，如何选择适合自己的方案？

│ │ │ ├─41-聊聊Flutter，面对层出不穷的新技术该如何跟进？

│ │ │ ├─42-Android开发高手课学习心得

│ │ │ ├─AndroidJVMTI机制详解（内含福利彩蛋）

│ │ │ ├─Android工程师的“面试指南”

│ │ │ ├─Native下如何获取调用栈？

│ │ │ ├─专栏学得苦？可能你还需要一份配套学习书单

│ │ │ ├─专栏学得苦？可能是方法没找对

│ │ │ ├─导读-如何打造高质量的应用？

│ │ │ ├─开篇词-焦虑的移动开发者该如何破局？

│ │ │ ├─程序员修炼之路-设计能力的提升途径

│ │ │ ├─练习Sample跑起来-ASM插桩强化练习

│ │ │ ├─练习Sample跑起来-唯鹿同学的练习手记第1辑

│ │ │ ├─练习Sample跑起来-唯鹿同学的练习手记第2辑

│ │ │ ├─练习Sample跑起来-唯鹿同学的练习手记第3辑

│ │ │ ├─练习Sample跑起来-热点问题答疑第1期

│ │ │ ├─练习Sample跑起来-热点问题答疑第2期

│ │ │ ├─练习Sample跑起来-热点问题答疑第3期

│ │ │ ├─练习Sample跑起来-热点问题答疑第4期

│ │ │ ├─结束语-移动开发的今天和明天

│ │ │ ├─结课测试-这些Android知识，你都掌握了吗？

│ │ │ ├─聊聊Framework的学习方法

│ │ │ └─聊聊Framework的学习方法

│ │ ├─033-程序员的数学基础课

│ │ │ ├─01-二进制：不了解计算机的源头，你学什么编程

│ │ │ ├─02-余数：原来取余操作本身就是个哈希函数

│ │ │ ├─03-迭代法：不用编程语言的自带函数，你会如何计算平方根？

│ │ │ ├─033-程序员的数学基础课

│ │ │ ├─04-数学归纳法：如何用数学归纳提升代码的运行效率？

│ │ │ ├─05-递归（上）：泛化数学归纳，如何将复杂问题简单化？

│ │ │ ├─06-递归（下）：分而治之，从归并排序到MapReduce

│ │ │ ├─07-排列：如何让计算机学会“田忌赛马”？

│ │ │ ├─08-组合：如何让计算机安排世界杯的赛程？

│ │ │ ├─09-动态规划（上）：如何实现基于编辑距离的查询推荐？

│ │ │ ├─10-动态规划（下）：如何求得状态转移方程并进行编程实现？

│ │ │ ├─11-树的深度优先搜索（上）：如何才能高效率地查字典？

│ │ │ ├─12-树的深度优先搜索（下）：如何才能高效率地查字典？

│ │ │ ├─13-树的广度优先搜索（上）：人际关系的六度理论是真的吗？

│ │ │ ├─14-树的广度优先搜索（下）：为什么双向广度优先搜索的效率更高？

│ │ │ ├─15-从树到图：如何让计算机学会看地图？

│ │ │ ├─16-时间和空间复杂度（上）：优化性能是否只是“纸上谈兵”？

│ │ │ ├─17-时间和空间复杂度（下）：如何使用六个法则进行复杂度分析？

│ │ │ ├─18-总结课：数据结构、编程语句和基础算法体现了哪些数学思想？

│ │ │ ├─19-概率和统计：编程为什么需要概率和统计？

│ │ │ ├─20-概率基础（上）：一篇文章帮你理解随机变量、概率分布和期望值

│ │ │ ├─21-概率基础（下）：联合概率、条件概率和贝叶斯法则，这些概率公式究竟能做什么？

│ │ │ ├─22-朴素贝叶斯：如何让计算机学会自动分类？

│ │ │ ├─23-文本分类：如何区分特定类型的新闻？

│ │ │ ├─24-语言模型：如何使用链式法则和马尔科夫假设简化概率模型？

│ │ │ ├─25-马尔科夫模型：从PageRank到语音识别，背后是什么模型在支撑？

│ │ │ ├─26-信息熵：如何通过几个问题，测出你对应的武侠人物？

│ │ │ ├─27-决策树：信息增益、增益比率和基尼指数的运用

│ │ │ ├─28-熵、信息增益和卡方：如何寻找关键特征？

│ │ │ ├─29-归一化和标准化：各种特征如何综合才是最合理的？

│ │ │ ├─30-统计意义（上）：如何通过显著性检验，判断你的A-B测试结果是不是巧合？

│ │ │ ├─31-统计意义（下）：如何通过显著性检验，判断你的A-B测试结果是不是巧合？

│ │ │ ├─32-概率统计篇答疑和总结：为什么会有欠拟合和过拟合？

│ │ │ ├─33-线性代数：线性代数到底都讲了些什么？

│ │ │ ├─34-向量空间模型：如何让计算机理解现实事物之间的关系？

│ │ │ ├─35-文本检索：如何让计算机处理自然语言？

│ │ │ ├─36-文本聚类：如何过滤冗余的新闻？

│ │ │ ├─37-矩阵（上）：如何使用矩阵操作进行PageRank计算？

│ │ │ ├─38-矩阵（下）：如何使用矩阵操作进行协同过滤推荐？

│ │ │ ├─39-线性回归（上）：如何使用高斯消元求解线性方程组？

│ │ │ ├─40-线性回归（中）：如何使用最小二乘法进行直线拟合？

│ │ │ ├─41-线性回归（下）：如何使用最小二乘法进行效果验证？

│ │ │ ├─42-PCA主成分分析（上）：如何利用协方差矩阵来降维？

│ │ │ ├─43-PCA主成分分析（下）：为什么要计算协方差矩阵的特征值和特征向量？

│ │ │ ├─44-奇异值分解：如何挖掘潜在的语义关系？

│ │ │ ├─45-线性代数篇答疑和总结：矩阵乘法的几何意义是什么？

│ │ │ ├─46-缓存系统：如何通过哈希表和队列实现高效访问？

│ │ │ ├─47-搜索引擎（上）：如何通过倒排索引和向量空间模型，打造一个简单的搜索引擎？

│ │ │ ├─48-搜索引擎（下）：如何通过查询的分类，让电商平台的搜索结果更相关？

│ │ │ ├─49-推荐系统（上）：如何实现基于相似度的协同过滤？

│ │ │ ├─50-推荐系统（下）：如何通过SVD分析用户和物品的矩阵？

│ │ │ ├─51-综合应用篇答疑和总结：如何进行个性化用户画像的设计？

│ │ │ ├─导读：程序员应该怎么学数学？

│ │ │ ├─开篇词-作为程序员，为什么你应该学好数学？

│ │ │ ├─数学专栏课外加餐（一）-我们为什么需要反码和补码？

│ │ │ ├─数学专栏课外加餐（三）：程序员需要读哪些数学书？

│ │ │ ├─数学专栏课外加餐（二）-位操作的三个应用实例

│ │ │ ├─结束语-从数学到编程，本身就是一个很长的链条

│ │ │ └─结课测试-这些数学知识你都掌握了吗？

│ │ ├─034-数据分析实战45讲

│ │ │ ├─01丨数据分析全景图及修炼指南

│ │ │ ├─02丨学习数据挖掘的最佳路径是什么？

│ │ │ ├─034-数据分析实战45讲

│ │ │ ├─03丨Python基础语法：开始你的Python之旅

│ │ │ ├─04丨Python科学计算：用NumPy快速处理数据

│ │ │ ├─05丨Python科学计算：Pandas

│ │ │ ├─06-学数据分析要掌握哪些基本概念？

│ │ │ ├─07-用户画像：标签化就是数据的抽象能力

│ │ │ ├─08-数据采集：如何自动化采集数据？

│ │ │ ├─09丨数据采集：如何用八爪鱼采集微博上的“D&G”评论

│ │ │ ├─10丨Python爬虫：如何自动化下载王祖贤海报？

│ │ │ ├─11-数据科学家80%时间都花费在了这些清洗任务上？

│ │ │ ├─12-数据集成：这些大号一共20亿粉丝？

│ │ │ ├─13-数据变换：考试成绩要求正态分布合理么？

│ │ │ ├─14丨数据可视化：掌握数据领域的万金油技能

│ │ │ ├─15丨一次学会Python数据可视化的10种技能

│ │ │ ├─16丨数据分析基础篇答疑

│ │ │ ├─17丨决策树（上）：要不要去打篮球？决策树来告诉你

│ │ │ ├─18丨决策树（中）：CART，一棵是回归树，另一棵是分类树

│ │ │ ├─19丨决策树（下）：泰坦尼克乘客生存预测

│ │ │ ├─20丨朴素贝叶斯分类（上）：如何让机器判断男女？

│ │ │ ├─21丨朴素贝叶斯分类（下）：如何对文档进行分类？

│ │ │ ├─22丨SVM（上）：如何用一根棍子将蓝红两色球分开？

│ │ │ ├─23丨SVM（下）：如何进行乳腺癌检测？

│ │ │ ├─24丨KNN（上）：如何根据打斗和接吻次数来划分电影类型？

│ │ │ ├─25丨KNN（下）：如何对手写数字进行识别？

│ │ │ ├─26丨K-Means（上）：如何给20支亚洲球队做聚类？

│ │ │ ├─27丨K-Means（下）：如何使用K-Means对图像进行分割？

│ │ │ ├─28丨EM聚类（上）：如何将一份菜等分给两个人？

│ │ │ ├─29丨EM聚类（下）：用EM算法对王者荣耀英雄进行划分

│ │ │ ├─30丨关联规则挖掘（上）：如何用Apriori发现用户购物规则？

│ │ │ ├─31丨关联规则挖掘（下）：导演如何选择演员？

│ │ │ ├─32丨PageRank（上）：搞懂Google的PageRank算法

│ │ │ ├─33丨PageRank（下）：分析希拉里邮件中的人物关系

│ │ │ ├─34丨AdaBoost（上）：如何使用AdaBoost提升分类器性能？

│ │ │ ├─35丨AdaBoost（下）：如何使用AdaBoost对房价进行预测？

│ │ │ ├─36丨数据分析算法篇答疑

│ │ │ ├─37丨数据采集实战：如何自动化运营微博？

│ │ │ ├─38丨数据可视化实战：如何给毛不易的歌曲做词云展示？

│ │ │ ├─39丨数据挖掘实战（1）：信用卡违约率分析

│ │ │ ├─40丨数据挖掘实战（2）：信用卡诈骗分析

│ │ │ ├─41丨数据挖掘实战（3）：如何对比特币走势进行预测？

│ │ │ ├─42丨当我们谈深度学习的时候，我们都在谈什么？

│ │ │ ├─43丨深度学习（下）：如何用Keras搭建深度学习网络做手写数字识别？

│ │ │ ├─44丨如何培养你的数据分析思维？

│ │ │ ├─45丨求职简历中没有相关项目经验，怎么办？

│ │ │ ├─加餐丨在社交网络上刷粉刷量，技术上是如何实现的？

│ │ │ ├─开篇词-你为什么需要数据分析能力？

│ │ │ ├─结束语丨当大家都在讲知识和工具的时候，我更希望你重视思维和实战

│ │ │ └─结课测试-数据分析的这些知识，你真的掌握了吗？

│ │ ├─035-10x程序员工作法

│ │ │ ├─01-10x程序员是如何思考的？

│ │ │ ├─02-以终为始：如何让你的努力不白费？

│ │ │ ├─03-DoD的价值：你完成了工作，为什么他们还不满意？

│ │ │ ├─035-10x程序员工作法

│ │ │ ├─04-接到需求任务，你要先做哪件事？

│ │ │ ├─05-持续集成：集成本身就是写代码的一个环节

│ │ │ ├─06-精益创业：产品经理不靠谱，你该怎么办？

│ │ │ ├─07-解决了很多技术问题，为什么你依然在“坑”里？

│ │ │ ├─08-为什么说做事之前要先进行推演？

│ │ │ ├─09-你的工作可以用数字衡量吗？

│ │ │ ├─10-迭代0-启动开发之前，你应该准备什么？

│ │ │ ├─11-向埃隆·马斯克学习任务分解

│ │ │ ├─12-测试也是程序员的事吗？

│ │ │ ├─13-先写测试，就是测试驱动开发吗？

│ │ │ ├─14-大师级程序员的工作秘笈

│ │ │ ├─15-一起练习：手把手带你分解任务

│ │ │ ├─16-为什么你的测试不够好？

│ │ │ ├─17-程序员也可以“砍”需求吗？

│ │ │ ├─18-需求管理：太多人给你安排任务，怎么办？

│ │ │ ├─19-如何用最小的代价做产品？

│ │ │ ├─20-为什么世界和你的理解不一样？

│ │ │ ├─21-你的代码为谁而写？

│ │ │ ├─22-轻量级沟通：你总是在开会吗？

│ │ │ ├─23-可视化：一种更为直观的沟通方式

│ │ │ ├─24-快速反馈：为什么你们公司总是做不好持续集成？

│ │ │ ├─25-开发中的问题一再出现，应该怎么办？

│ │ │ ├─26-作为程序员，你也应该聆听用户声音

│ │ │ ├─27-尽早暴露问题：为什么被指责的总是你？

│ │ │ ├─28-结构化：写文档也是一种学习方式

│ │ │ ├─29-“懒惰”应该是所有程序员的骄傲

│ │ │ ├─30-一个好的项目自动化应该是什么样子的？

│ │ │ ├─31-程序员怎么学习运维知识？

│ │ │ ├─32-持续交付：有持续集成就够了吗？

│ │ │ ├─33-如何做好验收测试？

│ │ │ ├─34-你的代码是怎么变混乱的？

│ │ │ ├─35-总是在说MVC分层架构，但你真的理解分层吗？

│ │ │ ├─36-为什么总有人觉得5万块钱可以做一个淘宝？

│ │ │ ├─37-先做好DDD再谈微服务吧，那只是一种部署形式

│ │ │ ├─38-新入职一家公司，怎么快速进入工作状态？

│ │ │ ├─39-面对遗留系统，你应该这样做

│ │ │ ├─40-我们应该如何保持竞争力？

│ │ │ ├─划重点-“综合运用”主题内容的全盘回顾

│ │ │ ├─划重点-“自动化”主题的重点内容回顾汇总

│ │ │ ├─划重点-一次关于“沟通反馈”主题内容的复盘

│ │ │ ├─划重点-关于“以终为始”，你要记住的9句话

│ │ │ ├─划重点-关于“任务分解”，你要重点掌握哪些事？

│ │ │ ├─加餐-你真的了解重构吗？

│ │ │ ├─开篇词-程序员解决的问题，大多不是程序问题

│ │ │ ├─总复习-重新审视“最佳实践”

│ │ │ ├─总复习-重新来“看书”

│ │ │ ├─用户故事-站在前人的肩膀上，领取属于你的高效工作秘籍

│ │ │ ├─第三季回归-我们一起来写好代码！

│ │ │ ├─第二季回归-我带着软件设计课回来了！

│ │ │ ├─第四季回归-通向高质量代码之路

│ │ │ ├─答疑解惑-如何分解一个你不了解的技术任务？

│ │ │ ├─答疑解惑-如何在实际工作中推行新观念？

│ │ │ ├─答疑解惑-如何管理你的上级？

│ │ │ ├─答疑解惑-持续集成、持续交付，然后呢？

│ │ │ ├─答疑解惑-持续集成，一条贯穿诸多实践的主线

│ │ │ ├─结束语-少做事，才能更有效地工作

│ │ │ └─结课测试-这些10x程序员工作法的知识你都掌握了吗？

│ │ ├─036-代码精进之路

│ │ │ ├─01-从条件运算符说起，反思什么是好代码

│ │ │ ├─02-把错误关在笼子里的五道关卡

│ │ │ ├─03-优秀程序员的六个关键特质

│ │ │ ├─036-代码精进之路

│ │ │ ├─04-代码规范的价值：复盘苹果公司的GoToFail漏洞

│ │ │ ├─05-经验总结：如何给你的代码起好名字？

│ │ │ ├─06-代码整理的关键逻辑和最佳案例

│ │ │ ├─07-写好注释，真的是小菜一碟吗？

│ │ │ ├─08-写好声明的“八项纪律”

│ │ │ ├─09-怎么用好Java注解？

│ │ │ ├─10-异常处理都有哪些陷阱？

│ │ │ ├─11-组织好代码段，让人对它“一见钟情”

│ │ │ ├─12丨组织好代码文件，要有“用户思维”

│ │ │ ├─13-接口规范，是协作的合约

│ │ │ ├─14-怎么写好用户指南？

│ │ │ ├─15-编写规范代码的检查清单

│ │ │ ├─16丨代码“规范”篇用户答疑

│ │ │ ├─17-为什么需要经济的代码？

│ │ │ ├─18丨思考框架：什么样的代码才是高效的代码？

│ │ │ ├─19-怎么避免过度设计？

│ │ │ ├─20-简单和直观，是永恒的解决方案

│ │ │ ├─21-怎么设计一个简单又直观的接口？

│ │ │ ├─22丨高效率，从超越线程同步开始！

│ │ │ ├─23-怎么减少内存使用，减轻内存管理负担？

│ │ │ ├─24-黑白灰，理解延迟分配的两面性

│ │ │ ├─25-使用有序的代码，调动异步的事件

│ │ │ ├─26-有哪些招惹麻烦的性能陷阱？

│ │ │ ├─27-怎么编写可持续发展的代码？

│ │ │ ├─28-怎么尽量“不写”代码？

│ │ │ ├─29-编写经济代码的检查清单

│ │ │ ├─30丨“代码经济篇”答疑汇总

│ │ │ ├─31-为什么安全的代码这么重要？

│ │ │ ├─32-如何评估代码的安全缺陷？

│ │ │ ├─33-整数的运算有哪些安全威胁？

│ │ │ ├─34-数组和集合，可变量的安全陷阱

│ │ │ ├─35-怎么处理敏感信息？

│ │ │ ├─36-继承有什么安全缺陷？

│ │ │ ├─37-边界，信任的分水岭

│ │ │ ├─38-对象序列化的危害有多大？

│ │ │ ├─39-怎么控制好代码的权力？

│ │ │ ├─40-规范，代码长治久安的基础

│ │ │ ├─41-预案，代码的主动风险管理

│ │ │ ├─42-纵深，代码安全的深度防御

│ │ │ ├─43-编写安全代码的最佳实践清单

│ │ │ ├─44-“代码安全篇”答疑汇总

│ │ │ ├─Q&A加餐丨关于代码质量，你关心的那些事儿

│ │ │ ├─开篇词-你写的每一行代码，都是你的名片

│ │ │ ├─期末测试丨有关代码编写的那些准则，你掌握了多少呢？

│ │ │ ├─结束语｜如何成为一个编程好手？

│ │ │ └─结束语｜如何成为一个编程好手？

│ │ ├─037-重学前端

│ │ │ ├─037-重学前端

│ │ │ ├─CSSFlex排版：为什么垂直居中这么难？

│ │ │ ├─CSS动画与交互：为什么动画要用贝塞尔曲线这么奇怪的东西？

│ │ │ ├─CSS小实验：动手做，用代码挖掘CSS属性

│ │ │ ├─CSS排版：从毕升开始，我们就开始用正常流了

│ │ │ ├─CSS渲染：CSS是如何绘制颜色的？

│ │ │ ├─CSS语法：除了属性和选择器，你还需要知道这些带@的规则

│ │ │ ├─CSS选择器：伪元素是怎么回事儿？

│ │ │ ├─CSS选择器：如何选中svg里的a元素？

│ │ │ ├─HTML·ARIA：可访问性是只给盲人用的特性么？

│ │ │ ├─HTML元信息类标签：你知道head里一共能写哪几种标签吗？

│ │ │ ├─HTML小实验：用代码分析HTML标准

│ │ │ ├─HTML替换型元素：为什么link一个CSS要用href，而引入js要用src呢？

│ │ │ ├─HTML语义：div和span不是够用了吗？

│ │ │ ├─HTML语义：如何运用语义类标签来呈现Wiki网页？

│ │ │ ├─HTML语言：DTD到底是什么？

│ │ │ ├─HTML链接：除了a标签，还有哪些标签叫链接？

│ │ │ ├─JavaScript对象：你知道全部的对象分类吗？

│ │ │ ├─JavaScript对象：我们真的需要模拟类吗？

│ │ │ ├─JavaScript对象：面向对象还是基于对象？

│ │ │ ├─JavaScript执行（一）：Promise里的代码为什么比setTimeout先执行？

│ │ │ ├─JavaScript执行（三）：你知道现在有多少种函数吗？

│ │ │ ├─JavaScript执行（二）：闭包和执行上下文到底是怎么回事？

│ │ │ ├─JavaScript执行（四）：try里面放return，finally还会执行吗？

│ │ │ ├─JavaScript类型：关于类型，有哪些你不知道的细节？

│ │ │ ├─JavaScript词法：为什么12

│ │ │ ├─JavaScript语法（一）：在script标签写export为什么会抛错？

│ │ │ ├─JavaScript语法（三）：什么是表达式语句？

│ │ │ ├─JavaScript语法（二）：你知道哪些JavaScript语句？

│ │ │ ├─JavaScript语法（四）：新加入的-运算符，哪里有些不一样呢？

│ │ │ ├─JavaScript语法（预备篇）：到底要不要写分号呢？

│ │ │ ├─列一份前端知识架构图

│ │ │ ├─前端架构：前端架构有哪些核心问题？

│ │ │ ├─加餐-前端与图形学

│ │ │ ├─加餐-前端交互基础设施的建设

│ │ │ ├─尾声-长风破浪会有时，直挂云帆济沧海

│ │ │ ├─工具链：什么样的工具链才能提升团队效率？

│ │ │ ├─开篇词-从今天起，重新理解前端

│ │ │ ├─性能：前端的性能到底对业务数据有多大的影响？

│ │ │ ├─持续集成：几十个前端一起工作，如何保证工作质量？

│ │ │ ├─搭建系统：大量的低价值需求应该如何应对？

│ │ │ ├─新年彩蛋-2019，有哪些前端技术值得关注？

│ │ │ ├─明确你的前端学习路线与方法

│ │ │ ├─期中答疑-name(){}与name-function(){}，两种写法有什么区别吗？

│ │ │ ├─期末答疑（一）：前端代码单元测试怎么做？

│ │ │ ├─期末答疑（二）：前端架构中，每个逻辑页面如何可以做到独立发布呢？

│ │ │ ├─浏览器API（小实验）：动手整理全部API

│ │ │ ├─浏览器CSSOM：如何获取一个元素的准确位置

│ │ │ ├─浏览器DOM：你知道HTML的节点有哪几种吗？

│ │ │ ├─浏览器事件：为什么会有捕获过程和冒泡过程？

│ │ │ ├─浏览器：一个浏览器是如何工作的（阶段三）

│ │ │ ├─浏览器：一个浏览器是如何工作的？（阶段一）

│ │ │ ├─浏览器：一个浏览器是如何工作的？（阶段二）

│ │ │ ├─浏览器：一个浏览器是如何工作的？（阶段五）

│ │ │ ├─浏览器：一个浏览器是如何工作的？（阶段四）

│ │ │ ├─用户故事-那些你与“重学前端”的不解之缘

│ │ │ ├─答疑加餐-学了这么多前端的“小众”知识，到底对我有什么帮助？

│ │ │ ├─（小实验）理解编译原理：一个四则运算的解释器

│ │ │ └─（小实验）理解编译原理：一个四则运算的解释器

│ │ ├─038-面试现场

│ │ │ ├─01-公司到底想要什么样的人？

│ │ │ ├─01-考官面对面：程序员择业时常碰到的几个疑惑

│ │ │ ├─02-想要成功面试，先要弄懂面试过程

│ │ │ ├─02-考官面对面：如何有效地准备一场面试？

│ │ │ ├─03-考官面对面：面试注意事项及面试官常见的思维模式

│ │ │ ├─03-面试官的面试逻辑是什么？

│ │ │ ├─038-面试现场

│ │ │ ├─04-现在的你，到底该不该换工作

│ │ │ ├─04-考官面对面：面试与应聘，如何站在对方的角度考虑问题？

│ │ │ ├─05-喜欢或擅长的工作，你该选哪一个？

│ │ │ ├─05-考官面对面：我是如何面试程序员的？

│ │ │ ├─06-考官面对面：我们是如何面试架构师的？

│ │ │ ├─06-职业规划一：你真的想好要怎么发展了吗？

│ │ │ ├─07-考官面对面：面试经验谈之校招与社招

│ │ │ ├─07-职业规划二：程序员后来都去干啥了？

│ │ │ ├─08-如何让你的简历更受青睐

│ │ │ ├─09-经历没有亮点可讲？你需要做份“详历”

│ │ │ ├─10-面试紧张怎么办？

│ │ │ ├─11-面试答疑（一）：说说你面试中的一些困惑

│ │ │ ├─12-如何做好开场：给自我介绍加“特效”

│ │ │ ├─13-你真能讲明白技术吗

│ │ │ ├─14-怎样展示你在项目中的重要性？

│ │ │ ├─15-如何认识自己的优缺点？

│ │ │ ├─16-透过兴趣爱好，面试官可以看出什么？

│ │ │ ├─17-如何让你的回答更到位？

│ │ │ ├─18-被面试官问住了怎么办？

│ │ │ ├─19-应该如何向面试官提问？

│ │ │ ├─20-怎么谈薪水比较好？

│ │ │ ├─21-面试答疑（二）：面试问答环节的一些思考

│ │ │ ├─22-怎样体现你的学习能力强？

│ │ │ ├─23-怎么体现你能把工作越做越好？

│ │ │ ├─24-怎样体现你的协作能力强？

│ │ │ ├─25-不是领导，怎么体现你的领导力？

│ │ │ ├─26-你解决问题的能力有多强？

│ │ │ ├─27-盘点面试官和应聘者的认知差异

│ │ │ ├─28-通过面试，你能了解这个团队多少？

│ │ │ ├─29-合同都签了，老板却不放你走，怎么办？

│ │ │ ├─30-面试答疑（三）：如何更好地体现你的能力？

│ │ │ ├─开篇词-面试，这样做会功到自然成

│ │ │ ├─结束语-以终为始，闭环迭代，持续提高

│ │ │ └─结课测试｜这些面试技巧你都掌握了吗？

│ │ ├─039-软件工程之美

│ │ │ ├─01-到底应该怎样理解软件工程？

│ │ │ ├─02-工程思维：把每件事都当作一个项目来推进

│ │ │ ├─03-瀑布模型：像工厂流水线一样把软件开发分层化

│ │ │ ├─039-软件工程之美

│ │ │ ├─04-瀑布模型之外，还有哪些开发模型？

│ │ │ ├─05-敏捷开发到底是想解决什么问题？

│ │ │ ├─06-大厂都在用哪些敏捷方法？（上）

│ │ │ ├─07-大厂都在用哪些敏捷方法？（下）

│ │ │ ├─08-怎样平衡软件质量与时间成本范围的关系？

│ │ │ ├─09-为什么软件工程项目普遍不重视可行性分析？

│ │ │ ├─10-如果你想技术转管理，先来试试管好一个项目

│ │ │ ├─11-项目计划：代码未动，计划先行

│ │ │ ├─12-流程和规范：红绿灯不是约束，而是用来提高效率

│ │ │ ├─13-白天开会，加班写代码的节奏怎么破？

│ │ │ ├─14-项目管理工具：一切管理问题，都应思考能否通过工具解决

│ │ │ ├─15-风险管理：不能盲目乐观，凡事都应该有B计划

│ │ │ ├─16-怎样才能写好项目文档？

│ │ │ ├─17-需求分析到底要分析什么？怎么分析？

│ │ │ ├─18-原型设计：如何用最小的代价完成产品特性？

│ │ │ ├─19-作为程序员，你应该有产品意识

│ │ │ ├─20-如何应对让人头疼的需求变更问题？

│ │ │ ├─21-架构设计：普通程序员也能实现复杂系统？

│ │ │ ├─22-如何为项目做好技术选型？

│ │ │ ├─23-架构师：不想当架构师的程序员不是好程序员

│ │ │ ├─24-技术债务：是继续修修补补凑合着用，还是推翻重来？

│ │ │ ├─25-有哪些方法可以提高开发效率？

│ │ │ ├─26-持续交付：如何做到随时发布新版本到生产环境？

│ │ │ ├─27-软件工程师的核心竞争力是什么？（上）

│ │ │ ├─28-软件工程师的核心竞争力是什么？（下）

│ │ │ ├─29-自动化测试：如何把Bug杀死在摇篮里？

│ │ │ ├─30-用好源代码管理工具，让你的协作更高效

│ │ │ ├─31-软件测试要为产品质量负责吗？

│ │ │ ├─32-软件测试：什么样的公司需要专职测试？

│ │ │ ├─33-测试工具：为什么不应该通过QQ-微信-邮件报Bug？

│ │ │ ├─34-账号密码泄露成灾，应该怎样预防？

│ │ │ ├─35-版本发布：软件上线只是新的开始

│ │ │ ├─36-DevOps工程师到底要做什么事情？

│ │ │ ├─37-遇到线上故障，你和高手的差距在哪里？

│ │ │ ├─38-日志管理：如何借助工具快速发现和定位产品问题？

│ │ │ ├─39-项目总结：做好项目复盘，把经验变成能力

│ │ │ ├─40-最佳实践：小团队如何应用软件工程？

│ │ │ ├─41-为什么程序员的业余项目大多都死了？

│ │ │ ├─42-反面案例：盘点那些失败的软件项目

│ │ │ ├─43-以VSCode为例，看大型开源项目是如何应用软件工程的？

│ │ │ ├─44-微软、谷歌、阿里巴巴等大厂是怎样应用软件工程的？

│ │ │ ├─45-从软件工程的角度看微服务、云计算、人工智能这些新技术

│ │ │ ├─“一问一答”第1期-30个软件开发常见问题解决策略

│ │ │ ├─“一问一答”第2期-30个软件开发常见问题解决策略

│ │ │ ├─“一问一答”第3期-18个软件开发常见问题解决策略

│ │ │ ├─“一问一答”第4期-14个软件开发常见问题解决策略

│ │ │ ├─“一问一答”第5期（内含彩蛋）-22个软件开发常见问题解决策略

│ │ │ ├─学习攻略-怎样学好软件工程？

│ │ │ ├─开篇词-你为什么应该学好软件工程？

│ │ │ ├─特别放送-从软件工程的角度解读任正非的新年公开信

│ │ │ ├─结束语-万事皆项目，软件工程无处不在

│ │ │ └─结课测试-这些软件工程知识，你都掌握了吗？

│ │ ├─040-Java并发编程实战

│ │ │ ├─01-可见性、原子性和有序性问题：并发编程Bug的源头

│ │ │ ├─02-Java内存模型：看Java如何解决可见性和有序性问题

│ │ │ ├─03-互斥锁（上）：解决原子性问题

│ │ │ ├─04-互斥锁（下）：如何用一把锁保护多个资源？

│ │ │ ├─040-Java并发编程实战

│ │ │ ├─05-一不小心就死锁了，怎么办？

│ │ │ ├─06-用“等待-通知”机制优化循环等待

│ │ │ ├─07-安全性、活跃性以及性能问题

│ │ │ ├─08-管程：并发编程的万能钥匙

│ │ │ ├─09-Java线程（上）：Java线程的生命周期

│ │ │ ├─10-Java线程（中）：创建多少线程才是合适的？

│ │ │ ├─11-Java线程（下）：为什么局部变量是线程安全的？

│ │ │ ├─12-如何用面向对象思想写好并发程序？

│ │ │ ├─13-理论基础模块热点问题答疑

│ │ │ ├─14-Lock和Condition（上）：隐藏在并发包中的管程

│ │ │ ├─15-Lock和Condition（下）：Dubbo如何用管程实现异步转同步？

│ │ │ ├─16-Semaphore：如何快速实现一个限流器？

│ │ │ ├─17-ReadWriteLock：如何快速实现一个完备的缓存？

│ │ │ ├─18-StampedLock：有没有比读写锁更快的锁？

│ │ │ ├─19-CountDownLatch和CyclicBarrier：如何让多线程步调一致？

│ │ │ ├─20-并发容器：都有哪些“坑”需要我们填？

│ │ │ ├─21-原子类：无锁工具类的典范

│ │ │ ├─22-Executor与线程池：如何创建正确的线程池？

│ │ │ ├─23-Future：如何用多线程实现最优的“烧水泡茶”程序？

│ │ │ ├─24-CompletableFuture：异步编程没那么难

│ │ │ ├─25-CompletionService：如何批量执行异步任务？

│ │ │ ├─26-Fork-Join：单机版的MapReduce

│ │ │ ├─27-并发工具类模块热点问题答疑

│ │ │ ├─28-Immutability模式：如何利用不变性解决并发问题？

│ │ │ ├─29-Copy-on-Write模式：不是延时策略的COW

│ │ │ ├─30-线程本地存储模式：没有共享，就没有伤害

│ │ │ ├─31-GuardedSuspension模式：等待唤醒机制的规范实现

│ │ │ ├─32-Balking模式：再谈线程安全的单例模式

│ │ │ ├─33-Thread-Per-Message模式：最简单实用的分工方法

│ │ │ ├─34-WorkerThread模式：如何避免重复创建线程？

│ │ │ ├─35-两阶段终止模式：如何优雅地终止线程？

│ │ │ ├─36-生产者-消费者模式：用流水线思想提高效率

│ │ │ ├─37-设计模式模块热点问题答疑

│ │ │ ├─38-案例分析（一）：高性能限流器GuavaRateLimiter

│ │ │ ├─39-案例分析（二）：高性能网络应用框架Netty

│ │ │ ├─3个用户来信-打开一个新的并发世界

│ │ │ ├─40-案例分析（三）：高性能队列Disruptor

│ │ │ ├─41-案例分析（四）：高性能数据库连接池HiKariCP

│ │ │ ├─42-Actor模型：面向对象原生的并发模型

│ │ │ ├─43-软件事务内存：借鉴数据库的并发经验

│ │ │ ├─44-协程：更轻量级的线程

│ │ │ ├─45-CSP模型：Golang的主力队员

│ │ │ ├─学习攻略-如何才能学好并发编程？

│ │ │ ├─开篇词-你为什么需要学习并发编程？

│ │ │ ├─用户来信-真好，面试考到这些并发编程，我都答对了！

│ │ │ ├─结束语-十年之后，初心依旧

│ │ │ └─结课测试-这些Java并发编程实战的知识你都掌握了吗？

│ │ ├─041-iOS开发高手课

│ │ │ ├─01-建立你自己的iOS开发知识体系

│ │ │ ├─02-App启动速度怎么做优化与监控？

│ │ │ ├─03-AutoLayout是怎么进行自动布局的，性能如何？

│ │ │ ├─04-项目大了人员多了，架构怎么设计更合理？

│ │ │ ├─041-iOS开发高手课

│ │ │ ├─05-链接器：符号是怎么绑定到地址上的？

│ │ │ ├─06-App如何通过注入动态库的方式实现极速编译调试？

│ │ │ ├─07-Clang、Infer和OCLint，我们应该使用谁来做静态分析？

│ │ │ ├─08-如何利用Clang为App提质？

│ │ │ ├─09-无侵入的埋点方案如何实现？

│ │ │ ├─10-包大小：如何从资源和代码层面实现全方位瘦身？

│ │ │ ├─11-热点问题答疑（一）：基础模块问题答疑

│ │ │ ├─12-iOS崩溃千奇百怪，如何全面监控？

│ │ │ ├─13-如何利用RunLoop原理去监控卡顿？

│ │ │ ├─14-临近OOM，如何获取详细内存分配信息，分析内存问题？

│ │ │ ├─15-日志监控：怎样获取App中的全量日志？

│ │ │ ├─16-性能监控：衡量App质量的那把尺

│ │ │ ├─17-远超你想象的多线程的那些坑

│ │ │ ├─18-怎么减少App电量消耗？

│ │ │ ├─19-热点问题答疑（二）：基础模块问题答疑

│ │ │ ├─20-iOS开发的最佳学习路径是什么？

│ │ │ ├─21-除了Cocoa，iOS还可以用哪些GUI框架开发？

│ │ │ ├─22-细说iOS响应式框架变迁，哪些思想可以为我所用？

│ │ │ ├─23-如何构造酷炫的物理效果和过场动画效果？

│ │ │ ├─24-A-B测试：验证决策效果的利器

│ │ │ ├─25-怎样构建底层的发布和订阅事件总线？

│ │ │ ├─26-如何提高JSON解析的性能？

│ │ │ ├─27-如何用Flexbox思路开发？跟自动布局比，Flexbox好在哪？

│ │ │ ├─28-怎么应对各种富文本表现需求？

│ │ │ ├─29-如何在iOS中进行面向测试驱动开发和面向行为驱动开发？

│ │ │ ├─30-如何制定一套适合自己团队的iOS编码规范？

│ │ │ ├─31-iOS开发学习资料和书单推荐

│ │ │ ├─32-热点问题答疑（三）

│ │ │ ├─33-iOS系统内核XNU：App如何加载？

│ │ │ ├─34-iOS黑魔法RuntimeMethodSwizzling背后的原理

│ │ │ ├─35-libffi：动态调用和定义C函数

│ │ │ ├─36-iOS是怎么管理内存的？

│ │ │ ├─37-如何编写Clang插件？

│ │ │ ├─38-热点问题答疑（四）

│ │ │ ├─39-打通前端与原生的桥梁：JavaScriptCore能干哪些事情？

│ │ │ ├─40-ReactNative、Flutter等，这些跨端方案怎么选？

│ │ │ ├─41-原生布局转到前端布局，开发思路有哪些转变？

│ │ │ ├─42-iOS原生、大前端和Flutter分别是怎么渲染的？

│ │ │ ├─43-剖析使App具有动态化和热更新能力的方案

│ │ │ ├─开篇词-锚定一个点，然后在这个点上深耕

│ │ │ ├─用户故事-我是如何学习这个专栏的？

│ │ │ ├─结束语-慢几步，深几度

│ │ │ └─结课测试-这些iOS的开发知识你都掌握了吗？

│ │ ├─042-趣谈Linux操作系统

│ │ │ ├─01-入学测验：你究竟对Linux操作系统了解多少？

│ │ │ ├─02-学习路径：爬过这六个陡坡，你就能对Linux了如指掌

│ │ │ ├─03-你可以把Linux内核当成一家软件外包公司的老板

│ │ │ ├─04-快速上手几个Linux命令：每家公司都有自己的黑话

│ │ │ ├─042-趣谈Linux操作系统

│ │ │ ├─05-学会几个系统调用：咱们公司能接哪些类型的项目？

│ │ │ ├─06-x86架构：有了开放的架构，才能打造开放的营商环境

│ │ │ ├─07-从BIOS到bootloader：创业伊始，有活儿老板自己上

│ │ │ ├─08-内核初始化：生意做大了就得成立公司

│ │ │ ├─09-系统调用：公司成立好了就要开始接项目

│ │ │ ├─10-进程：公司接这么多项目，如何管？

│ │ │ ├─11-线程：如何让复杂的项目并行执行？

│ │ │ ├─12-进程数据结构（上）：项目多了就需要项目管理系统

│ │ │ ├─13-进程数据结构（中）：项目多了就需要项目管理系统

│ │ │ ├─14-进程数据结构（下）：项目多了就需要项目管理系统

│ │ │ ├─15-调度（上）：如何制定项目管理流程？

│ │ │ ├─16-调度（中）：主动调度是如何发生的？

│ │ │ ├─17-调度（下）：抢占式调度是如何发生的？

│ │ │ ├─18-进程的创建：如何发起一个新项目？

│ │ │ ├─19-线程的创建：如何执行一个新子项目？

│ │ │ ├─20-内存管理（上）：为客户保密，规划进程内存空间布局

│ │ │ ├─21-内存管理（下）：为客户保密，项目组独享会议室封闭开发

│ │ │ ├─22-进程空间管理：项目组还可以自行布置会议室

│ │ │ ├─23-物理内存管理（上）：会议室管理员如何分配会议室？

│ │ │ ├─24-物理内存管理（下）：会议室管理员如何分配会议室？

│ │ │ ├─25-用户态内存映射：如何找到正确的会议室？

│ │ │ ├─26-内核态内存映射：如何找到正确的会议室？

│ │ │ ├─27-文件系统：项目成果要归档，我们就需要档案库

│ │ │ ├─28-硬盘文件系统：如何最合理地组织档案库的文档？

│ │ │ ├─29-虚拟文件系统：文件多了就需要档案管理系统

│ │ │ ├─30-文件缓存：常用文档应该放在触手可得的地方

│ │ │ ├─31-输入与输出：如何建立售前售后生态体系？

│ │ │ ├─32-字符设备（上）：如何建立直销模式？

│ │ │ ├─33-字符设备（下）：如何建立直销模式？

│ │ │ ├─34-块设备（上）：如何建立代理商销售模式？

│ │ │ ├─35-块设备（下）：如何建立代理商销售模式？

│ │ │ ├─36-进程间通信：遇到大项目需要项目组之间的合作才行

│ │ │ ├─37-信号（上）：项目组A完成了，如何及时通知项目组B？

│ │ │ ├─38-信号（下）：项目组A完成了，如何及时通知项目组B？

│ │ │ ├─39-管道：项目组A完成了，如何交接给项目组B？

│ │ │ ├─40-IPC（上）：不同项目组之间抢资源，如何协调？

│ │ │ ├─41-IPC（中）：不同项目组之间抢资源，如何协调？

│ │ │ ├─42-IPC（下）：不同项目组之间抢资源，如何协调？

│ │ │ ├─43-Socket通信：遇上特大项目，要学会和其他公司合作

│ │ │ ├─43预习-Socket通信之网络协议基本原理

│ │ │ ├─44-Socket内核数据结构：如何成立特大项目合作部？

│ │ │ ├─45-发送网络包（上）：如何表达我们想让合作伙伴做什么？

│ │ │ ├─46-发送网络包（下）：如何表达我们想让合作伙伴做什么？

│ │ │ ├─47-接收网络包（上）：如何搞明白合作伙伴让我们做什么？

│ │ │ ├─48-接收网络包（下）：如何搞明白合作伙伴让我们做什么？

│ │ │ ├─49-虚拟机：如何成立子公司，让公司变集团？

│ │ │ ├─50-计算虚拟化之CPU（上）：如何复用集团的人力资源？

│ │ │ ├─51-计算虚拟化之CPU（下）：如何复用集团的人力资源？

│ │ │ ├─52-计算虚拟化之内存：如何建立独立的办公室？

│ │ │ ├─53-存储虚拟化（上）：如何建立自己保管的单独档案库？

│ │ │ ├─54-存储虚拟化（下）：如何建立自己保管的单独档案库？

│ │ │ ├─55-网络虚拟化：如何成立独立的合作部？

│ │ │ ├─56-容器：大公司为保持创新，鼓励内部创业

│ │ │ ├─57-Namespace技术：内部创业公司应该独立运营

│ │ │ ├─58-cgroup技术：内部创业公司应该独立核算成本

│ │ │ ├─59-数据中心操作系统：上市敲钟

│ │ │ ├─60-搭建操作系统实验环境（上）：授人以鱼不如授人以渔

│ │ │ ├─61-搭建操作系统实验环境（下）：授人以鱼不如授人以渔

│ │ │ ├─62-知识串讲：用一个创业故事串起操作系统原理（一）

│ │ │ ├─63-知识串讲：用一个创业故事串起操作系统原理（二）

│ │ │ ├─64-知识串讲：用一个创业故事串起操作系统原理（三）

│ │ │ ├─65-知识串讲：用一个创业故事串起操作系统原理（四）

│ │ │ ├─66-知识串讲：用一个创业故事串起操作系统原理（五）

│ │ │ ├─“趣谈Linux操作系统”食用指南

│ │ │ ├─学习攻略（一）：学好操作系统，需要掌握哪些前置知识？

│ │ │ ├─开篇词-为什么要学习Linux操作系统？

│ │ │ ├─期末测试-这些操作系统问题，你真的掌握了吗？

│ │ │ ├─结束语-永远别轻视任何技术，也永远别轻视自己

│ │ │ └─结束语-永远别轻视任何技术，也永远别轻视自己

│ │ ├─043-从0开始做增长

│ │ │ ├─01预习-增长小白如何“弯道超车”？

│ │ │ ├─02预习-如何理解“增长”？

│ │ │ ├─03预习-不同职能如何做好增长？

│ │ │ ├─043-从0开始做增长

│ │ │ ├─04预习-做增长如何处理职能间的矛盾？

│ │ │ ├─05-正确目标找不对，天天加班也枉然

│ │ │ ├─06-活学活用北极星指标

│ │ │ ├─07-OKR如何助力增长？

│ │ │ ├─08-不懂用户调研？那就对了！

│ │ │ ├─09-调研目标：在差异性洞察中找到爆破点

│ │ │ ├─10-数据分析：在“花式对比”中发现玄机

│ │ │ ├─11-用户分类：围绕北极星指标细分人群

│ │ │ ├─12-用户访谈：像侦探一样寻找破案线索（上）

│ │ │ ├─13-用户访谈：像侦探一样寻找破案线索（下）

│ │ │ ├─14-提炼用户差异，发现增长契机

│ │ │ ├─15-挖掘产品优势，打破增长瓶颈

│ │ │ ├─16-定位营销差异，抢占用户心智

│ │ │ ├─17-一级方向：找到增长爆破点

│ │ │ ├─18-B端产品如何调研？

│ │ │ ├─19-全局规划增长机会

│ │ │ ├─20-统筹全局的用户增长地图

│ │ │ ├─21-案例解析：定义关键增长指标

│ │ │ ├─22-正负双向洞察，找准切入点

│ │ │ ├─23-二级机会：制定增长策略

│ │ │ ├─24-为一家濒临破产的公司制定增长策略（上）

│ │ │ ├─25-为一家濒临破产的公司制定增长策略（中）

│ │ │ ├─26-为一家濒临破产的公司制定增长策略（下）

│ │ │ ├─27-为什么指标数据怎么优化都不提升？

│ │ │ ├─28-案例解析：打造增长闭环（上）

│ │ │ ├─29-案例解析：打造增长闭环（下）

│ │ │ ├─30-案例解析：唤醒沉睡用户（上）

│ │ │ ├─31-案例解析：唤醒沉睡用户（下）

│ │ │ ├─32-没有分解，就无缘增长

│ │ │ ├─33-四个要点颠覆传统需求文档

│ │ │ ├─34-三级落地：无限场景应用

│ │ │ ├─35-手把手教你设计一次成功的实验（上）

│ │ │ ├─36-手把手教你设计一次成功的实验（下）

│ │ │ ├─37-积少可成多，别针换别墅

│ │ │ ├─38-四级延续：增长组件库案例

│ │ │ ├─39-以用户为中心增长

│ │ │ ├─增长导航图-增长专栏的知识架构是怎样的？

│ │ │ ├─尾声-结束意味着新的开始

│ │ │ ├─开篇词-人人都是增长官

│ │ │ ├─结课测试-这些“增长”知识，你真的掌握了吗？

│ │ │ ├─预习答疑-你需要一张思维导图吗？

│ │ │ └─预习答疑-你需要一张思维导图吗？

│ │ ├─044-许式伟的架构课

│ │ │ ├─01-架构设计的宏观视角

│ │ │ ├─02-大厦基石：无生有，有生万物

│ │ │ ├─03-汇编：编程语言的诞生(1)

│ │ │ ├─03-汇编：编程语言的诞生

│ │ │ ├─04-编程语言的进化

│ │ │ ├─044-许式伟的架构课

│ │ │ ├─05-思考题解读：如何实现可自我迭代的计算机？

│ │ │ ├─06-操作系统进场

│ │ │ ├─07-软件运行机制及内存管理

│ │ │ ├─08-操作系统内核与编程接口

│ │ │ ├─09-外存管理与文件系统

│ │ │ ├─10-输入和输出设备：交互的演进

│ │ │ ├─11-多任务：进程、线程与协程

│ │ │ ├─12-进程内协同：同步、互斥与通讯

│ │ │ ├─13-进程间的同步互斥、资源共享与通讯

│ │ │ ├─14-IP网络：连接世界的桥梁

│ │ │ ├─15-可编程的互联网世界

│ │ │ ├─16-安全管理：数字世界的守护

│ │ │ ├─17-架构：需求分析(上)

│ │ │ ├─18-架构：需求分析(下)·实战案例

│ │ │ ├─19-基础平台篇：回顾与总结

│ │ │ ├─20-桌面开发的宏观视角

│ │ │ ├─21-图形界面程序的框架

│ │ │ ├─22-桌面程序的架构建议

│ │ │ ├─23-Web开发：浏览器、小程序与PWA

│ │ │ ├─24-跨平台与Web开发的建议

│ │ │ ├─25-桌面开发的未来

│ │ │ ├─26-实战（一）：怎么设计一个“画图”程序？

│ │ │ ├─27-实战（二）：怎么设计一个“画图”程序？

│ │ │ ├─28-实战（三）：怎么设计一个“画图”程序？

│ │ │ ├─29-实战（四）：怎么设计一个“画图”程序？

│ │ │ ├─30-实战（五）：怎么设计一个“画图”程序？

│ │ │ ├─31-辅助界面元素的架构设计

│ │ │ ├─32-架构：系统的概要设计

│ │ │ ├─33-桌面开发篇：回顾与总结

│ │ │ ├─34-服务端开发的宏观视角

│ │ │ ├─35-流量调度与负载均衡

│ │ │ ├─36-业务状态与存储中间件

│ │ │ ├─37-键值存储与数据库

│ │ │ ├─38-文件系统与对象存储

│ │ │ ├─39-存储与缓存

│ │ │ ├─40-服务端的业务架构建议

│ │ │ ├─41-实战（一）：“画图”程序后端实战

│ │ │ ├─42-实战（二）：“画图”程序后端实战

│ │ │ ├─43-实战（三）：“画图”程序后端实战

│ │ │ ├─44-实战（四）：“画图”程序后端实战

│ │ │ ├─45-架构：怎么做详细设计？

│ │ │ ├─46-服务端开发篇：回顾与总结

│ │ │ ├─47-服务治理的宏观视角

│ │ │ ├─48-事务与工程：什么是工程师思维？

│ │ │ ├─49-发布、升级与版本管理

│ │ │ ├─50-日志、监控与报警

│ │ │ ├─51-故障域与故障预案

│ │ │ ├─52-故障排查与根因分析

│ │ │ ├─53-过载保护与容量规划

│ │ │ ├─54-业务的可支持性与持续运营

│ │ │ ├─55-云计算、容器革命与服务端的未来

│ │ │ ├─56-服务治理篇：回顾与总结

│ │ │ ├─57-心性：架构师的修炼之道

│ │ │ ├─58-如何判断架构设计的优劣？

│ │ │ ├─59-少谈点框架，多谈点业务

│ │ │ ├─60-架构分解：边界，不断重新审视边界

│ │ │ ├─61-全局性功能的架构设计

│ │ │ ├─62-重新认识开闭原则(OCP)

│ │ │ ├─63-接口设计的准则

│ │ │ ├─64-不断完善的架构范式

│ │ │ ├─65-架构范式：文本处理

│ │ │ ├─66-架构老化与重构

│ │ │ ├─67-架构思维篇：回顾与总结

│ │ │ ├─68-软件工程的宏观视角

│ │ │ ├─69-团队的共识管理

│ │ │ ├─70-怎么写设计文档？

│ │ │ ├─71-如何阅读别人的代码？

│ │ │ ├─72-发布单元与版本管理

│ │ │ ├─73-软件质量管理：单元测试、持续构建与发布

│ │ │ ├─74-开源、云服务与外包管理

│ │ │ ├─75-软件版本迭代的规划

│ │ │ ├─76-软件工程的未来

│ │ │ ├─77-软件工程篇：回顾与总结

│ │ │ ├─加餐-如何做HTTP服务的测试？

│ │ │ ├─加餐-实战：“画图程序”的整体架构

│ │ │ ├─加餐-怎么保障发布的效率与质量？

│ │ │ ├─开篇词-怎样成长为优秀的软件架构师？

│ │ │ ├─热点观察-我看Facebook发币（上）：区块链、比特币与Libra币

│ │ │ ├─热点观察-我看Facebook发币（下）：深入浅出理解Libra币

│ │ │ ├─用户故事-站在更高的视角看架构

│ │ │ ├─答疑解惑-想当架构师，我需要成为“全才”吗？

│ │ │ ├─结束语-放下技术人的身段，用极限思维提升架构能力

│ │ │ ├─结课问卷获奖用户名单

│ │ │ ├─课外阅读-从《孙子兵法》看底层的自然法则

│ │ │ ├─课程迭代-84讲音频重新交付

│ │ │ └─课程迭代-84讲音频重新交付

│ │ ├─045-大规模数据处理实战

│ │ │ ├─01-为什么MapReduce会被硅谷一线公司淘汰？

│ │ │ ├─02-MapReduce后谁主沉浮：怎样设计下一代数据处理技术？

│ │ │ ├─03-大规模数据处理初体验：怎样实现大型电商热销榜？

│ │ │ ├─04-分布式系统（上）：学会用服务等级协议SLA来评估你的系统

│ │ │ ├─045-大规模数据处理实战

│ │ │ ├─05-分布式系统（下）：架构师不得不知的三大指标

│ │ │ ├─06-如何区分批处理还是流处理？

│ │ │ ├─07-Workflow设计模式：让你在大规模数据世界中君临天下

│ │ │ ├─08-发布-订阅模式：流处理架构中的瑞士军刀

│ │ │ ├─09-CAP定理：三选二，架构师必须学会的取舍

│ │ │ ├─10-Lambda架构：Twitter亿级实时数据分析架构背后的倚天剑

│ │ │ ├─11-Kappa架构：利用Kafka锻造的屠龙刀

│ │ │ ├─12-我们为什么需要Spark？

│ │ │ ├─13-弹性分布式数据集：Spark大厦的地基（上）

│ │ │ ├─14-弹性分布式数据集：Spark大厦的地基（下）

│ │ │ ├─15-SparkSQL：Spark数据查询的利器

│ │ │ ├─16-SparkStreaming：Spark的实时流计算API

│ │ │ ├─17-StructuredStreaming：如何用DataFrameAPI进行实时数据分析

│ │ │ ├─18-WordCount：从零开始运行你的第一个Spark应用

│ │ │ ├─19-综合案例实战：处理加州房屋信息，构建线性回归模型

│ │ │ ├─20-流处理案例实战：分析纽约市出租车载客信息

│ │ │ ├─21-深入对比Spark与Flink：帮你系统设计两开花

│ │ │ ├─22-ApacheBeam的前世今生

│ │ │ ├─23-站在Google的肩膀上学习Beam编程模型

│ │ │ ├─24-PCollection：为什么Beam要如此抽象封装数据？

│ │ │ ├─25-Transform：Beam数据转换操作的抽象方法

│ │ │ ├─26-Pipeline：Beam如何抽象多步骤的数据流水线？

│ │ │ ├─27-PipelineI-O-Beam数据中转的设计模式

│ │ │ ├─28-如何设计创建好一个BeamPipeline？

│ │ │ ├─29-如何测试BeamPipeline？

│ │ │ ├─30-ApacheBeam实战冲刺：Beam如何runeverywhere

│ │ │ ├─31-WordCountBeamPipeline实战

│ │ │ ├─32-BeamWindow：打通流处理的任督二脉

│ │ │ ├─33-横看成岭侧成峰：再战StreamingWordCount

│ │ │ ├─34-Amazon热销榜BeamPipeline实战

│ │ │ ├─35-Facebook游戏实时流处理BeamPipeline实战（上）

│ │ │ ├─36-Facebook游戏实时流处理BeamPipeline实战（下）

│ │ │ ├─37-5G时代，如何处理超大规模物联网数据

│ │ │ ├─38-大规模数据处理在深度学习中如何应用？

│ │ │ ├─39-从SQL到StreamingSQL：突破静态数据查询的次元

│ │ │ ├─40-大规模数据处理未来之路

│ │ │ ├─FAQ第一期-学习大规模数据处理需要什么基础？

│ │ │ ├─FAQ第三期-ApacheBeam基础答疑

│ │ │ ├─FAQ第二期-Spark案例实战答疑

│ │ │ ├─加油站-Practicemakesperfect！

│ │ │ ├─开篇词-从这里开始，带你走上硅谷一线系统架构师之路

│ │ │ ├─结束语-世间所有的相遇，都是久别重逢

│ │ │ └─结束语-世间所有的相遇，都是久别重逢

│ │ ├─046-深入浅出计算机组成原理

│ │ │ ├─01-冯·诺依曼体系结构：计算机组成的金字塔

│ │ │ ├─02-给你一张知识地图，计算机组成原理应该这么学

│ │ │ ├─03-通过你的CPU主频，我们来谈谈“性能”究竟是什么？

│ │ │ ├─04-穿越功耗墙，我们该从哪些方面提升“性能”？

│ │ │ ├─046-深入浅出计算机组成原理

│ │ │ ├─05-计算机指令：让我们试试用纸带编程

│ │ │ ├─06-指令跳转：原来if

│ │ │ ├─07-函数调用：为什么会发生stackoverflow？

│ │ │ ├─08-ELF和静态链接：为什么程序无法同时在Linux和Windows下运行？

│ │ │ ├─09-程序装载：“640K内存”真的不够用么？

│ │ │ ├─10-动态链接：程序内部的“共享单车”

│ │ │ ├─11-二进制编码：“手持两把锟斤拷，口中疾呼烫烫烫”？

│ │ │ ├─12-理解电路：从电报机到门电路，我们如何做到“千里传信”？

│ │ │ ├─13-加法器：如何像搭乐高一样搭电路（上）？

│ │ │ ├─14-乘法器：如何像搭乐高一样搭电路（下）？

│ │ │ ├─15-浮点数和定点数（上）：怎么用有限的Bit表示尽可能多的信息？

│ │ │ ├─16-浮点数和定点数（下）：深入理解浮点数到底有什么用？

│ │ │ ├─17-建立数据通路（上）：指令+运算=CPU

│ │ │ ├─18-建立数据通路（中）：指令+运算=CPU

│ │ │ ├─19-建立数据通路（下）：指令+运算=CPU

│ │ │ ├─20-面向流水线的指令设计（上）：一心多用的现代CPU

│ │ │ ├─21-面向流水线的指令设计（下）：奔腾4是怎么失败的？

│ │ │ ├─22-冒险和预测（一）：hazard是“危”也是“机”

│ │ │ ├─23-冒险和预测（二）：流水线里的接力赛

│ │ │ ├─24-冒险和预测（三）：CPU里的“线程池”

│ │ │ ├─25-冒险和预测（四）：今天下雨了，明天还会下雨么？

│ │ │ ├─26-Superscalar和VLIW：如何让CPU的吞吐率超过1？

│ │ │ ├─27-SIMD：如何加速矩阵乘法？

│ │ │ ├─28-异常和中断：程序出错了怎么办？

│ │ │ ├─29-CISC和RISC：为什么手机芯片都是ARM？

│ │ │ ├─30-GPU（上）：为什么玩游戏需要使用GPU？

│ │ │ ├─31-GPU（下）：为什么深度学习需要使用GPU？

│ │ │ ├─32-FPGA和ASIC：计算机体系结构的黄金时代

│ │ │ ├─33-解读TPU：设计和拆解一块ASIC芯片

│ │ │ ├─34-理解虚拟机：你在云上拿到的计算机是什么样的？

│ │ │ ├─35-存储器层次结构全景：数据存储的大金字塔长什么样？

│ │ │ ├─36-局部性原理：数据库性能跟不上，加个缓存就好了？

│ │ │ ├─37-高速缓存（上）：“4毫秒”究竟值多少钱？

│ │ │ ├─38-高速缓存（下）：你确定你的数据更新了么？

│ │ │ ├─39-MESI协议：如何让多核CPU的高速缓存保持一致？

│ │ │ ├─40-理解内存（上）：虚拟内存和内存保护是什么？

│ │ │ ├─41-理解内存（下）：解析TLB和内存保护

│ │ │ ├─42-总线：计算机内部的高速公路

│ │ │ ├─43-输入输出设备：我们并不是只能用灯泡显示“0”和“1”

│ │ │ ├─44-理解IOWAIT：I-O性能到底是怎么回事儿？

│ │ │ ├─45-机械硬盘：Google早期用过的“黑科技”

│ │ │ ├─46-SSD硬盘（上）：如何完成性能优化的KPI？

│ │ │ ├─47-SSD硬盘（下）：如何完成性能优化的KPI？

│ │ │ ├─48-DMA：为什么Kafka这么快？

│ │ │ ├─49-数据完整性（上）：硬件坏了怎么办？

│ │ │ ├─50-数据完整性（下）：如何还原犯罪现场？

│ │ │ ├─51-分布式计算：如果所有人的大脑都联网会怎样？

│ │ │ ├─52-设计大型DMP系统（上）：MongoDB并不是什么灵丹妙药

│ │ │ ├─53-设计大型DMP系统（下）：SSD拯救了所有的DBA

│ │ │ ├─54-理解Disruptor（上）：带你体会CPU高速缓存的风驰电掣

│ │ │ ├─55-理解Disruptor（下）：不需要换挡和踩刹车的CPU，有多快？

│ │ │ ├─FAQ第一期-学与不学，知识就在那里，不如就先学好了

│ │ │ ├─FAQ第二期-世界上第一个编程语言是怎么来的？

│ │ │ ├─开篇词-为什么你需要学习计算机组成原理？

│ │ │ ├─特别加餐-我在2019年F8大会的两日见闻录

│ │ │ ├─特别加餐-我的一天怎么过？

│ │ │ ├─用户故事-赵文海：怕什么真理无穷，进一寸有一寸的欢喜

│ │ │ ├─结束语-知也无涯，愿你也享受发现的乐趣

│ │ │ └─结束语-知也无涯，愿你也享受发现的乐趣

│ │ ├─047-Python核心技术与实战

│ │ │ ├─01-如何逐步突破，成为Python高手？

│ │ │ ├─02-JupyterNotebook为什么是现代Python的必学技术？

│ │ │ ├─03-列表和元组，到底用哪一个？

│ │ │ ├─04-字典、集合，你真的了解吗？

│ │ │ ├─047-Python核心技术与实战

│ │ │ ├─05-深入浅出字符串

│ │ │ ├─06-Python“黑箱”：输入与输出

│ │ │ ├─07-修炼基本功：条件与循环

│ │ │ ├─08-异常处理：如何提高程序的稳定性？

│ │ │ ├─09-不可或缺的自定义函数

│ │ │ ├─10-简约不简单的匿名函数

│ │ │ ├─11-面向对象（上）：从生活中的类比说起

│ │ │ ├─12-面向对象（下）：如何实现一个搜索引擎？

│ │ │ ├─13-搭建积木：Python模块化

│ │ │ ├─14-答疑（一）：列表和元组的内部实现是怎样的？

│ │ │ ├─15-Python对象的比较、拷贝

│ │ │ ├─16-值传递，引用传递or其他，Python里参数是如何传递的？

│ │ │ ├─17-强大的装饰器

│ │ │ ├─18-metaclass，是潘多拉魔盒还是阿拉丁神灯？

│ │ │ ├─19-深入理解迭代器和生成器

│ │ │ ├─20-揭秘Python协程

│ │ │ ├─21-Python并发编程之Futures

│ │ │ ├─22-并发编程之Asyncio

│ │ │ ├─23-你真的懂PythonGIL（全局解释器锁）吗？

│ │ │ ├─24-带你解析Python垃圾回收机制

│ │ │ ├─25-答疑（二）：GIL与多线程是什么关系呢？

│ │ │ ├─26-活都来不及干了，还有空注意代码风格？！

│ │ │ ├─27-学会合理分解代码，提高代码可读性

│ │ │ ├─28-如何合理利用assert？

│ │ │ ├─29-巧用上下文管理器和With语句精简代码

│ │ │ ├─30-真的有必要写单元测试吗？

│ │ │ ├─31-pdb&cProfile：调试和性能分析的法宝

│ │ │ ├─32-答疑（三）：如何选择合适的异常处理方式？

│ │ │ ├─33-带你初探量化世界

│ │ │ ├─34-RESTful&Socket：搭建交易执行层核心

│ │ │ ├─35-RESTful&Socket：行情数据对接和抓取

│ │ │ ├─36-Pandas&Numpy：策略与回测系统

│ │ │ ├─37-Kafka&ZMQ：自动化交易流水线

│ │ │ ├─38-MySQL：日志和数据存储系统

│ │ │ ├─39-Django：搭建监控平台

│ │ │ ├─40-总结：Python中的数据结构与算法全景

│ │ │ ├─41-硅谷一线互联网公司的工作体验

│ │ │ ├─42-细数技术研发的注意事项

│ │ │ ├─43-Q&A：聊一聊职业发展和选择

│ │ │ ├─加餐-带你上手SWIG：一份清晰好用的SWIG编程实践指南

│ │ │ ├─开篇词-从工程的角度深入理解Python

│ │ │ ├─结束语-技术之外的几点成长建议

│ │ │ └─结课测试-关于Python的这些知识，你都掌握了吗？

│ │ ├─048-深入拆解Tomcat&Jetty

│ │ │ ├─01-Web容器学习路径

│ │ │ ├─02-HTTP协议必知必会

│ │ │ ├─03-你应该知道的Servlet规范和Servlet容器

│ │ │ ├─04-实战：纯手工打造和运行一个Servlet

│ │ │ ├─048-深入拆解Tomcat&Jetty

│ │ │ ├─05-Tomcat系统架构（上）：连接器是如何设计的？

│ │ │ ├─06-Tomcat系统架构（下）：聊聊多层容器的设计

│ │ │ ├─07-Tomcat如何实现一键式启停？

│ │ │ ├─08-Tomcat的“高层们”都负责做什么？

│ │ │ ├─09-比较：Jetty架构特点之Connector组件

│ │ │ ├─10-比较：Jetty架构特点之Handler组件

│ │ │ ├─11-总结：从Tomcat和Jetty中提炼组件化设计规范

│ │ │ ├─12-实战：优化并提高Tomcat启动速度

│ │ │ ├─13-热点问题答疑（1）：如何学习源码？

│ │ │ ├─14-NioEndpoint组件：Tomcat如何实现非阻塞I-O？

│ │ │ ├─15-Nio2Endpoint组件：Tomcat如何实现异步I-O？

│ │ │ ├─16-AprEndpoint组件：TomcatAPR提高I-O性能的秘密

│ │ │ ├─17-Executor组件：Tomcat如何扩展Java线程池？

│ │ │ ├─18-新特性：Tomcat如何支持WebSocket？

│ │ │ ├─19-比较：Jetty的线程策略EatWhatYouKill

│ │ │ ├─20-总结：Tomcat和Jetty中的对象池技术

│ │ │ ├─21-总结：Tomcat和Jetty的高性能、高并发之道

│ │ │ ├─22-热点问题答疑（2）：内核如何阻塞与唤醒进程？

│ │ │ ├─23-Host容器：Tomcat如何实现热部署和热加载？

│ │ │ ├─24-Context容器（上）：Tomcat如何打破双亲委托机制？

│ │ │ ├─25-Context容器（中）：Tomcat如何隔离Web应用？

│ │ │ ├─26-Context容器（下）：Tomcat如何实现Servlet规范？

│ │ │ ├─27-新特性：Tomcat如何支持异步Servlet？

│ │ │ ├─28-新特性：SpringBoot如何使用内嵌式的Tomcat和Jetty？

│ │ │ ├─29-比较：Jetty如何实现具有上下文信息的责任链？

│ │ │ ├─30-热点问题答疑（3）：Spring框架中的设计模式

│ │ │ ├─31-Logger组件：Tomcat的日志框架及实战

│ │ │ ├─32-Manager组件：Tomcat的Session管理机制解析

│ │ │ ├─33-Cluster组件：Tomcat的集群通信原理

│ │ │ ├─34-JVMGC原理及调优的基本思路

│ │ │ ├─35-如何监控Tomcat的性能？

│ │ │ ├─36-TomcatI-O和线程池的并发调优

│ │ │ ├─37-Tomcat内存溢出的原因分析及调优

│ │ │ ├─38-Tomcat拒绝连接原因分析及网络优化

│ │ │ ├─39-Tomcat进程占用CPU过高怎么办？

│ │ │ ├─40-谈谈Jetty性能调优的思路

│ │ │ ├─41-热点问题答疑（4）：Tomcat和Jetty有哪些不同？

│ │ │ ├─开篇词-Java程序员如何快速成长？

│ │ │ ├─特别放送-如何持续保持对学习的兴趣？

│ │ │ ├─结束语-静下心来，品味经典

│ │ │ └─结课测试-这些Tomcat&Jetty的知识你都掌握了吗？

│ │ ├─049-Java性能调优实战

│ │ │ ├─01-如何制定性能调优标准？

│ │ │ ├─02-如何制定性能调优策略？

│ │ │ ├─03-字符串性能优化不容小觑，百M内存轻松存储几十G数据

│ │ │ ├─04-慎重使用正则表达式

│ │ │ ├─049-Java性能调优实战

│ │ │ ├─05-ArrayList还是LinkedList？使用不当性能差千倍

│ │ │ ├─06-Stream如何提高遍历集合效率？

│ │ │ ├─07-深入浅出HashMap的设计与优化

│ │ │ ├─08-网络通信优化之I-O模型：如何解决高并发下I-O瓶颈？

│ │ │ ├─09-网络通信优化之序列化：避免使用Java序列化

│ │ │ ├─10-网络通信优化之通信协议：如何优化RPC网络通信？

│ │ │ ├─11-答疑课堂：深入了解NIO的优化实现原理

│ │ │ ├─12-多线程之锁优化（上）：深入了解Synchronized同步锁的优化方法

│ │ │ ├─13-多线程之锁优化（中）：深入了解Lock同步锁的优化方法

│ │ │ ├─14-多线程之锁优化（下）：使用乐观锁优化并行操作

│ │ │ ├─15-多线程调优（上）：哪些操作导致了上下文切换？

│ │ │ ├─16-多线程调优（下）：如何优化多线程上下文切换？

│ │ │ ├─17-并发容器的使用：识别不同场景下最优容器

│ │ │ ├─18-如何设置线程池大小？

│ │ │ ├─19-如何用协程来优化多线程业务？

│ │ │ ├─20-答疑课堂：模块三热点问题解答

│ │ │ ├─21-磨刀不误砍柴工：欲知JVM调优先了解JVM内存模型

│ │ │ ├─22-深入JVM即时编译器JIT，优化Java编译

│ │ │ ├─23-如何优化垃圾回收机制？

│ │ │ ├─24-如何优化JVM内存分配？

│ │ │ ├─25-内存持续上升，我该如何排查问题？

│ │ │ ├─26-答疑课堂：模块四热点问题解答

│ │ │ ├─27-单例模式：如何创建单一对象优化系统性能？

│ │ │ ├─28-原型模式与享元模式：提升系统性能的利器

│ │ │ ├─29-如何使用设计模式优化并发编程？

│ │ │ ├─30-生产者消费者模式：电商库存设计优化

│ │ │ ├─31-装饰器模式：如何优化电商系统中复杂的商品价格策略？

│ │ │ ├─32-答疑课堂：模块五思考题集锦

│ │ │ ├─33-MySQL调优之SQL语句：如何写出高性能SQL语句？

│ │ │ ├─34-MySQL调优之事务：高并发场景下的数据库事务调优

│ │ │ ├─35-MySQL调优之索引：索引的失效与优化

│ │ │ ├─36-记一次线上SQL死锁事故：如何避免死锁？

│ │ │ ├─37-什么时候需要分表分库？

│ │ │ ├─38-电商系统表设计优化案例分析

│ │ │ ├─39-数据库参数设置优化，失之毫厘差之千里

│ │ │ ├─40-答疑课堂：MySQL中InnoDB的知识点串讲

│ │ │ ├─41-如何设计更优的分布式锁？

│ │ │ ├─42-电商系统的分布式事务调优

│ │ │ ├─43-如何使用缓存优化系统性能？

│ │ │ ├─44-记一次双十一抢购性能瓶颈调优

│ │ │ ├─加餐-什么是数据的强、弱一致性？

│ │ │ ├─加餐-推荐几款常用的性能测试工具

│ │ │ ├─开篇词-怎样才能做好性能调优？

│ │ │ ├─期末测试-有关Java性能调优，你掌握了多少呢？

│ │ │ ├─结束语-栉风沐雨，砥砺前行！

│ │ │ └─结束语-栉风沐雨，砥砺前行！

│ │ ├─050-OpenResty从入门到实战

│ │ │ ├─01-初探OpenResty的三大特性

│ │ │ ├─02-如何写出你的“helloworld”？

│ │ │ ├─03-揪出隐藏在背后的那些子项目

│ │ │ ├─04-如何管理第三方包？从包管理工具luarocks和opm说起

│ │ │ ├─05-[视频]opm项目导读

│ │ │ ├─050-OpenResty从入门到实战

│ │ │ ├─06-OpenResty中用到的NGINX知识

│ │ │ ├─07-带你快速上手Lua

│ │ │ ├─08-LuaJIT分支和标准Lua有什么不同？

│ │ │ ├─09-为什么lua-resty-core性能更高一些？

│ │ │ ├─10-JIT编译器的死穴：为什么要避免使用NYI？

│ │ │ ├─11-剖析Lua唯一的数据结构table和metatable特性

│ │ │ ├─12-高手秘诀：识别Lua的独有概念和坑

│ │ │ ├─13-[视频]实战：基于FFI实现的lua-resty-lrucache

│ │ │ ├─14-答疑（一）：Lua规则和NGINX配置文件产生冲突怎么办？

│ │ │ ├─15-OpenResty和别的开发平台有什么不同？

│ │ │ ├─16-秒杀大多数开发问题的两个利器：文档和测试案例

│ │ │ ├─17-为什么能成为更好的Web服务器？动态处理请求和响应是关键

│ │ │ ├─18-worker间的通信法宝：最重要的数据结构之shareddict

│ │ │ ├─19-OpenResty的核心和精髓：cosocket

│ │ │ ├─20-超越Web服务器：特权进程和定时任务

│ │ │ ├─21-带你玩转时间、正则表达式等常用API

│ │ │ ├─22-[视频]从一个安全漏洞说起，探寻API性能和安全的平衡

│ │ │ ├─23-[视频]导读lua-resty-requests：优秀的lua-resty-是如何编写的？

│ │ │ ├─24-实战：处理四层流量，实现MemcachedServer

│ │ │ ├─25-答疑（二）：特权进程的权限到底是什么？

│ │ │ ├─26-代码贡献者的拦路虎：test-nginx简介

│ │ │ ├─27-test-nginx包罗万象的测试方法

│ │ │ ├─28-test-nginx还可以这样用？

│ │ │ ├─29-最容易失准的性能测试？你需要压测工具界的“悍马”wrk

│ │ │ ├─30-答疑（三）如何搭建测试的网络结构？

│ │ │ ├─31-性能下降10倍的真凶：阻塞函数

│ │ │ ├─32-让人又恨又爱的字符串操作

│ │ │ ├─33-性能提升10倍的秘诀：必须用好table

│ │ │ ├─34-特别放送：OpenResty编码指南

│ │ │ ├─35-[视频]实际项目中的性能优化：ingress-nginx中的几个PR解读

│ │ │ ├─36-盘点OpenResty的各种调试手段

│ │ │ ├─37-systemtap-toolkit和stapxx：如何用数据搞定“疑难杂症”？

│ │ │ ├─38-[视频]巧用wrk和火焰图，科学定位性能瓶颈

│ │ │ ├─39-高性能的关键：shareddict缓存和lru缓存

│ │ │ ├─40-缓存与风暴并存，谁说缓存风暴不可避免？

│ │ │ ├─41-lua-resty-封装，让你远离多级缓存之痛

│ │ │ ├─42-如何应对突发流量：漏桶和令牌桶的概念

│ │ │ ├─43-灵活实现动态限流限速，其实没有那么难

│ │ │ ├─44-OpenResty的杀手锏：动态

│ │ │ ├─45-不得不提的能力外延：OpenResty常用的第三方库

│ │ │ ├─46-答疑（四）：共享字典的缓存是必须的吗？

│ │ │ ├─47-微服务API网关搭建三步曲（一）

│ │ │ ├─48-微服务API网关搭建三步曲（二）

│ │ │ ├─49-微服务API网关搭建三步曲（三）

│ │ │ ├─50-答疑（五）：如何在工作中引入OpenResty？

│ │ │ ├─开篇词-OpenResty，为你打开高性能开发的大门

│ │ │ ├─结束语-行百里者半九十

│ │ │ └─结束语-行百里者半九十

│ │ ├─051-透视HTTP协议

│ │ │ ├─01-时势与英雄：HTTP的前世今生

│ │ │ ├─02-HTTP是什么？HTTP又不是什么？

│ │ │ ├─03-HTTP世界全览（上）：与HTTP相关的各种概念

│ │ │ ├─04-HTTP世界全览（下）：与HTTP相关的各种协议

│ │ │ ├─05-常说的“四层”和“七层”到底是什么？“五层”“六层”哪去了？

│ │ │ ├─051-透视HTTP协议

│ │ │ ├─06-域名里有哪些门道？

│ │ │ ├─07-自己动手，搭建HTTP实验环境

│ │ │ ├─08-键入网址再按下回车，后面究竟发生了什么？

│ │ │ ├─09-HTTP报文是什么样子的？

│ │ │ ├─10-应该如何理解请求方法？

│ │ │ ├─11-你能写出正确的网址吗？

│ │ │ ├─12-响应状态码该怎么用？

│ │ │ ├─13-HTTP有哪些特点？

│ │ │ ├─14-HTTP有哪些优点？又有哪些缺点？

│ │ │ ├─15-海纳百川：HTTP的实体数据

│ │ │ ├─16-把大象装进冰箱：HTTP传输大文件的方法

│ │ │ ├─17-排队也要讲效率：HTTP的连接管理

│ │ │ ├─18-四通八达：HTTP的重定向和跳转

│ │ │ ├─19-让我知道你是谁：HTTP的Cookie机制

│ │ │ ├─20-生鲜速递：HTTP的缓存控制

│ │ │ ├─21-良心中间商：HTTP的代理服务

│ │ │ ├─22-冷链周转：HTTP的缓存代理

│ │ │ ├─23-HTTPS是什么？SSL-TLS又是什么？

│ │ │ ├─24-固若金汤的根本（上）：对称加密与非对称加密

│ │ │ ├─25-固若金汤的根本（下）：数字签名与证书

│ │ │ ├─26-信任始于握手：TLS1

│ │ │ ├─27-更好更快的握手：TLS1

│ │ │ ├─28-连接太慢该怎么办：HTTPS的优化

│ │ │ ├─29-我应该迁移到HTTPS吗？

│ │ │ ├─30-时代之风（上）：HTTP-2特性概览

│ │ │ ├─31-时代之风（下）：HTTP-2内核剖析

│ │ │ ├─32-未来之路：HTTP-3展望

│ │ │ ├─33-我应该迁移到HTTP-2吗？

│ │ │ ├─34-Nginx：高性能的Web服务器

│ │ │ ├─35-OpenResty：更灵活的Web服务器

│ │ │ ├─36-WAF：保护我们的网络服务

│ │ │ ├─37-CDN：加速我们的网络服务

│ │ │ ├─38-WebSocket：沙盒里的TCP

│ │ │ ├─39-HTTP性能优化面面观（上）

│ │ │ ├─40-HTTP性能优化面面观（下）

│ │ │ ├─41-Linux-Mac实验环境搭建与URI查询参数

│ │ │ ├─42-DHE-ECDHE算法的原理

│ │ │ ├─43-如何进行Docker实验环境搭建？

│ │ │ ├─44-先睹为快：HTTP-3实验版本长什么样子？

│ │ │ ├─开篇词｜ToBeaHTTPHero

│ │ │ ├─结束语-做兴趣使然的Hero

│ │ │ ├─结课测试-这些HTTP协议知识，你真的掌握了吗？

│ │ │ └─罗剑锋老师出新课了？

│ │ ├─052-Kafka核心技术与实战

│ │ │ ├─01-消息引擎系统ABC

│ │ │ ├─02-一篇文章带你快速搞定Kafka术语

│ │ │ ├─03-Kafka只是消息引擎系统吗？

│ │ │ ├─04-我应该选择哪种Kafka？

│ │ │ ├─05-聊聊Kafka的版本号

│ │ │ ├─052-Kafka核心技术与实战

│ │ │ ├─06-Kafka线上集群部署方案怎么做？

│ │ │ ├─07-最最最重要的集群参数配置（上）

│ │ │ ├─08-最最最重要的集群参数配置（下）

│ │ │ ├─09-生产者消息分区机制原理剖析

│ │ │ ├─10-生产者压缩算法面面观

│ │ │ ├─11-无消息丢失配置怎么实现？

│ │ │ ├─12-客户端都有哪些不常见但是很高级的功能？

│ │ │ ├─13-Java生产者是如何管理TCP连接的？

│ │ │ ├─14-幂等生产者和事务生产者是一回事吗？

│ │ │ ├─15-消费者组到底是什么？

│ │ │ ├─16-揭开神秘的“位移主题”面纱

│ │ │ ├─17-消费者组重平衡能避免吗？

│ │ │ ├─18-Kafka中位移提交那些事儿

│ │ │ ├─19-CommitFailedException异常怎么处理？

│ │ │ ├─20-多线程开发消费者实例

│ │ │ ├─21-Java消费者是如何管理TCP连接的

│ │ │ ├─22-消费者组消费进度监控都怎么实现？

│ │ │ ├─23-Kafka副本机制详解

│ │ │ ├─24-请求是怎么被处理的？

│ │ │ ├─25-消费者组重平衡全流程解析

│ │ │ ├─26-你一定不能错过的Kafka控制器

│ │ │ ├─27-关于高水位和LeaderEpoch的讨论

│ │ │ ├─28-主题管理知多少

│ │ │ ├─29-Kafka动态配置了解下？

│ │ │ ├─30-怎么重设消费者组位移？

│ │ │ ├─31-常见工具脚本大汇总

│ │ │ ├─32-KafkaAdminClient：Kafka的运维利器

│ │ │ ├─33-Kafka认证机制用哪家？

│ │ │ ├─34-云环境下的授权该怎么做？

│ │ │ ├─35-跨集群备份解决方案MirrorMaker

│ │ │ ├─36-你应该怎么监控Kafka？

│ │ │ ├─37-主流的Kafka监控框架

│ │ │ ├─38-调优Kafka，你做到了吗？

│ │ │ ├─39-从0搭建基于Kafka的企业级实时日志流处理平台

│ │ │ ├─40-KafkaStreams与其他流处理平台的差异在哪里？

│ │ │ ├─41-KafkaStreamsDSL开发实例

│ │ │ ├─42-KafkaStreams在金融领域的应用

│ │ │ ├─加餐-搭建开发环境、阅读源码方法、经典学习资料大揭秘

│ │ │ ├─开篇词-为什么要学习Kafka？

│ │ │ ├─期末测试-这些Kafka核心要点，你都掌握了吗？

│ │ │ ├─用户故事-黄云：行百里者半九十

│ │ │ ├─结束语-以梦为马，莫负韶华！

│ │ │ └─结束语-以梦为马，莫负韶华！

│ │ ├─053-SQL必知必会

│ │ │ ├─01丨了解SQL：一门半衰期很长的语言

│ │ │ ├─02丨DBMS的前世今生

│ │ │ ├─03丨学会用数据库的方式思考SQL是如何执行的

│ │ │ ├─04丨使用DDL创建数据库&数据表时需要注意什么？

│ │ │ ├─053-SQL必知必会

│ │ │ ├─05丨检索数据：你还在SELECT-么？

│ │ │ ├─06丨数据过滤：SQL数据过滤都有哪些方法？

│ │ │ ├─07丨什么是SQL函数？为什么使用SQL函数可能会带来问题？

│ │ │ ├─08丨什么是SQL的聚集函数，如何利用它们汇总表的数据？

│ │ │ ├─09丨子查询：子查询的种类都有哪些，如何提高子查询的性能？

│ │ │ ├─10丨常用的SQL标准有哪些，在SQL92中是如何使用连接的？

│ │ │ ├─11丨SQL99是如何使用连接的，与SQL92的区别是什么？

│ │ │ ├─12丨视图在SQL中的作用是什么，它是怎样工作的？

│ │ │ ├─13丨什么是存储过程，在实际项目中用得多么？

│ │ │ ├─14丨什么是事务处理，如何使用COMMIT和ROLLBACK进行操作？

│ │ │ ├─15丨初识事务隔离：隔离的级别有哪些，它们都解决了哪些异常问题？

│ │ │ ├─16丨游标：当我们需要逐条处理数据时，该怎么做？

│ │ │ ├─17丨如何使用Python操作MySQL？

│ │ │ ├─18丨SQLAlchemy：如何使用PythonORM框架来操作MySQL？

│ │ │ ├─19丨基础篇总结：如何理解查询优化、通配符以及存储过程？

│ │ │ ├─20丨当我们思考数据库调优的时候，都有哪些维度可以选择？

│ │ │ ├─21丨范式设计：数据表的范式有哪些，3NF指的是什么？

│ │ │ ├─22丨反范式设计：3NF有什么不足，为什么有时候需要反范式设计？

│ │ │ ├─23丨索引的概览：用还是不用索引，这是一个问题

│ │ │ ├─24丨索引的原理：我们为什么用B+树来做索引？

│ │ │ ├─25丨Hash索引的底层原理是什么？

│ │ │ ├─26丨索引的使用原则：如何通过索引让SQL查询效率最大化？

│ │ │ ├─27丨从数据页的角度理解B+树查询

│ │ │ ├─28丨从磁盘I-O的角度理解SQL查询的成本

│ │ │ ├─29丨为什么没有理想的索引？

│ │ │ ├─30丨锁：悲观锁和乐观锁是什么？

│ │ │ ├─31丨为什么大部分RDBMS都会支持MVCC？

│ │ │ ├─32丨查询优化器是如何工作的？

│ │ │ ├─33丨如何使用性能分析工具定位SQL执行慢的原因？

│ │ │ ├─34丨答疑篇：关于索引以及缓冲池的一些解惑

│ │ │ ├─35丨数据库主从同步的作用是什么，如何解决数据不一致问题？

│ │ │ ├─36丨数据库没有备份，没有使用Binlog的情况下，如何恢复数据？

│ │ │ ├─37丨SQL注入：你的SQL是如何被注入的？

│ │ │ ├─38丨如何在Excel中使用SQL语言？

│ │ │ ├─39丨WebSQL：如何在H5中存储一个本地数据库？

│ │ │ ├─40丨SQLite：为什么微信用SQLite存储聊天记录？

│ │ │ ├─41丨初识Redis：Redis为什么会这么快？

│ │ │ ├─42丨如何使用Redis来实现多用户抢票问题

│ │ │ ├─43丨如何使用Redis搭建玩家排行榜？

│ │ │ ├─44丨DBMS篇总结和答疑：用SQLite做词云

│ │ │ ├─45丨数据清洗：如何使用SQL对数据进行清洗？

│ │ │ ├─46丨数据集成：如何对各种数据库进行集成和转换？

│ │ │ ├─47丨如何利用SQL对零售数据进行分析？

│ │ │ ├─开篇词丨SQL可能是你掌握的最有用的技能

│ │ │ ├─期末测试丨对于SQL的有关内容，你掌握了多少呢？

│ │ │ ├─结束语-互联网的下半场是数据驱动的时代

│ │ │ └─结束语-互联网的下半场是数据驱动的时代

│ │ ├─054-黄勇的OKR实战笔记

│ │ │ ├─01-你想要快速理解OKR吗？看这篇文章就够了

│ │ │ ├─02-如果有人再问你，OKR与KPI有何区别？你可以这样告诉他

│ │ │ ├─03-如何在企业中有效落地OKR？你必须掌握这些技巧

│ │ │ ├─04-在落地OKR之前，需要具备哪些先决条件？

│ │ │ ├─05-OKR好用，但一不小心就容易被误用，为什么呢？

│ │ │ ├─054-黄勇的OKR实战笔记

│ │ │ ├─06-OKR大咖说：产品技术部门的OKR从何而来

│ │ │ ├─07-热点问题答疑（一）：你的OKR用对了吗？

│ │ │ ├─08-如何轻松制定OKR？方法原来如此简单

│ │ │ ├─09-推动团队高效执行OKR，你知道这些技巧吗？

│ │ │ ├─10-OKR评估没你想象的那么难，其实你可以这么做！

│ │ │ ├─11-都说OKR赢在复盘，为何大家都忽略了这个重要环节？

│ │ │ ├─12-落地OKR效果不理想？可能是你身边缺少一位“教练”

│ │ │ ├─13-OKR大咖说：一个可供创业公司参考的OKR落地实践

│ │ │ ├─14-热点问题答疑（二）：你该如何看待OKR？（文末有彩蛋）

│ │ │ ├─15-技术团队真的是“成本中心”吗？如何改变这一现状？

│ │ │ ├─16-大家都说“向上管理”很重要，你想学一些“套路”吗？

│ │ │ ├─17-跨部门协同费劲，沟通效率低，如何粉碎“部门墙”？

│ │ │ ├─18-企业“腰部力量”不够，如何提升中层领导力？

│ │ │ ├─19-敏捷与OKR都是为了“拥抱变化”，两者如何无缝整合？

│ │ │ ├─20-OKR大咖说：OKR还有哪些应用场景？

│ │ │ ├─21-热点问题答疑（三）：如何计算研发团队人效？

│ │ │ ├─22-面试人才好纠结，新人试用难考核？你其实可以这样做

│ │ │ ├─23-人才激励方式众多，哪种方式最有效？

│ │ │ ├─24-敏捷时代下你该如何做绩效管理？

│ │ │ ├─25-如何告别无效会议？不妨试试这六招

│ │ │ ├─26-OKR最容易踩的10个坑，你踩过几个？

│ │ │ ├─27-OKR大咖说：在硅谷公司使用OKR时，一个资深员工的体验和感悟

│ │ │ ├─28-如何避免“跳槽”变“跳坑”？

│ │ │ ├─29-他们落地OKR都失败了，原因出在哪儿？

│ │ │ ├─30-用什么工具，能加强OKR落地效果？

│ │ │ ├─31-工作之外如何应用OKR？以真实案例为例

│ │ │ ├─32-积分制、游戏化，一种新型的团队管理和协同方式

│ │ │ ├─33-无所不能的OKR，它会变成“银弹”吗？

│ │ │ ├─34-OKR大咖说：为何有些文化的因，结不出OKR的果？

│ │ │ ├─35-OKR学习测验：你是否真的学会了OKR？

│ │ │ ├─入学测验-你对OKR了解有多少？

│ │ │ ├─加餐-OKR思维能助你学会向上管理？

│ │ │ ├─加餐-一幅图，让你快速入门OKR

│ │ │ ├─加餐-如何灵活运用OKR？

│ │ │ ├─加餐-新型的团队管理和协作方式是怎样的？

│ │ │ ├─开篇词-神奇的OKR工作法

│ │ │ ├─结束语-OKR助我一路成长

│ │ │ └─结束语-OKR助我一路成长

│ │ ├─055-Flutter核心技术与实战

│ │ │ ├─01-预习篇·从0开始搭建Flutter工程环境

│ │ │ ├─02-预习篇·Dart语言概览

│ │ │ ├─03-深入理解跨平台方案的历史发展逻辑

│ │ │ ├─04-Flutter区别于其他方案的关键技术是什么？

│ │ │ ├─05-从标准模板入手，体会Flutter代码是如何运行在原生系统上的

│ │ │ ├─055-Flutter核心技术与实战

│ │ │ ├─06-基础语法与类型变量：Dart是如何表示信息的？

│ │ │ ├─07-函数、类与运算符：Dart是如何处理信息的？

│ │ │ ├─08-综合案例：掌握Dart核心特性

│ │ │ ├─09-Widget，构建Flutter界面的基石

│ │ │ ├─10-Widget中的State到底是什么？

│ │ │ ├─11-提到生命周期，我们是在说什么？

│ │ │ ├─12-经典控件（一）：文本、图片和按钮在Flutter中怎么用？

│ │ │ ├─13-经典控件（二）：UITableView-ListView在Flutter中是什么？

│ │ │ ├─14-经典布局：如何定义子控件在父容器中排版的位置？

│ │ │ ├─15-组合与自绘，我该选用何种方式自定义Widget？

│ │ │ ├─16-从夜间模式说起，如何定制不同风格的App主题？

│ │ │ ├─17-依赖管理（一）：图片、配置和字体在Flutter中怎么用？

│ │ │ ├─18-依赖管理（二）：第三方组件库在Flutter中要如何管理？

│ │ │ ├─19-用户交互事件该如何响应？

│ │ │ ├─20-关于跨组件传递数据，你只需要记住这三招

│ │ │ ├─21-路由与导航，Flutter是这样实现页面切换的

│ │ │ ├─22-如何构造炫酷的动画效果？

│ │ │ ├─23-单线程模型怎么保证UI运行流畅？

│ │ │ ├─24-HTTP网络编程与JSON解析

│ │ │ ├─25-本地存储与数据库的使用和优化

│ │ │ ├─26-如何在Dart层兼容Android-iOS平台特定实现？（一）

│ │ │ ├─27-如何在Dart层兼容Android-iOS平台特定实现？（二）

│ │ │ ├─28-如何在原生应用中混编Flutter工程？

│ │ │ ├─29-混合开发，该用何种方案管理导航栈？

│ │ │ ├─30-为什么需要做状态管理，怎么做？

│ │ │ ├─31-如何实现原生推送能力？

│ │ │ ├─32-适配国际化，除了多语言我们还需要注意什么

│ │ │ ├─33-如何适配不同分辨率的手机屏幕？

│ │ │ ├─34-如何理解Flutter的编译模式？

│ │ │ ├─35-HotReload是怎么做到的？

│ │ │ ├─36-如何通过工具链优化开发调试效率？

│ │ │ ├─37-如何检测并优化FlutterApp的整体性能表现？

│ │ │ ├─38-如何通过自动化测试提高交付质量？

│ │ │ ├─39-线上出现问题，该如何做好异常捕获与信息采集？

│ │ │ ├─40-衡量FlutterApp线上质量，我们需要关注这三个指标

│ │ │ ├─41-组件化和平台化，该如何组织合理稳定的Flutter工程结构？

│ │ │ ├─42-如何构建高效的FlutterApp打包发布环境？

│ │ │ ├─43-如何构建自己的Flutter混合开发框架（一）？

│ │ │ ├─44-如何构建自己的Flutter混合开发框架（二）？

│ │ │ ├─开篇词-为什么每一位大前端从业者都应该学习Flutter？

│ │ │ ├─特别放送｜温故而知新，与你说说专栏的那些思考题

│ │ │ ├─结束语-勿畏难，勿轻略

│ │ │ └─结课测试-关于Flutter的这些知识，你都掌握了吗？

│ │ ├─056-编辑训练营

│ │ │ ├─01-为什么说编辑要重视文字规范？

│ │ │ ├─02-如何发现并纠正文章语病？

│ │ │ ├─03-到底该怎么理解技术采用生命周期？

│ │ │ ├─04-如何取一个好的文章标题？

│ │ │ ├─05-怎么才能写出一篇好新闻？

│ │ │ ├─056-编辑训练营

│ │ │ ├─06-和专家沟通出现冲突时，我该怎么办？

│ │ │ ├─07-如何快速找到各个领域的专家？

│ │ │ ├─08-如何制作出一张清晰且美观的配图？

│ │ │ ├─开篇词-把内容交付这件事做好

│ │ │ └─开篇词-把内容交付这件事做好

│ │ ├─057-从0打造音视频直播系统

│ │ │ ├─01-原来通过浏览器访问摄像头这么容易

│ │ │ ├─02-如何通过WebRTC进行音视频设备检测呢？

│ │ │ ├─03-如何使用浏览器给自己拍照呢？

│ │ │ ├─04-可以把采集到的音视频数据录制下来吗？

│ │ │ ├─05-原来浏览器还能抓取桌面？

│ │ │ ├─057-从0打造音视频直播系统

│ │ │ ├─06-WebRTC中的RTP及RTCP详解

│ │ │ ├─07-你竟然不知道SDP？它可是WebRTC的驱动核心！

│ │ │ ├─08-有话好商量，论媒体协商

│ │ │ ├─09-让我们揭开WebRTC建立连接的神秘面纱

│ │ │ ├─10-WebRTCNAT穿越原理

│ │ │ ├─11-如何通过Node

│ │ │ ├─12-RTCPeerConnection：音视频实时通讯的核心

│ │ │ ├─13-在WebRTC中如何控制传输速率呢？

│ │ │ ├─14-如何打开-关闭音视频？

│ │ │ ├─15-WebRTC中的数据统计原来这么强大（上）

│ │ │ ├─16-WebRTC中的数据统计原来这么强大（下）

│ │ │ ├─17-如何使用Canvas绘制统计图表（上）？

│ │ │ ├─18-如何使用Canvas绘制统计图表（下）？

│ │ │ ├─19-WebRTC能不能进行文本聊天呢？

│ │ │ ├─20-原来WebRTC还可以实时传输文件？

│ │ │ ├─21-如何保证数据传输的安全（上）？

│ │ │ ├─22-如何保证数据传输的安全（下）？

│ │ │ ├─23-实战演练：通过WebRTC实现一个1对1音视频实时直播系统

│ │ │ ├─24-多人音视频实时通讯是怎样的架构？

│ │ │ ├─25-那些常见的流媒体服务器，你该选择谁？

│ │ │ ├─26-为什么编译MedoozeServer这么难？

│ │ │ ├─27-让我们一起探索Medooze的具体实现吧（上）

│ │ │ ├─28-让我们一起探索Medooze的具体实现吧（下）

│ │ │ ├─29-如何使用Medooze实现多方视频会议？

│ │ │ ├─30-实战演练：通过WebRTC实现多人音视频实时互动直播系统

│ │ │ ├─31-一对多直播系统RTMP-HLS，你该选哪个？

│ │ │ ├─32-HLS：实现一对多直播系统的必备协议

│ │ │ ├─33-FLV：适合录制的多媒体格式

│ │ │ ├─34-如何使用Nginx搭建最简单的直播服务器？

│ │ │ ├─35-如何构建云端一对多直播系统？

│ │ │ ├─36-如何使用flv

│ │ │ ├─37-如何使用video

│ │ │ ├─38-实战推演：带你实现一个支持万人同时在线的直播系统

│ │ │ ├─开篇词-5G的到来将会为音视频插上飞翔的翅膀

│ │ │ ├─结束语-路漫漫其修远兮，吾将上下而求索

│ │ │ └─结课测试-这些音视频直播系统的知识你都掌握了吗？

│ │ ├─058-消息队列高手课

│ │ │ ├─01-为什么需要消息队列？

│ │ │ ├─02-该如何选择消息队列？

│ │ │ ├─03-消息模型：主题和队列有什么区别？

│ │ │ ├─04-如何利用事务消息实现分布式事务？

│ │ │ ├─05-如何确保消息不会丢失

│ │ │ ├─058-消息队列高手课

│ │ │ ├─06-如何处理消费过程中的重复消息？

│ │ │ ├─07-消息积压了该如何处理？

│ │ │ ├─08-答疑解惑（一）-网关如何接收服务端的秒杀结果？

│ │ │ ├─09-学习开源代码该如何入手？

│ │ │ ├─10-如何使用异步设计提升系统性能？

│ │ │ ├─11-如何实现高性能的异步网络传输？

│ │ │ ├─12-序列化与反序列化：如何通过网络传输结构化的数据？

│ │ │ ├─13-传输协议：应用程序之间对话的语言

│ │ │ ├─14-内存管理：如何避免内存溢出和频繁的垃圾回收？

│ │ │ ├─15-Kafka如何实现高性能IO？

│ │ │ ├─16-缓存策略：如何使用缓存来减少磁盘IO？

│ │ │ ├─17-如何正确使用锁保护共享数据，协调异步线程？

│ │ │ ├─18-如何用硬件同步原语（CAS）替代锁？

│ │ │ ├─19-数据压缩：时间换空间的游戏

│ │ │ ├─20-RocketMQProducer源码分析：消息生产的实现过程

│ │ │ ├─21-KafkaConsumer源码分析：消息消费的实现过程

│ │ │ ├─22-Kafka和RocketMQ的消息复制实现的差异点在哪？

│ │ │ ├─23-RocketMQ客户端如何在集群中找到正确的节点？

│ │ │ ├─24-Kafka的协调服务ZooKeeper：实现分布式系统的“瑞士军刀”

│ │ │ ├─25-RocketMQ与Kafka中如何实现事务？

│ │ │ ├─26-MQTT协议：如何支持海量的在线IoT设备

│ │ │ ├─27-Pulsar的存储计算分离设计：全新的消息队列设计思路

│ │ │ ├─28-答疑解惑（二）：我的100元哪儿去了？

│ │ │ ├─29-流计算与消息（一）：通过Flink理解流计算的原理

│ │ │ ├─30-流计算与消息（二）：在流计算中使用Kafka链接计算任务

│ │ │ ├─31-动手实现一个简单的RPC框架（一）：原理和程序的结构

│ │ │ ├─32-动手实现一个简单的RPC框架（二）：通信与序列化

│ │ │ ├─33-动手实现一个简单的RPC框架（三）：客户端

│ │ │ ├─34-动手实现一个简单的RPC框架（四）：服务端

│ │ │ ├─35-答疑解惑（三）：主流消息队列都是如何存储消息的？

│ │ │ ├─加餐-JMQ的Broker是如何异步处理消息的？

│ │ │ ├─开篇词-优秀的程序员，你的技术栈中不能只有“增删改查”

│ │ │ ├─期中测试丨10个消息队列热点问题自测

│ │ │ ├─期末测试-消息队列100分试卷等你来挑战！

│ │ │ ├─第二季回归丨这次我们一起实战后端存储

│ │ │ ├─结束语-程序员如何构建知识体系？

│ │ │ ├─预习-怎样更好地学习这门课？

│ │ │ └─预习-怎样更好地学习这门课？

│ │ ├─059-网络编程实战

│ │ │ ├─01-追古溯源：TCP-IP和Linux是如何改变世界的？

│ │ │ ├─02-网络编程模型：认识客户端-服务器网络模型的基本概念

│ │ │ ├─03丨套接字和地址：像电话和电话号码一样理解它们

│ │ │ ├─04-TCP三次握手：怎么使用套接字格式建立连接？

│ │ │ ├─05-使用套接字进行读写：开始交流吧

│ │ │ ├─059-网络编程实战

│ │ │ ├─06-嗨，别忘了UDP这个小兄弟

│ │ │ ├─07-What-还有本地套接字？

│ │ │ ├─08-工欲善其事必先利其器：学会使用各种工具

│ │ │ ├─09丨答疑篇：学习网络编程前，需要准备哪些东西？

│ │ │ ├─10-TIMEWAIT：隐藏在细节下的魔鬼

│ │ │ ├─11-优雅地关闭还是粗暴地关闭

│ │ │ ├─12-连接无效：使用Keep-Alive还是应用心跳来检测？

│ │ │ ├─13-小数据包应对之策：理解TCP协议中的动态数据传输

│ │ │ ├─14丨UDP也可以是“已连接”？

│ │ │ ├─15-怎么老是出现“地址已经被使用”？

│ │ │ ├─16-如何理解TCP的“流”？

│ │ │ ├─17-TCP并不总是“可靠”的？

│ │ │ ├─18-防人之心不可无：检查数据的有效性

│ │ │ ├─19丨提高篇答疑：如何理解TCP四次挥手？

│ │ │ ├─20-大名??的select：看我如何同时感知多个I-O事件

│ │ │ ├─21-poll：另一种I-O多路复用

│ │ │ ├─22-非阻塞I-O：提升性能的加速器

│ │ │ ├─23-Linux利器：epoll的前世今生

│ │ │ ├─24-C10K问题：高并发模型设计

│ │ │ ├─25-使用阻塞I-O和进程模型：最传统的方式

│ │ │ ├─26-使用阻塞I-O和线程模型：换一种轻量的方式

│ │ │ ├─27-I-O多路复用遇上线程：使用poll单线程处理所有I-O事件

│ │ │ ├─28-I-O多路复用进阶：子线程使用poll处理连接I-O事件

│ │ │ ├─29-渐入佳境：使用epoll和多线程模型

│ │ │ ├─30-真正的大杀器：异步I-O探索

│ │ │ ├─31丨性能篇答疑：epoll源码深度剖析

│ │ │ ├─32-自己动手写高性能HTTP服务器（一）：设计和思路

│ │ │ ├─33-自己动手写高性能HTTP服务器（二）：I-O模型和多线程模型实现

│ │ │ ├─34-自己动手写高性能HTTP服务器（三）：TCP字节流处理和HTTP协议实现

│ │ │ ├─35-答疑：编写高性能网络编程框架时，都需要注意哪些问题？

│ │ │ ├─开篇词-学好网络编程，需要掌握哪些核心问题？

│ │ │ ├─期中大作业丨动手编写一个自己的程序吧！

│ │ │ ├─期中大作业丨题目以及解答剖析

│ │ │ ├─期末测试题丨有关网络编程的知识，你掌握了多少呢？

│ │ │ ├─结束语丨我相信这不是结束，让我们江湖再见

│ │ │ └─结束语丨我相信这不是结束，让我们江湖再见

│ │ ├─060-浏览器工作原理与实践

│ │ │ ├─01-Chrome架构：仅仅打开了1个页面，为什么有4个进程？

│ │ │ ├─02-TCP协议：如何保证页面文件能被完整送达浏览器？

│ │ │ ├─03-HTTP请求流程：为什么很多站点第二次打开速度会很快？

│ │ │ ├─04-导航流程：从输入URL到页面展示，这中间发生了什么？

│ │ │ ├─05-渲染流程（上）：HTML、CSS和JavaScript，是如何变成页面的？

│ │ │ ├─06-渲染流程（下）：HTML、CSS和JavaScript，是如何变成页面的？

│ │ │ ├─060-浏览器工作原理与实践

│ │ │ ├─07-变量提升：JavaScript代码是按顺序执行的吗？

│ │ │ ├─08-调用栈：为什么JavaScript代码会出现栈溢出？

│ │ │ ├─09-块级作用域：var缺陷以及为什么要引入let和const？

│ │ │ ├─10-作用域链和闭包：代码中出现相同的变量，JavaScript引擎是如何选择的？

│ │ │ ├─11-this：从JavaScript执行上下文的视角讲清楚this

│ │ │ ├─12-栈空间和堆空间：数据是如何存储的？

│ │ │ ├─13-垃圾回收：垃圾数据是如何自动回收的？

│ │ │ ├─14-编译器和解释器：V8是如何执行一段JavaScript代码的？

│ │ │ ├─15-消息队列和事件循环：页面是怎么“活”起来的？

│ │ │ ├─16-WebAPI：setTimeout是如何实现的？

│ │ │ ├─17-WebAPI：XMLHttpRequest是怎么实现的？

│ │ │ ├─18-宏任务和微任务：不是所有任务都是一个待遇

│ │ │ ├─19-Promise：使用Promise，告别回调函数

│ │ │ ├─20-async-await：使用同步的方式去写异步代码

│ │ │ ├─21-Chrome开发者工具：利用网络面板做性能分析

│ │ │ ├─22-DOM树：JavaScript是如何影响DOM树构建的？

│ │ │ ├─23-渲染流水线：CSS如何影响首次加载时的白屏时间？

│ │ │ ├─24-分层和合成机制：为什么CSS动画比JavaScript高效？

│ │ │ ├─25-页面性能：如何系统地优化页面？

│ │ │ ├─26-虚拟DOM：虚拟DOM和实际的DOM有何不同？

│ │ │ ├─27-渐进式网页应用（PWA）：它究竟解决了Web应用的哪些问题？

│ │ │ ├─28-WebComponent：像搭积木一样构建Web应用

│ │ │ ├─29-HTTP-1：HTTP性能优化

│ │ │ ├─30｜HTTP-2：如何提升网络速度？

│ │ │ ├─31｜HTTP-3：甩掉TCP、TLS的包袱，构建高效网络

│ │ │ ├─32-同源策略：为什么XMLHttpRequest不能跨域请求资源？

│ │ │ ├─33-跨站脚本攻击（XSS）：为什么Cookie中有HttpOnly属性？

│ │ │ ├─34-CSRF攻击：陌生链接不要随便点

│ │ │ ├─35-安全沙箱：页面和系统之间的隔离墙

│ │ │ ├─36-HTTPS：让数据传输更安全

│ │ │ ├─加餐一｜浏览上下文组：如何计算Chrome中渲染进程的个数？

│ │ │ ├─加餐三｜加载阶段性能：使用Audits来优化Web性能

│ │ │ ├─加餐二｜任务调度：有了setTimeOut，为什么还要使用rAF？

│ │ │ ├─加餐五-性能分析工具：如何分析Performance中的Main指标？

│ │ │ ├─加餐六｜HTTPS：浏览器如何验证数字证书？

│ │ │ ├─加餐四｜页面性能工具：如何使用Performance？

│ │ │ ├─开篇词-参透了浏览器的工作原理，你就能解决80%的前端难题

│ │ │ ├─第二季回归-这次我们来专门聊聊V8

│ │ │ ├─结束语-大道至简

│ │ │ └─结课测试-这些浏览器的知识你都掌握了吗？

│ │ ├─061-编译原理之美

│ │ │ ├─01-理解代码：编译器的前端技术

│ │ │ ├─02-正则文法和有限自动机：纯手工打造词法分析器

│ │ │ ├─03-语法分析（一）：纯手工打造公式计算器

│ │ │ ├─04-语法分析（二）：解决二元表达式中的难点

│ │ │ ├─05-语法分析（三）：实现一门简单的脚本语言

│ │ │ ├─06-编译器前端工具（一）：用Antlr生成词法、语法分析器

│ │ │ ├─061-编译原理之美

│ │ │ ├─07-编译器前端工具（二）：用Antlr重构脚本语言

│ │ │ ├─08-作用域和生存期：实现块作用域和函数

│ │ │ ├─09-面向对象：实现数据和方法的封装

│ │ │ ├─10-闭包：理解了原理，它就不反直觉了

│ │ │ ├─11-语义分析（上）：如何建立一个完善的类型系统？

│ │ │ ├─12-语义分析（下）：如何做上下文相关情况的处理？

│ │ │ ├─13-继承和多态：面向对象运行期的动态特性

│ │ │ ├─14-前端技术应用（一）：如何透明地支持数据库分库分表？

│ │ │ ├─15-前端技术应用（二）：如何设计一个报表工具？

│ │ │ ├─16-NFA和DFA：如何自己实现一个正则表达式工具？

│ │ │ ├─17-First和Follow集合：用LL算法推演一个实例

│ │ │ ├─18-移进和规约：用LR算法推演一个实例

│ │ │ ├─19-案例总结与热点问题答疑：对于左递归的语法，为什么我的推导不是左递归的？

│ │ │ ├─20-高效运行：编译器的后端技术

│ │ │ ├─21-运行时机制：突破现象看本质，透过语法看运行时

│ │ │ ├─22-生成汇编代码（一）：汇编语言其实不难学

│ │ │ ├─23-生成汇编代码（二）：把脚本编译成可执行文件

│ │ │ ├─24-中间代码：兼容不同的语言和硬件

│ │ │ ├─25-后端技术的重用：LLVM不仅仅让你高效

│ │ │ ├─26-生成IR：实现静态编译的语言

│ │ │ ├─27-代码优化：为什么你的代码比他的更高效？

│ │ │ ├─28-数据流分析：你写的程序，它更懂

│ │ │ ├─29-目标代码的生成和优化（一）：如何适应各种硬件架构？

│ │ │ ├─30-目标代码的生成和优化（二）：如何适应各种硬件架构？

│ │ │ ├─31-内存计算：对海量数据做计算，到底可以有多快？

│ │ │ ├─32-字节码生成：为什么Spring技术很强大？

│ │ │ ├─33-垃圾收集：能否不停下整个世界？

│ │ │ ├─34-运行时优化：即时编译的原理和作用

│ │ │ ├─35-案例总结与热点问题答疑：后端部分真的比前端部分难吗？

│ │ │ ├─36-当前技术的发展趋势以及其对编译技术的影响

│ │ │ ├─37-云编程：云计算会如何改变编程模式？

│ │ │ ├─38-元编程：一边写程序，一边写语言

│ │ │ ├─加餐-汇编代码编程与栈帧管理

│ │ │ ├─开篇词-为什么你要学习编译原理？

│ │ │ ├─期中考试-来赴一场100分的约定吧！

│ │ │ ├─用户故事-因为热爱，所以坚持

│ │ │ ├─第二季回归-这次，我们一起实战解析真实世界的编译器

│ │ │ ├─结束语-用程序语言，推动这个世界的演化

│ │ │ └─结课测试-编译原理的这些知识，你都掌握了吗？

│ │ ├─062-研发效率破局之道

│ │ │ ├─01-效能模型：如何系统地理解研发效能？

│ │ │ ├─02-效能度量：效果不好甚至有副作用，怎么回事？

│ │ │ ├─03-效能度量：如何选对指标与方法，真正提升效能？

│ │ │ ├─04-流程优化：怎样才能让敏捷、精益真正为我所用？

│ │ │ ├─05-代码入库前：Facebook如何让开发人员聚焦于开发？

│ │ │ ├─06-代码入库到产品上线：Facebook如何使用CI-CD满足业务要求？

│ │ │ ├─062-研发效率破局之道

│ │ │ ├─07-分支管理：Facebook的策略，适合我的团队吗？

│ │ │ ├─08-DevOps、SRE的共性：应用全栈思路打通开发和运维

│ │ │ ├─09-信息流通：让团队高效协同，让产品准确击中目标

│ │ │ ├─10-答疑篇：反对996并不是反对奋斗

│ │ │ ├─11-研发环境：Facebook怎样让开发人员不再操心环境？

│ │ │ ├─12-代码审查：哪种方式更适合我的团队？

│ │ │ ├─13-代码审查：学习Facebook真正发挥代码审查的提效作用

│ │ │ ├─14-质量与速度的均衡：让“唯快不破”快得更持久

│ │ │ ├─15-开源：从Phabricator的开源历程看开源利弊

│ │ │ ├─16-高效上云：如何用云计算来提高效能？

│ │ │ ├─17-测试左移：测试如何应对新的开发模式？

│ │ │ ├─18-蓝绿红黑灰度发布：这些五颜六色的发布到底怎么用？

│ │ │ ├─19-不再掉队，研发流程、工程方法趋势解读和展望

│ │ │ ├─20-答疑篇：如何平衡短期收益和长期收益？

│ │ │ ├─21-高效工作：Facebook的10x程序员效率心法

│ │ │ ├─22-深度工作：聚焦最有价值的事儿

│ │ │ ├─23-效率工具：选对用对才能事半功倍

│ │ │ ├─24-VIM：如何高性价比地学习VIM的实用技巧？

│ │ │ ├─25-玩转Git：五种提高代码提交原子性的基本操作

│ │ │ ├─26-Facebook怎样实现代码提交的原子性？

│ │ │ ├─27-命令行：不只是酷，更重要的是能提高个人效能

│ │ │ ├─28-从工作场景出发，寻找炫酷且有效的命令行工具

│ │ │ ├─29-1+1-2，灵活的工具组合及环境让你的工作效率翻倍

│ │ │ ├─30-答疑篇：关于价值导向和沟通

│ │ │ ├─31-业务目标和技术目标两手抓：怎样打造高效团队？

│ │ │ ├─32-从Netflix公开的著名PPT谈硅谷公司文化

│ │ │ ├─33-Facebook企业文化：工程师文化是创造力引擎

│ │ │ ├─34-Facebook工程师文化实践三大支柱之一做感兴趣的事

│ │ │ ├─35-Facebook工程师文化实践三大支柱之二拥有信息和权限

│ │ │ ├─36-Facebook工程师文化实践三大支柱之三绩效调节

│ │ │ ├─开篇词-为什么你要关注研发效能？

│ │ │ ├─特别放送-每个开发人员都应该学一些VIM

│ │ │ ├─结束语-超越昨天的自己，享受成长的快乐

│ │ │ └─结课测试-关于研发效率的这些知识，你都掌握了吗？

│ │ ├─063-即时消息技术剖析与实战

│ │ │ ├─01-架构与特性：一个完整的IM系统是怎样的？

│ │ │ ├─02-消息收发架构：为你的App，加上实时通信功能

│ │ │ ├─03-轮询与长连接：如何解决消息的实时到达问题？

│ │ │ ├─04-ACK机制：如何保证消息的可靠投递？

│ │ │ ├─05-消息序号生成器：如何保证你的消息不会乱序？

│ │ │ ├─06-HttpDNS和TLS：你的消息聊天真的安全吗？

│ │ │ ├─063-即时消息技术剖析与实战

│ │ │ ├─07-分布式锁和原子性：你看到的未读消息提醒是真的吗？

│ │ │ ├─08-智能心跳机制：解决网络的不确定性

│ │ │ ├─09-分布式一致性：让你的消息支持多终端漫游

│ │ │ ├─10-自动智能扩缩容：直播互动场景中峰值流量的应对

│ │ │ ├─11-期中实战：动手写一个简易版的IM系统

│ │ │ ├─12-服务高可用：保证核心链路稳定性的流控和熔断机制

│ │ │ ├─13-HTTPTunnel：复杂网络下消息通道高可用设计的思考

│ │ │ ├─14-分片上传：如何让你的图片、音视频消息发送得更快？

│ │ │ ├─15-CDN加速：如何让你的图片、视频、语音消息浏览播放不卡？

│ │ │ ├─16-APNs：聊一聊第三方系统级消息通道的事

│ │ │ ├─17-Cache：多级缓存架构在消息系统中的应用

│ │ │ ├─18-Docker容器化：说一说IM系统中模块水平扩展的实现

│ │ │ ├─19-端到端Trace：消息收发链路的监控体系搭建

│ │ │ ├─20-存储和并发：万人群聊系统设计中的几个难点

│ │ │ ├─21-期末实战：为你的简约版IM系统，加上功能

│ │ │ ├─22-答疑解惑：不同即时消息场景下架构实现上的异同

│ │ │ ├─开篇词-搞懂“实时交互”的IM技术，将会有什么新机遇？

│ │ │ ├─结束语-真正的高贵，不是优于别人，而是优于过去的自己

│ │ │ └─结课测试-“即时消息技术剖析与实战”100分试卷等你来挑战！

│ │ ├─064-全栈工程师修炼指南

│ │ │ ├─01-网络互联的昨天、今天和明天：HTTP协议的演化

│ │ │ ├─02-为HTTP穿上盔甲：HTTPS

│ │ │ ├─03-换个角度解决问题：服务端推送技术

│ │ │ ├─04-工整与自由的风格之争：SOAP和REST

│ │ │ ├─05-权衡的艺术：漫谈WebAPI的设计

│ │ │ ├─06-特别放送：北美大厂如何招聘全栈工程师？

│ │ │ ├─064-全栈工程师修炼指南

│ │ │ ├─07-解耦是永恒的主题：MVC框架的发展

│ │ │ ├─08-MVC架构解析：模型（Model）篇

│ │ │ ├─09-MVC架构解析：视图（View）篇

│ │ │ ├─10-MVC架构解析：控制器（Controller）篇

│ │ │ ├─11-剑走偏锋：面向切面编程

│ │ │ ├─12-唯有套路得人心：谈谈JavaEE的那些模式

│ │ │ ├─13-特别放送：选择比努力更重要

│ │ │ ├─14-别有洞天：从后端到前端

│ │ │ ├─15-重剑无锋，大巧不工：JavaScript面向对象

│ │ │ ├─16-百花齐放，百家争鸣：前端MVC框架

│ │ │ ├─17-不一样的体验：交互设计和页面布局

│ │ │ ├─18-千言万语不及一幅画：谈谈数据可视化

│ │ │ ├─19-打开潘多拉盒子：JavaScript异步编程

│ │ │ ├─20-特别放送：全栈团队的角色构成

│ │ │ ├─21-赫赫有名的双刃剑：缓存（上）

│ │ │ ├─22-赫赫有名的双刃剑：缓存（下）

│ │ │ ├─23-知其然，知其所以然：数据的持久化和一致性

│ │ │ ├─24-尺有所短，寸有所长：CAP和数据存储技术选择

│ │ │ ├─25-设计数据持久层（上）：理论分析

│ │ │ ├─26-设计数据持久层（下）：案例介绍

│ │ │ ├─27-特别放送：聊一聊代码审查

│ │ │ ├─28-Ops三部曲之一：配置管理

│ │ │ ├─29-Ops三部曲之二：集群部署

│ │ │ ├─30-Ops三部曲之三：测试和发布

│ │ │ ├─31-防人之心不可无：网站安全问题窥视

│ │ │ ├─32-和搜索引擎的对话：SEO的原理和基础

│ │ │ ├─33-特别放送：聊一聊程序员学英语

│ │ │ ├─34-网站性能优化（上）

│ │ │ ├─35-网站性能优化（下）

│ │ │ ├─36-全栈开发中的算法（上）

│ │ │ ├─37-全栈开发中的算法（下）

│ │ │ ├─38-分页的那些事儿

│ │ │ ├─39-XML、JSON、YAML比较

│ │ │ ├─40-全栈衍化：让全栈意味着更多

│ │ │ ├─全栈回顾-成为更好的全栈工程师！

│ │ │ ├─好书荐读：小众书也有看头儿

│ │ │ ├─学习路径-怎样成为一名优秀的全栈工程师？

│ │ │ ├─导读-如何学习这个专栏？

│ │ │ ├─开篇词-从成长角度看，为什么你应该成为全栈工程师？

│ │ │ └─期末测试-对于全栈的内容，你掌握了多少呢？

│ │ ├─065-高并发系统设计40问

│ │ │ ├─01-高并发系统：它的通用设计方法是什么？

│ │ │ ├─02-架构分层：我们为什么一定要这么做？

│ │ │ ├─03-系统设计目标（一）：如何提升系统性能？

│ │ │ ├─04-系统设计目标（二）：系统怎样做到高可用？

│ │ │ ├─05-系统设计目标（三）：如何让系统易于扩展？

│ │ │ ├─06-面试现场第一期：当问到组件实现原理时，面试官是在刁难你吗？

│ │ │ ├─065-高并发系统设计40问

│ │ │ ├─07-池化技术：如何减少频繁创建数据库连接的性能损耗？

│ │ │ ├─08-数据库优化方案（一）：查询请求增加时，如何做主从分离？

│ │ │ ├─09-数据库优化方案（二）：写入数据量增加时，如何实现分库分表？

│ │ │ ├─10-发号器：如何保证分库分表后ID的全局唯一性？

│ │ │ ├─11-NoSQL：在高并发场景下，数据库和NoSQL如何做到互补？

│ │ │ ├─12-缓存：数据库成为瓶颈后，动态数据的查询要如何加速？

│ │ │ ├─13-缓存的使用姿势（一）：如何选择缓存的读写策略？

│ │ │ ├─14-缓存的使用姿势（二）：缓存如何做到高可用？

│ │ │ ├─15-缓存的使用姿势（三）：缓存穿透了怎么办？

│ │ │ ├─16-CDN：静态资源如何加速？

│ │ │ ├─17-消息队列：秒杀时如何处理每秒上万次的下单请求？

│ │ │ ├─18-消息投递：如何保证消息仅仅被消费一次？

│ │ │ ├─19-消息队列：如何降低消息队列系统中消息的延迟？

│ │ │ ├─20-面试现场第二期：当问到项目经历时，面试官究竟想要了解什么？

│ │ │ ├─21-系统架构：每秒1万次请求的系统要做服务化拆分吗？

│ │ │ ├─22-微服务架构：微服务化后系统架构要如何改造？

│ │ │ ├─23-RPC框架：10万QPS下如何实现毫秒级的服务调用？

│ │ │ ├─24-注册中心：分布式系统如何寻址？

│ │ │ ├─25-分布式Trace：横跨几十个分布式组件的慢请求要如何排查？

│ │ │ ├─26-负载均衡：怎样提升系统的横向扩展能力？

│ │ │ ├─27-API网关：系统的门面要如何做呢？

│ │ │ ├─28-多机房部署：跨地域的分布式系统如何做？

│ │ │ ├─29-ServiceMesh：如何屏蔽服务化系统的服务治理细节？

│ │ │ ├─30-给系统加上眼睛：服务端监控要怎么做？

│ │ │ ├─31-应用性能管理：用户的使用体验应该如何监控？

│ │ │ ├─32-压力测试：怎样设计全链路压力测试平台？

│ │ │ ├─33-配置管理：成千上万的配置项要如何管理？

│ │ │ ├─34-降级熔断：如何屏蔽非核心系统故障的影响？

│ │ │ ├─35-流量控制：高并发系统中我们如何操纵流量？

│ │ │ ├─36-面试现场第三期：你要如何准备一场技术面试呢？

│ │ │ ├─37-计数系统设计（一）：面对海量数据的计数器要如何做？

│ │ │ ├─38-计数系统设计（二）：50万QPS下如何设计未读数系统？

│ │ │ ├─39-信息流设计（一）：通用信息流系统的推模式要如何做？

│ │ │ ├─40-信息流设计（二）：通用信息流系统的拉模式要如何做？

│ │ │ ├─加餐-数据的迁移应该如何做？

│ │ │ ├─开篇词-为什么你要学习高并发系统设计？

│ │ │ ├─春节特别策划-我们如何准备抵抗流量峰值？

│ │ │ ├─春节特别策划-高并发下如何发现和排查问题？

│ │ │ ├─期中测试-10道高并发系统设计题目自测

│ │ │ ├─用户故事-从“心”出发，我还有无数个可能

│ │ │ ├─结束语-学不可以已

│ │ │ ├─结课测试-高并发系统设计的相关知识，你都掌握了吗？

│ │ │ └─结课问卷获奖用户名单

│ │ ├─066-分布式技术原理与算法解析

│ │ │ ├─01-分布式缘何而起：从单兵，到游击队，到集团军

│ │ │ ├─02-分布式系统的指标：啥是分布式的三围

│ │ │ ├─03-分布式互斥：有你没我，有我没你

│ │ │ ├─04-分布式选举：国不可一日无君

│ │ │ ├─05-分布式共识：存异求同

│ │ │ ├─06-分布式事务：Allornothing

│ │ │ ├─066-分布式技术原理与算法解析

│ │ │ ├─07-分布式锁：关键重地，非请勿入

│ │ │ ├─08-分布式技术是如何引爆人工智能的？

│ │ │ ├─09-分布式体系结构之集中式结构：一人在上，万人在下

│ │ │ ├─10-分布式体系结构之非集中式结构：众生平等

│ │ │ ├─11-分布式调度架构之单体调度：物质文明、精神文明一手抓

│ │ │ ├─12-分布式调度架构之两层调度：物质文明、精神文明两手抓

│ │ │ ├─13-分布式调度架构之共享状态调度：物质文明、精神文明多手协商抓

│ │ │ ├─14-答疑篇：分布式事务与分布式锁相关问题

│ │ │ ├─15-分布式计算模式之MR：一门同流合污的艺术

│ │ │ ├─16-分布式计算模式之Stream：一门背锅的艺术

│ │ │ ├─17-分布式计算模式之Actor：一门甩锅的艺术

│ │ │ ├─18-分布式计算模式之流水线：你方唱罢我登场

│ │ │ ├─19-分布式通信之远程调用：我是你的千里眼

│ │ │ ├─20-分布式通信之发布订阅：送货上门

│ │ │ ├─21-分布式通信之消息队列：货物自取

│ │ │ ├─22-答疑篇：分布式体系架构与分布式计算相关问题

│ │ │ ├─23-CAP理论：这顶帽子我不想要

│ │ │ ├─24-分布式数据存储系统之三要素：顾客、导购与货架

│ │ │ ├─25-数据分布方式之哈希与一致性哈希：“掐指一算”与“掐指两算”的事

│ │ │ ├─26-分布式数据复制技术：分身有术

│ │ │ ├─27-分布式数据之缓存技术：“身手钥钱”随身带

│ │ │ ├─28-分布式高可靠之负载均衡：不患寡，而患不均

│ │ │ ├─29-分布式高可靠之流量控制：大禹治水，在疏不在堵

│ │ │ ├─30-分布式高可用之故障隔离：当断不断，反受其乱

│ │ │ ├─31-分布式高可用之故障恢复：知错能改，善莫大焉

│ │ │ ├─32-答疑篇：如何判断并解决网络分区问题？

│ │ │ ├─33-知识串联：以购买火车票的流程串联分布式核心技术

│ │ │ ├─34-搭建一个分布式实验环境：纸上得来终觉浅，绝知此事要躬行

│ │ │ ├─开篇词-四纵四横，带你透彻理解分布式技术

│ │ │ ├─特别放送-Jackey：寄语天涯客，轻寒底用愁

│ │ │ ├─特别放送-分布式下的一致性杂谈

│ │ │ ├─特别放送-崔新：追根溯源，拨开云雾见青天

│ │ │ ├─特别放送-徐志强：学习这件事儿，不到长城非好汉

│ │ │ ├─特别放送-那些你不能错过的分布式系统论文

│ │ │ ├─结束语-为什么说提升职业竞争力要从尊重、诚实开始？

│ │ │ ├─结课测试-关于分布式的这些知识点，你都掌握了吗？

│ │ ├─067-说透中台

│ │ │ ├─01-来龙去脉：中台为什么这么火？

│ │ │ ├─02-中台种类：你听说的中台真的是中台吗？

│ │ │ ├─03-中台定义：当我们谈中台时到底在谈些什么？

│ │ │ ├─04-万事预则立：中台建设前必须想清楚的四个问题

│ │ │ ├─05-D4模型：中台规划建设方法论概述

│ │ │ ├─06-中台落地第一步：企业战略分解及现状调研（Discovery）

│ │ │ ├─067-说透中台

│ │ │ ├─07-中台落地第二步：企业数字化全景规划（Define）

│ │ │ ├─08-中台落地第三步：中台的规划与设计（Design）

│ │ │ ├─09-中台落地第四步：中台的建设与接入（Delivery）

│ │ │ ├─10-总结：中台落地工具资源汇总

│ │ │ ├─开篇词-中台，昙花一现还是下一个风口？

│ │ │ ├─答疑篇（上）-你问我答，关于中台还有哪些困惑？

│ │ │ ├─答疑篇（下）-你问我答，关于中台还有哪些困惑？

│ │ │ └─结课测试｜“说透中台”100分试卷等你来挑战

│ │ ├─068-DevOps实战笔记

│ │ │ ├─01-DevOps的“定义”：DevOps究竟要解决什么问题？

│ │ │ ├─02-DevOps的价值：数字化转型时代，DevOps是必选项？

│ │ │ ├─03-DevOps的实施：到底是工具先行还是文化先行？

│ │ │ ├─04-DevOps的衡量：你是否找到了DevOps的实施路线图？

│ │ │ ├─05-价值流分析：关于DevOps转型，我们应该从何处入手？

│ │ │ ├─06-转型之路：企业实施DevOps的常见路径和问题

│ │ │ ├─068-DevOps实战笔记

│ │ │ ├─07-业务敏捷：帮助DevOps快速落地的源动力

│ │ │ ├─08-精益看板（上）：精益驱动的敏捷开发方法

│ │ │ ├─09-精益看板（下）：精益驱动的敏捷开发方法

│ │ │ ├─10-配置管理：最容易被忽视的DevOps工程实践基础

│ │ │ ├─11-分支策略：让研发高效协作的关键要素

│ │ │ ├─12-持续集成：你说的CI和我说的CI是一回事吗？

│ │ │ ├─13-自动化测试：DevOps的阿克琉斯之踵

│ │ │ ├─14-内建质量：丰田和亚马逊给我们的启示

│ │ │ ├─15-技术债务：那些不可忽视的潜在问题

│ │ │ ├─16-环境管理：一切皆代码是一种什么样的体验？

│ │ │ ├─17-部署管理：低风险的部署发布策略

│ │ │ ├─18-混沌工程：软件领域的反脆弱

│ │ │ ├─19-正向度量：如何建立完整的DevOps度量体系？

│ │ │ ├─20-持续改进：PDCA体系和持续改进的意义

│ │ │ ├─21-开源还是自研：企业DevOps平台建设的三个阶段

│ │ │ ├─22-产品设计之道：DevOps产品设计的五个层次

│ │ │ ├─23-持续交付平台：现代流水线必备的十大特征（上）

│ │ │ ├─24-持续交付平台：现代流水线必备的十大特征（下）

│ │ │ ├─25-让数据说话：如何建设企业级数据度量平台？

│ │ │ ├─26-平台产品研发：三个月完成千人规模的产品要怎么做？

│ │ │ ├─27-巨人的肩膀：那些你不能忽视的开源工具

│ │ │ ├─28-迈向云端：云原生应用时代的平台思考

│ │ │ ├─29-向前一步：万人规模企业的DevOps实战转型案例（上）

│ │ │ ├─30-向前一步：万人规模企业的DevOps实战转型案例（下）

│ │ │ ├─开篇词-从默默无闻到风靡全球，DevOps究竟有什么魔力？

│ │ │ ├─期中总结-3个典型问题答疑及如何高效学习

│ │ │ ├─期末总结-在云时代，如何选择一款合适的流水线工具？

│ │ │ ├─期末测试-这些DevOps核心知识，你都掌握了吗？

│ │ │ ├─特别放送（一）-成为DevOps工程师的必备技能（上）

│ │ │ ├─特别放送（三）-学习DevOps不得不了解的经典资料

│ │ │ ├─特别放送（二）-成为DevOps工程师的必备技能（下）

│ │ │ ├─特别放送（五）-关于DevOps组织和文化的那些趣事儿

│ │ │ ├─特别放送（四）-Jenkins产品经理是如何设计产品的？

│ │ │ ├─结束语-持续改进，成就非凡！

│ │ ├─069-DDD实战课

│ │ │ ├─01-领域驱动设计：微服务设计为什么要选择DDD？

│ │ │ ├─02-领域、子域、核心域、通用域和支撑域：傻傻分不清？

│ │ │ ├─03-限界上下文：定义领域边界的利器

│ │ │ ├─04-实体和值对象：从领域模型的基础单元看系统设计

│ │ │ ├─05-聚合和聚合根：怎样设计聚合？

│ │ │ ├─06-领域事件：解耦微服务的关键

│ │ │ ├─069-DDD实战课

│ │ │ ├─07-DDD分层架构：有效降低层与层之间的依赖

│ │ │ ├─08-微服务架构模型：几种常见模型的对比和分析

│ │ │ ├─09-中台：数字转型后到底应该共享什么？

│ │ │ ├─10-DDD、中台和微服务：它们是如何协作的？

│ │ │ ├─11-DDD实践：如何用DDD重构中台业务模型？

│ │ │ ├─12-领域建模：如何用事件风暴构建领域模型？

│ │ │ ├─13-代码模型（上）：如何使用DDD设计微服务代码模型？

│ │ │ ├─14-代码模型（下）：如何保证领域模型与代码模型的一致性？

│ │ │ ├─15-边界：微服务的各种边界在架构演进中的作用？

│ │ │ ├─16-视图：如何实现服务和数据在微服务各层的协作？

│ │ │ ├─17-从后端到前端：微服务后，前端如何设计？

│ │ │ ├─18-知识点串讲：基于DDD的微服务设计实例

│ │ │ ├─19-总结（一）：微服务设计和拆分要坚持哪些原则？

│ │ │ ├─20-总结（二）：分布式架构关键设计10问

│ │ │ ├─基于DDD的微服务设计实例代码详解

│ │ │ ├─开篇词-学好了DDD，你能做什么？

│ │ │ ├─抽奖｜《DDD实战课》沉淀成书了，感谢有你！

│ │ │ ├─期末测试-有关DDD的内容，你掌握了多少呢？

│ │ │ ├─答疑：有关3个典型问题的讲解

│ │ │ ├─结束语-所谓高手，就是跨过坑和大海！

│ │ │ └─结束语-所谓高手，就是跨过坑和大海！

│ │ ├─070-苏杰的产品创新课

│ │ │ ├─01-为什么每个人都要学产品创新课？

│ │ │ ├─02-四轮MVP框架导读：产品从无到有的创新，有通杀的法门吗？

│ │ │ ├─03-从理解用户开始：故事、生态、画像、旅程

│ │ │ ├─04-竞品生态：真正有效的竞品分析怎么做？

│ │ │ ├─05-打造属于你的点子过滤器

│ │ │ ├─06-Y模型：从问题域到方案域的最硬核解题思路

│ │ │ ├─07-用“原型”低成本验证：差个程序员，也可以做产品

│ │ │ ├─070-苏杰的产品创新课

│ │ │ ├─08-设计冲刺：谷歌创投如何帮助产品成功？

│ │ │ ├─09-产品服务系统：避免狭隘，再聊什么是产品

│ │ │ ├─10-好产品的评价标准：单一产品的两个维度

│ │ │ ├─11-习惯、启程、发现、精通：一个好产品的起步逻辑

│ │ │ ├─12-和用户一起成长：生命周期，不同阶段怎么运营

│ │ │ ├─13-真正的成功指标：用户数、收入等等都不是

│ │ │ ├─14-赚到钱只是结果：做出来和推出去的效率

│ │ │ ├─15-需求采集：各种方法怎么灵活应用

│ │ │ ├─16-KANO模型：雪中送炭与锦上添花

│ │ │ ├─17-产品进化案例：千岛湖啤酒的脑洞

│ │ │ ├─18-我的实践：这门“产品创新课”本身

│ │ │ ├─19-从产品到产品矩阵：可复用、能积累、善生死

│ │ │ ├─20-组织团队的支撑：面向未来，如何提升你的竞争力

│ │ │ ├─21-长大以后：从4轮到6轮MVP（M2V6P）

│ │ │ ├─22-步步为营：项目、产品、平台、生态

│ │ │ ├─23-痛苦抉择：从满足用户到“伤害”用户

│ │ │ ├─24-众里寻他：怎么找到合适的产品达人？

│ │ │ ├─25-借力打力：和产品达人做朋友

│ │ │ ├─26-养家糊口：商业模式=价值+收入+过程

│ │ │ ├─27-群策群力：组织效率，管理？沟通？协作？

│ │ │ ├─28-长期主义：从产品到职场、人生

│ │ │ ├─加餐-知识地图：学习产品创新的意义是什么？

│ │ │ ├─开篇词-人人都是产品经理吗？

│ │ │ ├─结束语-死亡是宇宙最伟大的发明

│ │ │ └─结课测试-这些产品创新知识，你真的掌握了吗？

│ │ ├─071-雷蓓蓓的项目管理实战课

│ │ │ ├─01｜角色转变：新手项目管理的三大误区

│ │ │ ├─02｜十大领域五大过程组（上）：你必须了解的项目管理常识

│ │ │ ├─03｜十大领域五大过程组（下）：你必须了解的项目管理常识

│ │ │ ├─04-启动：盘活四类干系人，把拥护项目的人搞得多多的

│ │ │ ├─05-规划：扫除五大“延期地雷”，计划是用来对焦的

│ │ │ ├─06-执行：三种闭环验证方法，保证执行不走样

│ │ │ ├─07-监控：“巧”用数据说话，让汇报告别流水账

│ │ │ ├─071-雷蓓蓓的项目管理实战课

│ │ │ ├─08-收尾：持续改进，从真正有效的复盘开始

│ │ │ ├─09-需求变更：三个锦囊，让需求变更不再是洪水猛兽

│ │ │ ├─10-风险管理：冰山下的风险，如何系统化应对？

│ │ │ ├─11-质量管理：层层卡点，一次把事情做对

│ │ │ ├─12-高效会议：拒绝例行公事，开好最有必要的会

│ │ │ ├─13｜工具方法大串讲：手把手教你高效管理

│ │ │ ├─14｜“学习”到“实战”的距离，到底有多远？

│ │ │ ├─15｜学会对焦，从头到尾把事做成（上）

│ │ │ ├─16｜学会对焦，从头到尾把事做成（下）

│ │ │ ├─17｜新手上路，如何引入变化？

│ │ │ ├─18-小步快跑，小而美的敏捷

│ │ │ ├─19｜用户故事：我想从头到尾把事情做成

│ │ │ ├─20｜向上沟通：你必须要注意的三个误区

│ │ │ ├─21｜跨部门沟通：怎么让不归你管的人积极配合你？

│ │ │ ├─22｜向下沟通（上）：无权无势，他们不听你的怎么办？

│ │ │ ├─23-向下沟通（下）：无权无势，他们不听你的怎么办？

│ │ │ ├─24｜小心“猴子”：项目经理的头号时间杀手

│ │ │ ├─25-进阶之路：项目经理预备战之PMP认证攻略

│ │ │ ├─开篇词｜使众人行：如何带领一群人把事做成？

│ │ │ ├─结束语-如果我可以，你也一定行！

│ │ │ ├─结课测试｜这些项目管理知识你都掌握了吗？

│ │ │ ├─迭代说明｜如何学习项目管理这门课？

│ │ │ └─迭代说明｜如何学习项目管理这门课？

│ │ ├─072-设计模式之美

│ │ │ ├─01-为什么说每个程序员都要尽早地学习并掌握设计模式相关知识？

│ │ │ ├─02-从哪些维度评判代码质量的好坏？如何具备写出高质量代码的能力？

│ │ │ ├─03-面向对象、设计原则、设计模式、编程规范、重构，这五者有何关系？(1)

│ │ │ ├─03-面向对象、设计原则、设计模式、编程规范、重构，这五者有何关系？

│ │ │ ├─04-理论一：当谈论面向对象的时候，我们到底在谈论什么？(1)

│ │ │ ├─04-理论一：当谈论面向对象的时候，我们到底在谈论什么？

│ │ │ ├─05-理论二：封装、抽象、继承、多态分别可以解决哪些编程问题？

│ │ │ ├─06-理论三：面向对象相比面向过程有哪些优势？面向过程真的过时了吗？

│ │ │ ├─07-理论四：哪些代码设计看似是面向对象，实际是面向过程的？

│ │ │ ├─072-设计模式之美

│ │ │ ├─08-理论五：接口vs抽象类的区别？如何用普通的类模拟抽象类和接口？

│ │ │ ├─09-理论六：为什么基于接口而非实现编程？有必要为每个类都定义接口吗？

│ │ │ ├─10-理论七：为何说要多用组合少用继承？如何决定该用组合还是继承？

│ │ │ ├─100-如何将设计思想、原则、模式等理论知识应用到项目中？

│ │ │ ├─11-实战一（上）：业务开发常用的基于贫血模型的MVC架构违背OOP吗？

│ │ │ ├─12-实战一（下）：如何利用基于充血模型的DDD开发一个虚拟钱包系统？

│ │ │ ├─13-实战二（上）：如何对接口鉴权这样一个功能开发做面向对象分析？

│ │ │ ├─14-实战二（下）：如何利用面向对象设计和编程开发接口鉴权功能？

│ │ │ ├─15-理论一：对于单一职责原则，如何判定某个类的职责是否够“单一”？

│ │ │ ├─16-理论二：如何做到“对扩展开放、修改关闭”？扩展和修改各指什么？

│ │ │ ├─17-理论三：里式替换（LSP）跟多态有何区别？哪些代码违背了LSP？

│ │ │ ├─18-理论四：接口隔离原则有哪三种应用？原则中的“接口”该如何理解？

│ │ │ ├─19-理论五：控制反转、依赖反转、依赖注入，这三者有何区别和联系？

│ │ │ ├─20-理论六：我为何说KISS、YAGNI原则看似简单，却经常被用错？

│ │ │ ├─21-理论七：重复的代码就一定违背DRY吗？如何提高代码的复用性？

│ │ │ ├─22-理论八：如何用迪米特法则（LOD）实现“高内聚、松耦合”？

│ │ │ ├─23-实战一（上）：针对业务系统的开发，如何做需求分析和设计？

│ │ │ ├─24-实战一（下）：如何实现一个遵从设计原则的积分兑换系统？

│ │ │ ├─25-实战二（上）：针对非业务的通用框架开发，如何做需求分析和设计？

│ │ │ ├─26-实战二（下）：如何实现一个支持各种统计规则的性能计数器？

│ │ │ ├─27-理论一：什么情况下要重构？到底重构什么？又该如何重构？

│ │ │ ├─28-理论二：为了保证重构不出错，有哪些非常能落地的技术手段？

│ │ │ ├─29-理论三：什么是代码的可测试性？如何写出可测试性好的代码？

│ │ │ ├─30-理论四：如何通过封装、抽象、模块化、中间层等解耦代码？

│ │ │ ├─31-理论五：让你最快速地改善代码质量的20条编程规范（上）

│ │ │ ├─32-理论五：让你最快速地改善代码质量的20条编程规范（中）

│ │ │ ├─33-理论五：让你最快速地改善代码质量的20条编程规范（下）

│ │ │ ├─34-实战一（上）：通过一段ID生成器代码，学习如何发现代码质量问题

│ │ │ ├─35-实战一（下）：手把手带你将ID生成器代码从“能用”重构为“好用”

│ │ │ ├─36-实战二（上）：程序出错该返回啥？NULL、异常、错误码、空对象？

│ │ │ ├─37-实战二（下）：重构ID生成器项目中各函数的异常处理代码

│ │ │ ├─38-总结回顾面向对象、设计原则、编程规范、重构技巧等知识点

│ │ │ ├─39-运用学过的设计原则和思想完善之前讲的性能计数器项目（上）

│ │ │ ├─40-运用学过的设计原则和思想完善之前讲的性能计数器项目（下）

│ │ │ ├─41-单例模式（上）：为什么说支持懒加载的双重检测不比饿汉式更优？

│ │ │ ├─42-单例模式（中）：我为什么不推荐使用单例模式？又有何替代方案？

│ │ │ ├─43-单例模式（下）：如何设计实现一个集群环境下的分布式单例模式？

│ │ │ ├─44-工厂模式（上）：我为什么说没事不要随便用工厂模式创建对象？

│ │ │ ├─45-工厂模式（下）：如何设计实现一个DependencyInjection框架？

│ │ │ ├─46-建造者模式：详解构造函数、set方法、建造者模式三种对象创建方式

│ │ │ ├─47-原型模式：如何最快速地clone一个HashMap散列表？

│ │ │ ├─48-代理模式：代理在RPC、缓存、监控等场景中的应用

│ │ │ ├─49-桥接模式：如何实现支持不同类型和渠道的消息推送系统？

│ │ │ ├─50-装饰器模式：通过剖析JavaIO类库源码学习装饰器模式

│ │ │ ├─51-适配器模式：代理、适配器、桥接、装饰，这四个模式有何区别？

│ │ │ ├─52-门面模式：如何设计合理的接口粒度以兼顾接口的易用性和通用性？

│ │ │ ├─53-组合模式：如何设计实现支持递归遍历的文件系统目录树结构？

│ │ │ ├─54-享元模式（上）：如何利用享元模式优化文本编辑器的内存占用？

│ │ │ ├─55-享元模式（下）：剖析享元模式在JavaInteger、String中的应用

│ │ │ ├─56-观察者模式（上）：详解各种应用场景下观察者模式的不同实现方式

│ │ │ ├─57-观察者模式（下）：如何实现一个异步非阻塞的EventBus框架？

│ │ │ ├─58-模板模式（上）：剖析模板模式在JDK、Servlet、JUnit等中的应用

│ │ │ ├─59-模板模式（下）：模板模式与Callback回调函数有何区别和联系？

│ │ │ ├─60-策略模式（上）：如何避免冗长的if-else-switch分支判断代码？

│ │ │ ├─61-策略模式（下）：如何实现一个支持给不同大小文件排序的小程序？

│ │ │ ├─62-职责链模式（上）：如何实现可灵活扩展算法的敏感信息过滤框架？

│ │ │ ├─63-职责链模式（下）：框架中常用的过滤器、拦截器是如何实现的？

│ │ │ ├─64-状态模式：游戏、工作流引擎中常用的状态机是如何实现的？

│ │ │ ├─65-迭代器模式（上）：相比直接遍历集合数据，使用迭代器有哪些优势？

│ │ │ ├─66-迭代器模式（中）：遍历集合的同时，为什么不能增删集合元素？

│ │ │ ├─67-迭代器模式（下）：如何设计实现一个支持“快照”功能的iterator？

│ │ │ ├─68-访问者模式（上）：手把手带你还原访问者模式诞生的思维过程

│ │ │ ├─69-访问者模式（下）：为什么支持双分派的语言不需要访问者模式？

│ │ │ ├─70-备忘录模式：对于大对象的备份和恢复，如何优化内存和时间的消耗？

│ │ │ ├─71-命令模式：如何利用命令模式实现一个手游后端架构？

│ │ │ ├─72-解释器模式：如何设计实现一个自定义接口告警规则功能？

│ │ │ ├─73-中介模式：什么时候用中介模式？什么时候用观察者模式？

│ │ │ ├─74-总结回顾23种经典设计模式的原理、背后的思想、应用场景等

│ │ │ ├─75-在实际的项目开发中，如何避免过度设计？又如何避免设计不足？

│ │ │ ├─76-开源实战一（上）：通过剖析JavaJDK源码学习灵活应用设计模式

│ │ │ ├─77-开源实战一（下）：通过剖析JavaJDK源码学习灵活应用设计模式

│ │ │ ├─78-开源实战二（上）：从Unix开源开发学习应对大型复杂项目开发

│ │ │ ├─79-开源实战二（中）：从Unix开源开发学习应对大型复杂项目开发

│ │ │ ├─80-开源实战二（下）：从Unix开源开发学习应对大型复杂项目开发

│ │ │ ├─81-开源实战三（上）：借GoogleGuava学习发现和开发通用功能模块

│ │ │ ├─82-开源实战三（中）：剖析GoogleGuava中用到的几种设计模式

│ │ │ ├─83-开源实战三（下）：借GoogleGuava学习三大编程范式中的函数式编程

│ │ │ ├─84-开源实战四（上）：剖析Spring框架中蕴含的经典设计思想或原则

│ │ │ ├─85-开源实战四（中）：剖析Spring框架中用来支持扩展的两种设计模式

│ │ │ ├─86-开源实战四（下）：总结Spring框架用到的11种设计模式

│ │ │ ├─87-开源实战五（上）：MyBatis如何权衡易用性、性能和灵活性？

│ │ │ ├─88-开源实战五（中）：如何利用职责链与代理模式实现MyBatisPlugin？

│ │ │ ├─89-开源实战五（下）：总结MyBatis框架中用到的10种设计模式

│ │ │ ├─90-项目实战一：设计实现一个支持各种算法的限流框架（分析）

│ │ │ ├─91-项目实战一：设计实现一个支持各种算法的限流框架（设计）

│ │ │ ├─92-项目实战一：设计实现一个支持各种算法的限流框架（实现）

│ │ │ ├─93-项目实战二：设计实现一个通用的接口幂等框架（分析）

│ │ │ ├─94-项目实战二：设计实现一个通用的接口幂等框架（设计）

│ │ │ ├─95-项目实战二：设计实现一个通用的接口幂等框架（实现）

│ │ │ ├─96-项目实战三：设计实现一个支持自定义规则的灰度发布组件（分析）

│ │ │ ├─97-项目实战三：设计实现一个支持自定义规则的灰度发布组件（设计）

│ │ │ ├─98-项目实战三：设计实现一个支持自定义规则的灰度发布组件（实现）

│ │ │ ├─99-总结回顾：在实际软件开发中常用的设计思想、原则和模式

│ │ │ ├─加餐一-用一篇文章带你了解专栏中用到的所有Java语法

│ │ │ ├─加餐七-基础学科的知识如何转化成实际的技术生产力？

│ │ │ ├─加餐三-聊一聊Google是如何做CodeReview的

│ │ │ ├─加餐九-作为面试官或候选人，如何面试或回答设计模式问题？

│ │ │ ├─加餐二-设计模式、重构、编程规范等相关书籍推荐

│ │ │ ├─加餐五-听一听小争哥对Google工程师文化的解读

│ │ │ ├─加餐八-程序员怎么才能让自己走得更高、更远？

│ │ │ ├─加餐六-什么才是所谓的编程能力？如何考察一个人的编程能力？

│ │ │ ├─加餐十-如何接手一坨烂业务代码？如何在烂业务代码中成长？

│ │ │ ├─加餐四-聊一聊Google那些让我快速成长的地方

│ │ │ ├─开篇词-一对一的设计与编码集训，让你告别没有成长的烂代码！

│ │ │ ├─春节特别加餐-王争：如何学习《设计模式之美》专栏？

│ │ │ ├─结束语-聊一聊机遇、方向、能力、努力！

│ │ │ └─结束语-聊一聊机遇、方向、能力、努力！

│ │ ├─073-JavaScript核心原理解析

│ │ │ ├─01-delete0：JavaScript中到底有什么是可以销毁的

│ │ │ ├─02-varx=y=100：声明语句与语法改变了JavaScript语言核心性质

│ │ │ ├─03-a

│ │ │ ├─04-exportdefaultfunction(){}：你无法导出一个匿名函数表达式

│ │ │ ├─05-for(letxof[1,2,3])

│ │ │ ├─06-x-breakx;搞懂如何在循环外使用break，方知语句执行真解

│ │ │ ├─07-`${1}`：详解JavaScript中特殊的可执行结构

│ │ │ ├─073-JavaScript核心原理解析

│ │ │ ├─08-x=-x：函数式语言的核心抽象：函数与表达式的同一性

│ │ │ ├─09-(

│ │ │ ├─10-x=yieldx：迭代过程的“函数式化”

│ │ │ ├─11-throw1;：它在“最简单语法榜”上排名第三

│ │ │ ├─12-1in1

│ │ │ ├─13-newX：从构造器到类，为你揭密对象构造的全程

│ │ │ ├─14-super

│ │ │ ├─15-returnObject

│ │ │ ├─16-[a,b]={a,b}：让你从一行代码看到对象的本质

│ │ │ ├─17-Object

│ │ │ ├─18-a+b：动态类型是灾难之源还是最好的特性？（上）

│ │ │ ├─19-a+b：动态类型是灾难之源还是最好的特性？（下）

│ │ │ ├─20-(0,eval)(-x=100-)：一行让严格模式形同虚设的破坏性设计（上）

│ │ │ ├─21-(0,eval)(-x=100-)：一行让严格模式形同虚设的破坏性设计（下）

│ │ │ ├─22-newFunction(‘x=100’)();：函数的类化是对动态与静态系统的再次统一

│ │ │ ├─加餐-捡豆吃豆的学问（上）：这门课讲的是什么？

│ │ │ ├─加餐-捡豆吃豆的学问（下）：这门课该怎么学？

│ │ │ ├─加餐-让JavaScript运行起来

│ │ │ ├─开篇词-如何解决语言问题？

│ │ │ ├─结束语-愿你能做一个真正“懂”的程序员

│ │ │ └─结课测试-这些JavaScript知识，你真的掌握了吗？

│ │ ├─074-后端技术面试38讲

│ │ │ ├─01丨程序运行原理：程序是如何运行又是如何崩溃的？

│ │ │ ├─02丨数据结构原理：Hash表的时间复杂度为什么是O(1)？

│ │ │ ├─03丨Java虚拟机原理：JVM为什么被称为机器（machine）？

│ │ │ ├─04丨网络编程原理：一个字符的互联网之旅

│ │ │ ├─05丨文件系统原理：如何用1分钟遍历一个100TB的文件？

│ │ │ ├─06丨数据库原理：为什么PrepareStatement性能更好更安全？

│ │ │ ├─074-后端技术面试38讲

│ │ │ ├─07丨编程语言原理：面向对象编程是编程的终极形态吗？

│ │ │ ├─08丨软件设计的方法论：软件为什么要建模？

│ │ │ ├─09丨软件设计实践：如何使用UML完成一个设计文档？

│ │ │ ├─10-软件设计的目的：糟糕的程序员比优秀的程序员差在哪里？

│ │ │ ├─11丨软件设计的开闭原则：如何不修改代码却能实现需求变更？

│ │ │ ├─12-软件设计的依赖倒置原则：如何不依赖代码却可以复用它的功能？

│ │ │ ├─13丨软件设计的里氏替换原则：正方形可以继承长方形吗？

│ │ │ ├─14-软件设计的单一职责原则：为什么说一个类文件打开最好不要超过一屏？

│ │ │ ├─15丨软件设计的接口隔离原则：如何对类的调用者隐藏类的公有方法？

│ │ │ ├─16-设计模式基础：不会灵活应用设计模式，你就没有掌握面向对象编程

│ │ │ ├─17-设计模式应用：编程框架中的设计模式

│ │ │ ├─18-反应式编程框架设计：如何使程序调用不阻塞等待，立即响应？

│ │ │ ├─19-组件设计原则：组件的边界在哪里？

│ │ │ ├─20-领域驱动设计：35岁的程序员应该写什么样的代码？

│ │ │ ├─21丨分布式架构：如何应对高并发的用户请求

│ │ │ ├─22-缓存架构：如何减少不必要的计算？

│ │ │ ├─23-异步架构：如何避免互相依赖的系统间耦合？

│ │ │ ├─24-负载均衡架构：如何用10行代码实现一个负载均衡服务？

│ │ │ ├─25-数据存储架构：如何改善系统的数据存储能力？

│ │ │ ├─26-搜索引擎架构：如何瞬间完成海量数据检索？

│ │ │ ├─27-微服务架构：微服务究竟是灵丹还是毒药？

│ │ │ ├─28-高性能架构：除了代码，你还可以在哪些地方优化性能？

│ │ │ ├─29-高可用架构：我们为什么感觉不到淘宝应用升级时的停机？

│ │ │ ├─30-安全性架构：为什么说用户密码泄漏是程序员的锅？

│ │ │ ├─31-大数据架构：大数据技术架构的思想和原理是什么？

│ │ │ ├─32-AI与物联网架构：从智能引擎到物联网平台

│ │ │ ├─33-区块链技术架构：区块链到底能做什么？

│ │ │ ├─34-技术修炼之道：同样工作十几年，为什么有的人成为大厂架构师，有的人失业？

│ │ │ ├─35-技术进阶之道：你和这个星球最顶级的程序员差几个等级？

│ │ │ ├─36丨技术落地之道：你真的知道自己要解决的问题是什么吗？

│ │ │ ├─37丨技术沟通之道：如何解决问题？

│ │ │ ├─38丨技术管理之道：你真的要转管理吗？

│ │ │ ├─加餐-软件设计文档示例模板

│ │ │ ├─开篇词-掌握软件开发技术的第一性原理

│ │ │ ├─期末测试丨快来测测你对专栏内容掌握到何种程度了

│ │ │ ├─答疑丨JavaWeb程序的运行时环境到底是怎样的？

│ │ │ ├─答疑丨互联网需要解决的技术问题是什么？

│ │ │ ├─答疑丨对于设计模式而言，场景到底有多重要？

│ │ │ ├─答疑丨工作中的交往和沟通，都有哪些小技巧呢？

│ │ │ ├─结束语丨期待未来的你，成为优秀的软件架构师

│ │ │ └─结束语丨期待未来的你，成为优秀的软件架构师

│ │ ├─075-现代C++编程实战

│ │ │ ├─01-堆、栈、RAII：C++里该如何管理资源？

│ │ │ ├─02-自己动手，实现C++的智能指针

│ │ │ ├─03-右值和移动究竟解决了什么问题？

│ │ │ ├─04-容器汇编I：比较简单的若干容器

│ │ │ ├─05-容器汇编II：需要函数对象的容器

│ │ │ ├─06-异常：用还是不用，这是个问题

│ │ │ ├─07-迭代器和好用的新for循环

│ │ │ ├─075-现代C++编程实战

│ │ │ ├─08-易用性改进I：自动类型推断和初始化

│ │ │ ├─09-易用性改进II：字面量、静态断言和成员函数说明符

│ │ │ ├─10-到底应不应该返回对象？

│ │ │ ├─11-Unicode：进入多文字支持的世界

│ │ │ ├─12-编译期多态：泛型编程和模板入门

│ │ │ ├─13-编译期能做些什么？一个完整的计算世界

│ │ │ ├─14-SFINAE：不是错误的替换失败是怎么回事

│ │ │ ├─15-constexpr：一个常态的世界

│ │ │ ├─16-函数对象和lambda：进入函数式编程

│ │ │ ├─17-函数式编程：一种越来越流行的编程范式

│ │ │ ├─18-应用可变模板和tuple的编译期技巧

│ │ │ ├─19-thread和future：领略异步中的未来

│ │ │ ├─20-内存模型和atomic：理解并发的复杂性

│ │ │ ├─21-工具漫谈：编译、格式化、代码检查、排错各显身手

│ │ │ ├─22-处理数据类型变化和错误：optional、variant、expected和Herbception

│ │ │ ├─23-数字计算：介绍线性代数和数值计算库

│ │ │ ├─24-Boost：你需要的“瑞士军刀”

│ │ │ ├─25-两个单元测试库：C++里如何进行单元测试

│ │ │ ├─26-Easylogging++和spdlog：两个好用的日志库

│ │ │ ├─27-C++RESTSDK：使用现代C++开发网络应用

│ │ │ ├─28-Concepts：如何对模板进行约束

│ │ │ ├─29-Ranges：无迭代器的迭代和更方便的组合

│ │ │ ├─30-Coroutines：协作式的交叉调度执行

│ │ │ ├─31｜new和delete背后：分配函数和释放函数

│ │ │ ├─32｜容器里的内存管理：分配器

│ │ │ ├─33｜性能测试的正确姿势：性能、时间和优化

│ │ │ ├─34｜快速分配和释放内存：内存池

│ │ │ ├─35-发现和识别内存问题：内存调试实践

│ │ │ ├─36｜访问对象的代理对象：视图类型

│ │ │ ├─37｜参数传递的正确方法和模板的二进制膨胀

│ │ │ ├─38-折叠表达式：高效的编译期展开

│ │ │ ├─39-如何在编译期玩转字符串？

│ │ │ ├─40-如何在编译期遍历数据？

│ │ │ ├─41｜对象传参和返回的最佳实践

│ │ │ ├─加餐-部分课后思考题答案合集

│ │ │ ├─开篇词-C++这么难，为什么我们还要用C++？

│ │ │ ├─新春寄语-35年码龄程序员：人生漫长，走点弯路在所难免

│ │ │ ├─新春福利-C++好书荐读

│ │ │ ├─旅程再启｜那些关于C++的新认知

│ │ │ ├─期末测试-对于现代C++，你掌握了多少呢？

│ │ │ ├─第二季回归｜拿下Vim，让编程效率神器为我所用

│ │ │ ├─结束语-终点已达，行程还要继续

│ │ │ ├─课前必读-有关术语发音及环境要求

│ │ │ └─课前必读-有关术语发音及环境要求

│ │ ├─076-性能工程高手课

│ │ │ ├─01-程序员为什么要关心代码性能？

│ │ │ ├─02-程序员也要关心整个系统和公司成本吗？

│ │ │ ├─03-导读：专栏是怎么设计的？需要哪些知识？

│ │ │ ├─04-性能工程三定律：IT业和性能优化工作的“法律法规”

│ │ │ ├─05-概率统计和排队论：做性能工作必须懂的数理基础

│ │ │ ├─06-性能数据的分析：如何从大量数据中看出想要的信号？

│ │ │ ├─07-性能数据的展示：一图胜千言，说出你的数据故事

│ │ │ ├─076-性能工程高手课

│ │ │ ├─08-经验总结：必须熟记的一组常用性能数字

│ │ │ ├─09-性能测试的种类：如何快准狠地抓住一个测试的本质？

│ │ │ ├─10-性能测试的规划和步骤：为什么性能测试不容易一蹴而就呢？

│ │ │ ├─11-性能测试的工具：七大测试场景如何选择高质量的测试工具？

│ │ │ ├─12-九条性能测试的经验和教训：如何保证测试结果可靠且可重复？

│ │ │ ├─13-性能测试的工程集成：如何与产品开发和运维业务有机集成？

│ │ │ ├─14-性能分析概述：性能问题归根结底是什么原因？

│ │ │ ├─15-CPU篇：如何让CPU的运行不受阻碍？

│ │ │ ├─16-内存篇：如何减少延迟提升内存分配效率？

│ │ │ ├─17-存储篇：如何根据性能优缺点选择最合适的存储系统？

│ │ │ ├─18-网络篇：如何步步拆解处理复杂的网络性能问题？

│ │ │ ├─19-性能优化六大原则：三要三不要，快速有效地进行优化

│ │ │ ├─20-性能优化十大策略：如何系统地有层次地优化性能问题？

│ │ │ ├─21-CPU案例：如何提高LLC（最后一级缓存）的命中率？

│ │ │ ├─22-系统案例：如何提高iTLB（指令地址映射）的命中率？

│ │ │ ├─23-存储案例：如何降低SSD峰值延迟？

│ │ │ ├─24-跨层案例：如何优化程序、OS和存储系统的交互？

│ │ │ ├─25-如何在生产环境中进行真实的容量测试？

│ │ │ ├─26-怎么规划和控制数据库的复制延迟大小？

│ │ │ ├─27-多任务环境中的Java性能问题，怎样才能不让程序互相干扰？

│ │ │ ├─28-网络数据传输慢，问题到底出在哪了？

│ │ │ ├─29-如何彻底发挥SSD的潜力？

│ │ │ ├─30-服务器的管理和部署：工业界近几年有哪些发展趋势？

│ │ │ ├─31-规划部署数据中心要考虑哪些重要因素？

│ │ │ ├─32-服务的容量规划：怎样才能做到有备无患？

│ │ │ ├─33-服务效率提升：如何降低公司运营成本？

│ │ │ ├─34-服务需求控制管理：每种需求都是必需的吗？

│ │ │ ├─35-职业发展：从“锦上添花”到“不可或缺”

│ │ │ ├─36-如何成为优秀的性能和容量工程师？

│ │ │ ├─开篇词-代码不要眼前的苟且，而要效率的提升和性能的优化

│ │ │ ├─结束语-不愁明月尽，自有夜珠来

│ │ │ ├─结课测试-这些性能工程知识，你真的掌握了吗？

│ │ ├─077-安全攻防技能30讲

│ │ │ ├─01-安全的本质：数据被窃取后，你能意识到问题来源吗？

│ │ │ ├─02-安全原则：我们应该如何上手解决安全问题？

│ │ │ ├─03-密码学基础：如何让你的密码变得“不可见”？

│ │ │ ├─04-身份认证：除了账号密码，我们还能怎么做身份认证？

│ │ │ ├─05-访问控制：如何选取一个合适的数据保护方案？

│ │ │ ├─06-XSS：当你“被发送”了一条微博时，到底发生了什么？

│ │ │ ├─07-SQL注入：明明设置了强密码，为什么还会被别人登录？

│ │ │ ├─077-安全攻防技能30讲

│ │ │ ├─08-CSRF-SSRF：为什么避免了XSS，还是“被发送”了一条微博？

│ │ │ ├─09-反序列化漏洞：使用了编译型语言，为什么还是会被注入？

│ │ │ ├─10-信息泄露：为什么黑客会知道你的代码逻辑？

│ │ │ ├─11-插件漏洞：我的代码看起来很安全，为什么还会出现漏洞？

│ │ │ ├─12-权限提升和持久化：为什么漏洞修复了，黑客还是能够自由进出？

│ │ │ ├─13-Linux系统安全：多人共用服务器，如何防止别人干“坏事”？

│ │ │ ├─14-网络安全：和别人共用Wi-Fi时，你的信息会被窃取吗？

│ │ │ ├─15-Docker安全：在虚拟的环境中，就不用考虑安全了吗？

│ │ │ ├─16-数据库安全：数据库中的数据是如何被黑客拖取的？

│ │ │ ├─17-分布式安全：上百个分布式节点，不会出现“内奸”吗？

│ │ │ ├─18-安全标准和框架：怎样依“葫芦”画出好“瓢”？

│ │ │ ├─19-防火墙：如何和黑客“划清界限”？

│ │ │ ├─20-WAF：如何为漏洞百出的Web应用保驾护航？

│ │ │ ├─21-IDS：当黑客绕过了防火墙，你该如何发现？

│ │ │ ├─22-RASP：写规则写得烦了？尝试一下更底层的IDS

│ │ │ ├─23-SIEM：一个人管理好几个安全工具，如何高效运营？

│ │ │ ├─24-SDL：怎样才能写出更“安全”的代码？

│ │ │ ├─25-业务安全体系：对比基础安全，业务安全有哪些不同？

│ │ │ ├─26-产品安全方案：如何降低业务对黑灰产的诱惑？

│ │ │ ├─27-风控系统：如何从海量业务数据中，挖掘黑灰产？

│ │ │ ├─28-机器学习：如何教会机器识别黑灰产？

│ │ │ ├─29-设备指纹：面对各种虚拟设备，如何进行对抗？

│ │ │ ├─30-安全运营：“黑灰产”打了又来，如何正确处置？

│ │ │ ├─加餐1-数据安全：如何防止内部员工泄露商业机密？

│ │ │ ├─加餐2-前端安全：如何打造一个可信的前端环境？

│ │ │ ├─加餐3-职业发展：应聘安全工程师，我需要注意什么？

│ │ │ ├─加餐4-个人成长：学习安全，哪些资源我必须要知道？

│ │ │ ├─加餐5-安全新技术：IoT、IPv6、区块链中的安全新问题

│ │ │ ├─开篇词-别说你没被安全困扰过

│ │ │ ├─模块串讲（一）-Web安全：如何评估用户数据和资产数据面临的威胁？

│ │ │ ├─模块串讲（三）-安全防御工具：如何选择和规划公司的安全防御体系？

│ │ │ ├─模块串讲（二）-Linux系统和应用安全：如何大范围提高平台安全性？

│ │ │ ├─结束语-在与黑客的战役中，我们都是盟友！

│ │ │ └─结课测试｜这些安全知识，你都掌握了吗？

│ │ ├─078-性能测试实战30讲

│ │ │ ├─01丨性能综述：性能测试的概念到底是什么？

│ │ │ ├─02丨性能综述：TPS和响应时间之间是什么关系？

│ │ │ ├─03丨性能综述：怎么理解TPS、QPS、RT、吞吐量这些性能指标？

│ │ │ ├─04丨JMeter和LoadRunner：要知道工具仅仅只是工具

│ │ │ ├─05丨指标关系：你知道并发用户数应该怎么算吗？

│ │ │ ├─06丨倾囊相授：我毕生所学的性能分析思路都在这里了

│ │ │ ├─078-性能测试实战30讲

│ │ │ ├─07丨性能测试工具：如何录制脚本？

│ │ │ ├─08丨案例：手把手教你编写最简单的性能脚本

│ │ │ ├─09丨-关联和断言：一动一静，核心都是在取数据

│ │ │ ├─10丨案例：在JMeter中如何设置参数化数据？

│ │ │ ├─11丨性能脚本：用案例和图示帮你理解HTTP协议

│ │ │ ├─12丨性能场景：做参数化之前，我们需要考虑什么？

│ │ │ ├─13丨性能测试场景：如何进行场景设计？

│ │ │ ├─14丨性能测试场景：如何理解业务模型？

│ │ │ ├─15丨性能测试场景：如何进行监控设计？

│ │ │ ├─16丨案例：性能监控工具之Grafana+Prometheus+Exporters

│ │ │ ├─17丨CentOS：操作系统级监控及常用计数器解析（上）

│ │ │ ├─18丨CentOS：操作系统级监控及常用计数器解析（下）

│ │ │ ├─19丨Java&C++：代码级监控及常用计数器解析（上）

│ │ │ ├─20丨Java&C++：代码级监控及常用计数器解析（下）

│ │ │ ├─21丨Tomcat：中间件监控及常用计数器解析

│ │ │ ├─22丨MySQL：数据库级监控及常用计数器解析（上）

│ │ │ ├─23丨MySQL：数据库级监控及常用计数器解析（下）

│ │ │ ├─24丨Kafka：性能监控工具之队列级监控及常用计数器解析

│ │ │ ├─25丨SkyWalking：性能监控工具之链路级监控及常用计数器解析

│ │ │ ├─26丨案例：手把手带你理解TPS趋势分析

│ │ │ ├─27丨案例：带宽消耗以及Swap（上）

│ │ │ ├─28丨案例：带宽消耗以及Swap（下）

│ │ │ ├─29丨案例：如何应对因网络参数导致的TPS-呈锯齿状？

│ │ │ ├─30丨案例：为什么参数化数据会导致TPS突然下降？

│ │ │ ├─31丨案例：当磁盘参数导致I-O高的时候，应该怎么办？

│ │ │ ├─32丨当Postgres磁盘读引起I-O高的时候，应该怎么办？

│ │ │ ├─开篇词丨“老板，之前咱TPS是100，我优化完是10000”

│ │ │ ├─春节策划丨快来挑战一下自己的分析逻辑吧！

│ │ │ ├─春节策划丨性能评估和性能分析试题，等你挑战！

│ │ │ ├─期末测试题丨快来测试一下你对性能掌握到何种程度了吧！

│ │ │ ├─结束语丨见过林林总总的乱象，才知未来的无限可能

│ │ │ └─结束语丨见过林林总总的乱象，才知未来的无限可能

│ │ ├─079-摄影入门课

│ │ │ ├─00丨开篇词 (1讲)

│ │ │ │ ├─00丨开篇词丨拍了十三年照片，我还是个小白

│ │ │ │ └─00丨开篇词丨拍了十三年照片，我还是个小白

│ │ │ ├─01丨摄影史 (2讲)

│ │ │ │ ├─01丨影像时代的视觉语言（上）：是什么推动了摄影的发展？

│ │ │ │ ├─02丨影像时代的视觉语言（下）：有图就有真相？

│ │ │ │ └─02丨影像时代的视觉语言（下）：有图就有真相？

│ │ │ ├─02丨理论篇 (8讲)

│ │ │ │ ├─03丨光圈与景深：拍照片可以不对焦？

│ │ │ │ ├─04丨镜头焦段与实际运用：你拍到的是你看到的么？

│ │ │ │ ├─05丨快门：你看到就能拍到么？

│ │ │ │ ├─06丨感光度(ISO)与其他相机参数：除了光圈和快门，你还应该知道些什么？

│ │ │ │ ├─07丨测光：什么才是正确曝光？(1)

│ │ │ │ ├─07丨测光：什么才是正确曝光？

│ │ │ │ ├─08丨拍摄设备选择（上）：都有什么相机？(1)

│ │ │ │ ├─08丨拍摄设备选择（上）：都有什么相机？

│ │ │ │ ├─09丨拍摄设备选择（下）：什么相机才是最好的相机？

│ │ │ │ ├─10丨好照片的构成因素：什么照片才是好照片？(1)

│ │ │ │ ├─10丨好照片的构成因素：什么照片才是好照片？

│ │ │ │ └─10丨好照片的构成因素：什么照片才是好照片？

│ │ │ ├─03丨实战篇 (10讲)

│ │ │ │ ├─11丨光（上）：摄影的“影”长什么样？

│ │ │ │ ├─12丨光（中）：你真的会在阳光下拍照片么？

│ │ │ │ ├─13丨光（下）：闪光灯是因为环境太暗所以照亮儿用的么？

│ │ │ │ ├─14丨静物：静物是静物么？

│ │ │ │ ├─15丨人物：会聊天比会拍照片更重要

│ │ │ │ ├─16丨风光：你不想让别人看见什么？

│ │ │ │ ├─17丨街拍：艺术这场“大骗局”

│ │ │ │ ├─18丨基础手机后期（上）：VSCO 完整指南（@随你们去）

│ │ │ │ ├─19丨基础手机后期（下）：Snapseed使用攻略（@随你们去）

│ │ │ │ ├─20丨摄影的更多可能：摄影到底是不是艺术？

│ │ │ │ └─20丨摄影的更多可能：摄影到底是不是艺术？

│ │ │ └─04丨结束语 (1讲)

│ │ │ ├─在此谢罪，结束语被迫延期了

│ │ │ └─在此谢罪，结束语被迫延期了

│ │ ├─080-人人都能学会的编程入门课

│ │ │ ├─01-学习编程，我到底该选择哪门语言？

│ │ │ ├─02-第一个程序：教你输出彩色的文字

│ │ │ ├─03-判断与循环：给你的程序加上处理逻辑

│ │ │ ├─04-随机函数：随机实验真的可以算π值嘛？

│ │ │ ├─05-数组：一秒钟，定义1000个变量

│ │ │ ├─06-字符串：彻底被你忽略的printf的高级用法

│ │ │ ├─07-指针系列（一）：记住，指针变量也是变量

│ │ │ ├─08-指针系列（二）：记住，指针变量也是变量

│ │ │ ├─080-人人都能学会的编程入门课

│ │ │ ├─09-函数：自己动手实现低配版scanf函数

│ │ │ ├─10-预处理命令（上）：必须掌握的“黑魔法”，让编译器帮你写代码

│ │ │ ├─11-预处理命令（下）：必须掌握的“黑魔法”，让编译器帮你写代码

│ │ │ ├─12-数学归纳法：搞定循环与递归的钥匙

│ │ │ ├─13-程序设计原则：把计算过程交给计算机

│ │ │ ├─14-框架思维（上）：将素数筛算法写成框架算法

│ │ │ ├─15-框架思维（下）：用筛法求解其他积性函数

│ │ │ ├─16-数据结构（上）：突破基本类型的限制，存储更大的整数

│ │ │ ├─17-数据结构（下）：大整数实战，提升Shift-And算法能力

│ │ │ ├─18-重新认识数据结构（上）：初识链表结构

│ │ │ ├─19-重新认识数据结构（下）：有趣的“链表思维”

│ │ │ ├─20-二分查找：提升程序的查找效率

│ │ │ ├─21-队列与单调队列：滑动区间最大值

│ │ │ ├─22-栈与单调栈：最大矩形面积

│ │ │ ├─23-深入理解：容斥原理与递推算法

│ │ │ ├─24-动态规划（上）：只需四步，搞定动态规划算法设计

│ │ │ ├─25-动态规划（下）：背包问题与动态规划算法优化

│ │ │ ├─26-牛刀小试（上）：实现测试框架前的基础准备

│ │ │ ├─27-牛刀小试（下）：实现一个自己的测试框架

│ │ │ ├─28-尝试升级（上）：完善测试框架的功能与提示

│ │ │ ├─29-尝试升级（下）：“链表”知识在测试框架中的应用

│ │ │ ├─30-毕业设计：实现你自己的计算器程序

│ │ │ ├─做好闭环（一）：不看答案可能就白学了

│ │ │ ├─做好闭环（三）：编码能力训练篇的思考题答案都在这里啦！

│ │ │ ├─做好闭环（二）：函数是压缩的数组，数组是展开的函数

│ │ │ ├─做好闭环（四）：二分答案算法的代码统一结构

│ │ │ ├─开篇词-别闹了，学编程≠学语言

│ │ │ ├─期中测试-给语言基础篇交一份满分答卷，去迎接新的挑战！

│ │ │ ├─结束语-设立目标，有的放矢

│ │ │ └─结课测试-这些编程知识，你都掌握了吗？

│ │ ├─081-说透敏捷

│ │ │ ├─01-灵魂拷问：如何利用敏捷思维更好地解决实际问题？

│ │ │ ├─02-老生常谈：你真的知道敏捷到底是什么吗？

│ │ │ ├─03-评估诊断：成功迈出敏捷推进的第一步

│ │ │ ├─04-团队试点（一）：让你的敏捷实践“事半功倍”

│ │ │ ├─05-团队试点（二）：打造一支无往不胜的敏捷团队

│ │ │ ├─06-规模化推广：复制粘贴试点的经验就够了吗？

│ │ │ ├─07-填坑指南：填好这4个坑，快速做对敏捷

│ │ │ ├─08-避雷策略：如何防止你的敏捷变为“小瀑布”？

│ │ │ ├─081-说透敏捷

│ │ │ ├─09-内部教练：守护敏捷实践，求人不如求己

│ │ │ ├─10-服务型领导：在敏捷中你该怎样提升自己的领导力？

│ │ │ ├─开篇词-重识敏捷，让你的研发管理少走一些弯路

│ │ │ ├─结束语-用敏捷提升自己，从敏捷走向未来

│ │ │ └─结课测试-敏捷的这些知识，你掌握到什么程度了呢？

│ │ ├─082-接口测试入门课

│ │ │ ├─01-基础：跳出细节看全局，接口测试到底是在做什么？

│ │ │ ├─02-方法论：没有任何文档，怎么才能快速了解接口的信息？

│ │ │ ├─03-思维方式：用一个案例彻底理解接口测试的关键逻辑

│ │ │ ├─04-案例：如何把流程化的测试脚本抽象为测试框架？

│ │ │ ├─05-案例：测试框架如何才能支持RESTful风格的接口？

│ │ │ ├─06-接口测试平台：工具和框架不可以兼容？

│ │ │ ├─07-WebSocket接口：如何测试一个完全陌生的协议接口？

│ │ │ ├─08-测试数据：是不是可以把所有的参数都保存到Excel中？

│ │ │ ├─082-接口测试入门课

│ │ │ ├─09-微服务接口：怎么用Mock解决混乱的调用关系？

│ │ │ ├─开篇词-把接口测试这件小事做深、做透

│ │ │ ├─结束语｜如何成为一名优秀的测试工程师？

│ │ │ └─结课测试｜这些接口测试知识你都掌握了吗？

│ │ ├─083-分布式协议与算法实战

│ │ │ ├─01-拜占庭将军问题：有叛徒的情况下，如何才能达成共识？

│ │ │ ├─02-CAP理论：分布式系统的PH试纸，用它来测酸碱度

│ │ │ ├─03-ACID理论：CAP的酸，追求一致性

│ │ │ ├─04-BASE理论：CAP的碱，追求可用性

│ │ │ ├─05-Paxos算法（一）：如何在多个节点间确定某变量的值？

│ │ │ ├─06-Paxos算法（二）：Multi-Paxos不是一个算法，而是统称

│ │ │ ├─07-Raft算法（一）：如何选举领导者？

│ │ │ ├─08-Raft算法（二）：如何复制日志？

│ │ │ ├─083-分布式协议与算法实战

│ │ │ ├─09-Raft算法（三）：如何解决成员变更的问题？

│ │ │ ├─10-一致哈希算法：如何分群，突破集群的“领导者”限制？

│ │ │ ├─11-Gossip协议：流言蜚语，原来也可以实现一致性

│ │ │ ├─12-QuorumNWR算法：想要灵活地自定义一致性，没问题！

│ │ │ ├─13-PBFT算法：有人作恶，如何达成共识？

│ │ │ ├─14-PoW算法：有办法黑比特币吗？

│ │ │ ├─15-ZAB协议：如何实现操作的顺序性？

│ │ │ ├─16-InfluxDB企业版一致性实现剖析：他山之石，可以攻玉

│ │ │ ├─17-HashicorpRaft（一）：如何跨过理论和代码之间的鸿沟？

│ │ │ ├─18-HashicorpRaft（二）：如何以“集群节点”为中心使用API？

│ │ │ ├─19-基于Raft的分布式KV系统开发实战（一）：如何设计架构？

│ │ │ ├─20-基于Raft的分布式KV系统开发实战（二）：如何实现代码？

│ │ │ ├─加餐-MySQLXA是如何实现分布式事务的？

│ │ │ ├─加餐-PBFT算法：如何替换作恶的领导者？

│ │ │ ├─加餐-TCC如何实现指令执行的原子性？

│ │ │ ├─加餐-ZAB协议（一）：主节点崩溃了，怎么办？

│ │ │ ├─加餐-ZAB协议（三）：如何处理读写请求？

│ │ │ ├─加餐-ZAB协议（二）：如何从故障中恢复？

│ │ │ ├─加餐-拜占庭将军问题：如何基于签名消息实现作战计划的一致性？

│ │ │ ├─学习路径-分布式协议与算法你应该这么学

│ │ │ ├─开篇词-想成为分布式高手？那就先把协议和算法烂熟于心吧

│ │ │ ├─结束语-静下心来，享受技术的乐趣

│ │ │ └─结课测试-这些分布式协议与算法的知识，你都掌握了吗？

│ │ ├─084-RPC实战与核心原理

│ │ │ ├─01-核心原理：能否画张图解释下RPC的通信流程？

│ │ │ ├─02-协议：怎么设计可扩展且向后兼容的协议？

│ │ │ ├─03-序列化：对象怎么在网络中传输？

│ │ │ ├─04-网络通信：RPC框架在网络通信上更倾向于哪种网络IO模型？

│ │ │ ├─05-动态代理：面向接口编程，屏蔽RPC处理流程

│ │ │ ├─06-RPC实战：剖析gRPC源码，动手实现一个完整的RPC

│ │ │ ├─07-架构设计：设计一个灵活的RPC框架

│ │ │ ├─08-服务发现：到底是要CP还是AP？

│ │ │ ├─084-RPC实战与核心原理

│ │ │ ├─09-健康检测：这个节点都挂了，为啥还要疯狂发请求？

│ │ │ ├─10-路由策略：怎么让请求按照设定的规则发到不同的节点上？

│ │ │ ├─11-负载均衡：节点负载差距这么大，为什么收到的流量还一样？

│ │ │ ├─12-异常重试：在约定时间内安全可靠地重试

│ │ │ ├─13-优雅关闭：如何避免服务停机带来的业务损失？

│ │ │ ├─14-优雅启动：如何避免流量打到没有启动完成的节点？

│ │ │ ├─15-熔断限流：业务如何实现自我保护

│ │ │ ├─16-业务分组：如何隔离流量？

│ │ │ ├─17-异步RPC：压榨单机吞吐量

│ │ │ ├─18-安全体系：如何建立可靠的安全体系？

│ │ │ ├─19-分布式环境下如何快速定位问题？

│ │ │ ├─20-详解时钟轮在RPC中的应用

│ │ │ ├─21-流量回放：保障业务技术升级的神器

│ │ │ ├─22-动态分组：超高效实现秒级扩缩容

│ │ │ ├─23-如何在没有接口的情况下进行RPC调用？

│ │ │ ├─24-如何在线上环境里兼容多种RPC协议？

│ │ │ ├─加餐-RPC框架代码实例详解

│ │ │ ├─加餐-谈谈我所经历过的RPC

│ │ │ ├─开篇词-别老想着怎么用好RPC框架，你得多花时间琢磨原理

│ │ │ ├─答疑课堂-基础篇与进阶篇思考题答案合集

│ │ │ ├─结束语-学会从优秀项目的源代码中挖掘知识

│ │ │ └─结束语-学会从优秀项目的源代码中挖掘知识

│ │ ├─085-架构实战案例解析

│ │ │ ├─01-架构的本质：如何打造一个有序的系统？

│ │ │ ├─02-业务架构：作为开发，你真的了解业务吗？

│ │ │ ├─03-可扩展架构：如何打造一个善变的柔性系统？

│ │ │ ├─04-可扩展架构案例（一）：电商平台架构是如何演变的？

│ │ │ ├─05-可扩展架构案例（二）：App服务端架构是如何升级的？

│ │ │ ├─06-可扩展架构案例（三）：你真的需要一个中台吗？

│ │ │ ├─07-可复用架构：如何实现高层次的复用？

│ │ │ ├─08-可复用架构案例（一）：如何设计一个基础服务？

│ │ │ ├─085-架构实战案例解析

│ │ │ ├─09-可复用架构案例（二）：如何对现有系统做微服务改造？

│ │ │ ├─10-可复用架构案例（三）：中台是如何炼成的？

│ │ │ ├─11-技术架构：作为开发，你真的了解系统吗？

│ │ │ ├─12-高可用架构：如何让你的系统不掉链子？

│ │ │ ├─13-高可用架构案例（一）：如何实现O2O平台日订单500万？

│ │ │ ├─14-高可用架构案例（二）：如何第一时间知道系统哪里有问题？

│ │ │ ├─15-高可用架构案例（三）：如何打造一体化的监控系统？

│ │ │ ├─16-高性能和可伸缩架构：业务增长，能不能加台机器就搞定？

│ │ │ ├─17-高性能架构案例：如何设计一个秒杀系统？

│ │ │ ├─18-可伸缩架构案例：数据太多，如何无限扩展你的数据库？

│ │ │ ├─19-综合案例：电商平台技术架构是如何演变的？

│ │ │ ├─20-从务实的角度，给你架构设计的重点知识和学习路径

│ │ │ ├─开篇词-想吃透架构？你得看看真实、接地气的架构案例

│ │ │ ├─结束语-和你聊聊我的架构心路历程

│ │ │ ├─结课测试-“架构实战案例解析”100分试卷等你来挑战！

│ │ │ └─结课测试-“架构实战案例解析”100分试卷等你来挑战！

│ │ ├─086-后端存储实战课

│ │ │ ├─01-创建和更新订单时，如何保证数据准确无误？

│ │ │ ├─02-流量大、数据多的商品详情页系统该如何设计？

│ │ │ ├─03-复杂而又重要的购物车系统，应该如何设计？

│ │ │ ├─04-事务：账户余额总是对不上账，怎么办？

│ │ │ ├─05-分布式事务：如何保证多个系统间的数据是一致的？

│ │ │ ├─06-如何用Elasticsearch构建商品搜索系统？

│ │ │ ├─07｜MySQLHA：如何将“删库跑路”的损失降到最低？

│ │ │ ├─08-一个几乎每个系统必踩的坑儿：访问数据库超时

│ │ │ ├─086-后端存储实战课

│ │ │ ├─09-怎么能避免写出慢SQL？

│ │ │ ├─10-走进黑盒：SQL是如何在数据库中执行的？

│ │ │ ├─11-MySQL如何应对高并发（一）：使用缓存保护MySQL

│ │ │ ├─12-MySQL如何应对高并发（二）：读写分离

│ │ │ ├─13-MySQL主从数据库同步是如何实现的？

│ │ │ ├─14-订单数据越来越多，数据库越来越慢该怎么办？

│ │ │ ├─15-MySQL存储海量数据的最后一招：分库分表

│ │ │ ├─16-用Redis构建缓存集群的最佳实践有哪些？

│ │ │ ├─17-大厂都是怎么做MySQLtoRedis同步的

│ │ │ ├─18-分布式存储：你知道对象存储是如何保存图片文件的吗？

│ │ │ ├─19-跨系统实时同步数据，分布式事务是唯一的解决方案吗？

│ │ │ ├─20-如何在不停机的情况下，安全地更换数据库？

│ │ │ ├─21-类似“点击流”这样的海量数据应该如何存储？

│ │ │ ├─22-面对海量数据，如何才能查得更快

│ │ │ ├─23-MySQL经常遇到的高可用、分片问题，NewSQL是如何解决的？

│ │ │ ├─24-RocksDB：不丢数据的高性能KV存储

│ │ │ ├─开篇词-从今天起，换种方式学存储

│ │ │ ├─特别放送-和你分享一个好消息：这门课被出版了一本书

│ │ │ ├─特别放送-如何平衡存储系统的一致性和可用性？

│ │ │ ├─结束语-把奋斗当习惯

│ │ │ ├─结课测试-后端存储，100分试卷等你来挑战

│ │ │ ├─课前加餐-电商系统是如何设计的？

│ │ │ └─课前加餐-电商系统是如何设计的？

│ │ ├─087-深入浅出云计算

│ │ │ ├─01-区域和可用区：欢迎来到云端数据中心

│ │ │ ├─02-云虚拟机（一）：云端“攒机”，有哪些容易忽视的要点？

│ │ │ ├─03-云虚拟机（二）：眼花缭乱的虚拟机型号，我该如何选择？

│ │ │ ├─04-云虚拟机（三）：老板要求省省省，有哪些妙招？

│ │ │ ├─05-云硬盘：云上IO到底给不给力？

│ │ │ ├─06-云上虚拟网络：开合有度，编织无形之网

│ │ │ ├─07-云端架构最佳实践：与故障同舞，与伸缩共生

│ │ │ ├─08-云上运维：云端究竟需不需要运维？需要怎样的运维？

│ │ │ ├─087-深入浅出云计算

│ │ │ ├─09-什么是PaaS？怎样深入理解和评估PaaS？

│ │ │ ├─10-对象存储：看似简单的存储服务都有哪些玄机？

│ │ │ ├─11-应用托管服务：Web应用怎样在云上安家？

│ │ │ ├─12-云数据库：高歌猛进的数据库“新贵”

│ │ │ ├─13-云上大数据：云计算遇上大数据，为什么堪称天作之合？

│ │ │ ├─14-云上容器服务：从Docker到Kubernetes，迎接云原生浪潮

│ │ │ ├─15-无服务器计算：追求极致效率的多面手

│ │ │ ├─16-云上AI服务：云AI能从哪些方面帮助构建智能应用？

│ │ │ ├─开篇词-云计算，这是开发者最好的时代

│ │ │ ├─结束语-与云计算一起，迈向未来

│ │ │ ├─结课测试｜这些云计算知识，你都掌握了吗？

│ │ │ └─结课测试｜这些云计算知识，你都掌握了吗？

│ │ ├─088-Java业务开发常见错误100例

│ │ │ ├─01-使用了并发工具类库，线程安全就高枕无忧了吗？

│ │ │ ├─02-代码加锁：不要让“锁”事成为烦心事

│ │ │ ├─03-线程池：业务代码最常用也最容易犯错的组件

│ │ │ ├─04-连接池：别让连接池帮了倒忙

│ │ │ ├─05-HTTP调用：你考虑到超时、重试、并发了吗？

│ │ │ ├─06-20%的业务代码的Spring声明式事务，可能都没处理正确

│ │ │ ├─07-数据库索引：索引并不是万能药

│ │ │ ├─08-判等问题：程序里如何确定你就是你？

│ │ │ ├─088-Java业务开发常见错误100例

│ │ │ ├─09-数值计算：注意精度、舍入和溢出问题

│ │ │ ├─10-集合类：坑满地的List列表操作

│ │ │ ├─11-空值处理：分不清楚的null和恼人的空指针

│ │ │ ├─12-异常处理：别让自己在出问题的时候变为瞎子

│ │ │ ├─13-日志：日志记录真没你想象的那么简单

│ │ │ ├─14-文件IO：实现高效正确的文件读写并非易事

│ │ │ ├─15-序列化：一来一回你还是原来的你吗？

│ │ │ ├─16-用好Java8的日期时间类，少踩一些“老三样”的坑

│ │ │ ├─17-别以为“自动挡”就不可能出现OOM

│ │ │ ├─18-当反射、注解和泛型遇到OOP时，会有哪些坑？

│ │ │ ├─19-Spring框架：IoC和AOP是扩展的核心

│ │ │ ├─20-Spring框架：框架帮我们做了很多工作也带来了复杂度

│ │ │ ├─21-代码重复：搞定代码重复的三个绝招

│ │ │ ├─22-接口设计：系统间对话的语言，一定要统一

│ │ │ ├─23-缓存设计：缓存可以锦上添花也可以落井下石

│ │ │ ├─24-业务代码写完，就意味着生产就绪了？

│ │ │ ├─25-异步处理好用，但非常容易用错

│ │ │ ├─26-数据存储：NoSQL与RDBMS如何取长补短、相辅相成？

│ │ │ ├─27-数据源头：任何客户端的东西都不可信任

│ │ │ ├─28-安全兜底：涉及钱时，必须考虑防刷、限量和防重

│ │ │ ├─29-数据和代码：数据就是数据，代码就是代码

│ │ │ ├─30-如何正确保存和传输敏感数据？

│ │ │ ├─31-加餐1：带你吃透课程中Java8的那些重要知识点（一）

│ │ │ ├─32-加餐2：带你吃透课程中Java8的那些重要知识点（二）

│ │ │ ├─33-加餐3：定位应用问题，排错套路很重要

│ │ │ ├─34-加餐4：分析定位Java问题，一定要用好这些工具（一）

│ │ │ ├─35-加餐5：分析定位Java问题，一定要用好这些工具（二）

│ │ │ ├─36-加餐6：这15年来，我是如何在工作中学习技术和英语的？

│ │ │ ├─37-加餐7：程序员成长28计

│ │ │ ├─38-加餐8：Java程序从虚拟机迁移到Kubernetes的一些坑

│ │ │ ├─开篇词-业务代码真的会有这么多坑？

│ │ │ ├─答疑篇：代码篇思考题集锦（一）

│ │ │ ├─答疑篇：代码篇思考题集锦（三）

│ │ │ ├─答疑篇：代码篇思考题集锦（二）

│ │ │ ├─答疑篇：加餐篇思考题答案合集

│ │ │ ├─答疑篇：安全篇思考题答案合集

│ │ │ ├─答疑篇：设计篇思考题答案合集

│ │ │ ├─结束语-写代码时，如何才能尽量避免踩坑？

│ │ │ ├─结课测试-关于Java业务开发的100个常见错误，你都明白其中缘由了吗？

│ │ ├─089-图解GoogleV8

│ │ │ ├─01-V8是如何执行一段JavaScript代码的？

│ │ │ ├─02-函数即对象：一篇文章彻底搞懂JavaScript的函数特点

│ │ │ ├─03-快属性和慢属性：V8是怎样提升对象属性访问速度的？

│ │ │ ├─04-函数表达式：涉及大量概念，函数表达式到底该怎么学？

│ │ │ ├─05｜原型链：V8是如何实现对象继承的？

│ │ │ ├─06｜作用域链：V8是如何查找变量的？

│ │ │ ├─07｜类型转换：V8是怎么实现1+“2”的？

│ │ │ ├─089-图解GoogleV8

│ │ │ ├─08｜答疑：如何构建和使用V8的调试工具d8？

│ │ │ ├─09-运行时环境：运行JavaScript代码的基石

│ │ │ ├─10-机器代码：二进制机器码究竟是如何被CPU执行的？

│ │ │ ├─11-堆和栈：函数调用是如何影响到内存布局的？

│ │ │ ├─12-延迟解析：V8是如何实现闭包的？

│ │ │ ├─13-字节码（一）：V8为什么又重新引入字节码？

│ │ │ ├─14｜字节码（二）：解释器是如何解释执行字节码的？

│ │ │ ├─15-隐藏类：如何在内存中快速查找对象属性？

│ │ │ ├─16-答疑：V8是怎么通过内联缓存来提升函数执行效率的？

│ │ │ ├─17-消息队列：V8是怎么实现回调函数的？

│ │ │ ├─18-异步编程（一）：V8是如何实现微任务的？

│ │ │ ├─19｜异步编程（二）：V8是如何实现async-await的？

│ │ │ ├─20-垃圾回收（一）：V8的两个垃圾回收器是如何工作的？

│ │ │ ├─21-垃圾回收（二）：V8是如何优化垃圾回收器执行效率的？

│ │ │ ├─22｜答疑：几种常见内存问题的解决策略

│ │ │ ├─开篇词-如何学习谷歌高性能JavaScript引擎V8？

│ │ │ ├─结束语-我的前端学习踩坑史

│ │ │ └─结课测试-这些V8的知识你都掌握了吗？

│ │ ├─090-SRE实战手册

│ │ │ ├─01｜SRE迷思：无所不能的角色？还是运维的升级？

│ │ │ ├─02-系统可用性：没有故障，系统就一定是稳定的吗？

│ │ │ ├─03-SRE切入点：选择SLI，设定SLO

│ │ │ ├─04-错误预算：达成稳定性目标的共识机制

│ │ │ ├─05-案例：落地SLO时还需要考虑哪些因素？

│ │ │ ├─06-故障发现：如何建设On-Call机制？

│ │ │ ├─07｜故障处理：一切以恢复业务为最高优先级

│ │ │ ├─08｜故障复盘：黄金三问与判定三原则

│ │ │ ├─090-SRE实战手册

│ │ │ ├─09｜案例：互联网典型的SRE组织架构是怎样的？

│ │ │ ├─10-经验：都有哪些高效的SRE组织协作机制？

│ │ │ ├─开篇词｜SRE是解决系统稳定性问题的灵丹妙药吗？

│ │ │ ├─答疑｜没什么能阻挡你拓展边界的渴望

│ │ │ ├─结束语｜聊聊我的SRE落地心路历程

│ │ │ └─结束语｜聊聊我的SRE落地心路历程

│ │ ├─091-检索技术核心20讲

│ │ │ ├─01-线性结构检索：从数组和链表的原理初窥检索本质

│ │ │ ├─02-非线性结构检索：数据频繁变化的情况下，如何高效检索？

│ │ │ ├─03-哈希检索：如何根据用户ID快速查询用户信息？

│ │ │ ├─04-状态检索：如何快速判断一个用户是否存在？

│ │ │ ├─05-倒排索引：如何从海量数据中查询同时带有“极”和“客”的唐诗？

│ │ │ ├─06-数据库检索：如何使用B+树对海量磁盘数据建立索引？

│ │ │ ├─07-NoSQL检索：为什么日志系统主要用LSM树而非B+树？

│ │ │ ├─08-索引构建：搜索引擎如何为万亿级别网站生成索引？

│ │ │ ├─09-索引更新：刚发布的文章就能被搜到，这是怎么做到的？

│ │ │ ├─091-检索技术核心20讲

│ │ │ ├─10-索引拆分：大规模检索系统如何使用分布式技术加速检索？

│ │ │ ├─11｜精准TopK检索：搜索结果是怎么进行打分排序的？

│ │ │ ├─12-非精准TopK检索：如何给检索结果的排序过程装上“加速器”？

│ │ │ ├─13-空间检索（上）：如何用Geohash实现“查找附近的人”功能？

│ │ │ ├─14-空间检索（下）：“查找最近的加油站”和“查找附近的人”有何不同？

│ │ │ ├─15-最近邻检索（上）：如何用局部敏感哈希快速过滤相似文章？

│ │ │ ├─16-最近邻检索（下）：如何用乘积量化实现“拍照识花”功能？

│ │ │ ├─17-存储系统：从检索技术角度剖析LevelDB的架构设计思想

│ │ │ ├─18-搜索引擎：输入搜索词以后，搜索引擎是怎么工作的？

│ │ │ ├─19-广告系统：广告引擎如何做到在0

│ │ │ ├─20-推荐引擎：没有搜索词，“头条”怎么找到你感兴趣的文章？

│ │ │ ├─导读-三步走策略，轻松搞定检索！

│ │ │ ├─开篇词-学会检索，快人一步！

│ │ │ ├─测一测-检索算法基础，你掌握了多少？

│ │ │ ├─测一测-高性能检索系统的实战知识，你掌握了多少？

│ │ │ ├─特别加餐-倒排检索加速（一）：工业界如何利用跳表、哈希表、位图进行加速？

│ │ │ ├─特别加餐-倒排检索加速（二）：如何对联合查询进行加速？

│ │ │ ├─特别加餐-高性能检索系统中的设计漫谈

│ │ │ ├─结束语-成长和进化，技术如此，我们亦如此

│ │ │ ├─结课测试-这些检索知识，你都掌握了吗？

│ │ │ └─结课测试-这些检索知识，你都掌握了吗？

│ │ ├─092-数据中台实战课

│ │ │ ├─01-前因后果：为什么说数据中台是大数据的下一站？

│ │ │ ├─02-关键抉择：到底什么样的企业应该建数据中台？

│ │ │ ├─03-数据中台建设三板斧：方法论、组织和技术

│ │ │ ├─04-元数据中心的关键目标和技术实现方案

│ │ │ ├─05-如何统一管理纷繁杂乱的数据指标？

│ │ │ ├─06-数据模型无法复用，归根结底还是设计问题

│ │ │ ├─07-同事老打脸说数据有问题，该怎么彻底解决？

│ │ │ ├─08-交付速度和质量问题解决了，老板说还得“省”

│ │ │ ├─09-数据服务到底解决了什么问题？

│ │ │ ├─092-数据中台实战课

│ │ │ ├─10-数据服务难道就是对外提供个API吗？

│ │ │ ├─11-怎么一劳永逸地解决数据安全问题？

│ │ │ ├─12-数据的台子搭完了，但你还得想好戏该怎么唱

│ │ │ ├─13-数据研发就只是写代码吗？

│ │ │ ├─14-数据被加工后，你还要学会使用和管理数据

│ │ │ ├─15-数据中台在网易电商业务的最佳实践

│ │ │ ├─开篇词-数据中台，是陷阱？还是金钥匙？

│ │ │ ├─特别放送｜史凯：建设数据中台到底有什么用？

│ │ │ ├─结束语-数据中台从哪里来，要到哪里去？

│ │ │ ├─结课测试-建设数据中台的这些知识，你都掌握了吗？

│ │ │ └─结课测试-建设数据中台的这些知识，你都掌握了吗？

│ │ ├─093-Kafka核心源码解读

│ │ │ ├─01-日志段：保存消息文件的对象是怎么实现的？

│ │ │ ├─02-日志（上）：日志究竟是如何加载日志段的？

│ │ │ ├─03-日志（下）：彻底搞懂Log对象的常见操作

│ │ │ ├─04-索引（上）：改进的二分查找算法在Kafka索引的应用

│ │ │ ├─05-索引（下）：位移索引和时间戳索引的区别是什么？

│ │ │ ├─06-请求通道：如何实现Kafka请求队列？

│ │ │ ├─07-SocketServer（上）：Kafka到底是怎么应用NIO实现网络通信的？

│ │ │ ├─08-SocketServer（中）：请求还要区分优先级？

│ │ │ ├─09-SocketServer（下）：请求处理全流程源码分析

│ │ │ ├─093-Kafka核心源码解读

│ │ │ ├─10-KafkaApis：Kafka最重要的源码入口，没有之一

│ │ │ ├─11-Controller元数据：Controller都保存有哪些东西？有几种状态？

│ │ │ ├─12-ControllerChannelManager：Controller如何管理请求发送？

│ │ │ ├─13-ControllerEventManager：变身单线程后的Controller如何处理事件？

│ │ │ ├─14-Controller选举是怎么实现的？

│ │ │ ├─15-如何理解Controller在Kafka集群中的作用？

│ │ │ ├─16-TopicDeletionManager：Topic是怎么被删除的？

│ │ │ ├─17-ReplicaStateMachine：揭秘副本状态机实现原理

│ │ │ ├─18-PartitionStateMachine：分区状态转换如何实现？

│ │ │ ├─19-TimingWheel：探究Kafka定时器背后的高效时间轮算法

│ │ │ ├─20-DelayedOperation：Broker是怎么延时处理请求的？

│ │ │ ├─21-AbstractFetcherThread：拉取消息分几步？

│ │ │ ├─22-ReplicaFetcherThread：Follower如何拉取Leader消息？

│ │ │ ├─23-ReplicaManager（上）：必须要掌握的副本管理类定义和核心字段

│ │ │ ├─24-ReplicaManager（中）：副本管理器是如何读写副本的？

│ │ │ ├─25-ReplicaManager（下）：副本管理器是如何管理副本的？

│ │ │ ├─26-MetadataCache：Broker是怎么异步更新元数据缓存的？

│ │ │ ├─27-消费者组元数据（上）：消费者组都有哪些元数据？

│ │ │ ├─28-消费者组元数据（下）：Kafka如何管理这些元数据？

│ │ │ ├─29-GroupMetadataManager：组元数据管理器是个什么东西？

│ │ │ ├─30-GroupMetadataManager：位移主题保存的只是位移吗？

│ │ │ ├─31-GroupMetadataManager：查询位移时，不用读取位移主题？

│ │ │ ├─32-GroupCoordinator：在Rebalance中，Coordinator如何处理成员入组？

│ │ │ ├─33-GroupCoordinator：在Rebalance中，如何进行组同步？

│ │ │ ├─导读-构建Kafka工程和源码阅读环境、Scala语言热身

│ │ │ ├─开篇词-阅读源码，逐渐成了职业进阶道路上的“必选项”

│ │ │ ├─期中测试-这些源码知识，你都掌握了吗？

│ │ │ ├─期末测试-一套习题，测试你的掌握程度

│ │ │ ├─特别放送（一）-经典的Kafka学习资料有哪些？

│ │ │ ├─特别放送（三）-我是怎么度过日常一天的？

│ │ │ ├─特别放送（二）-一篇文章带你了解参与开源社区的全部流程

│ │ │ ├─特别放送（五）-Kafka社区的重磅功能：移除ZooKeeper依赖

│ │ │ ├─特别放送（四）-20道经典的Kafka面试题详解

│ │ │ ├─结束语-源码学习，我们才刚上路呢

│ │ │ ├─重磅加餐-带你快速入门Scala语言

│ │ │ └─重磅加餐-带你快速入门Scala语言

│ │ ├─094-Serverless入门课

│ │ │ ├─01｜定义：到底什么是Serverless？

│ │ │ ├─02-原理：通过一个案例，理解FaaS的运行逻辑

│ │ │ ├─03-原理：FaaS的两种进程模型及应用场景

│ │ │ ├─04-原理：FaaS应用如何才能快速扩缩容？

│ │ │ ├─05-后端BaaS化（上）：NoOps的微服务

│ │ │ ├─06-后端BaaS化（中）：业务逻辑的拆与合

│ │ │ ├─07-后端BaaS化（下）：ContainerServerless

│ │ │ ├─08-搭建私有Serverless（一）：K8s和云原生CNCF

│ │ │ ├─09-搭建私有Serverless（二）：基于K8s的Serverless

│ │ │ ├─094-Serverless入门课

│ │ │ ├─10-经验：Serverless架构应该如何选型？

│ │ │ ├─11-经验：Serverless开发最佳实践

│ │ │ ├─开篇词-说来说去，到底Serverless要解决什么问题？

│ │ │ ├─期末测试-有关Serverless，你掌握了多少呢？

│ │ │ ├─特别放送-为什么阿里要举集团之力趟坑Serverless？

│ │ │ ├─结束语-带你整体回顾我们的Serverless案例

│ │ ├─095-视觉笔记入门课

│ │ │ ├─01-基础：只用点线面也能搞定视觉笔记

│ │ │ ├─02-人物：如何画出引人注目的主角？

│ │ │ ├─03-动态容器：如何生动地记录对话？

│ │ │ ├─04-静态容器：办公用品如何表达你的内容？

│ │ │ ├─05-图标（上）：把现实装进你的笔记

│ │ │ ├─06-图标（下）：万物皆可视觉化

│ │ │ ├─07-链接：如何串联一个旅行故事？

│ │ │ ├─08-字体：如何用文字表现信息的情绪？

│ │ │ ├─09-色彩：如何让你的视觉笔记“有温度”？

│ │ │ ├─095-视觉笔记入门课

│ │ │ ├─10-抽象逻辑构图：如何通过内容关系确定构图方式？

│ │ │ ├─11-具象逻辑构图：如何通过视觉场景进行构图？

│ │ │ ├─12-静态实践：如何做图书的视觉笔记？

│ │ │ ├─13-动态实践：如何做语音信息的视觉笔记？

│ │ │ ├─开篇词-一图胜千言

│ │ │ ├─答疑-笔记大触们可能没有告诉你的那些事

│ │ │ ├─结束语-你和你的笔记都闪闪发光

│ │ │ └─结束语-你和你的笔记都闪闪发光

│ │ ├─096-系统性能调优必知必会

│ │ │ ├─01-CPU缓存：怎样写代码能够让CPU执行得更快？

│ │ │ ├─02-内存池：如何提升内存分配的效率？

│ │ │ ├─03-索引：如何用哈希表管理亿级对象？

│ │ │ ├─04-零拷贝：如何高效地传输文件？

│ │ │ ├─05-协程：如何快速地实现高并发服务？

│ │ │ ├─06-锁：如何根据业务场景选择合适的锁？

│ │ │ ├─07-性能好，效率高的一对多通讯该如何实现？

│ │ │ ├─08-事件驱动：C10M是如何实现的？

│ │ │ ├─09-如何提升TCP三次握手的性能？

│ │ │ ├─096-系统性能调优必知必会

│ │ │ ├─10-如何提升TCP四次挥手的性能？

│ │ │ ├─11-如何修改TCP缓冲区才能兼顾并发数量与传输速度？

│ │ │ ├─12-如何调整TCP拥塞控制的性能？

│ │ │ ├─13-实战：单机如何实现管理百万主机的心跳服务？

│ │ │ ├─14-优化TLS-SSL性能该从何下手？

│ │ │ ├─15-如何提升HTTP-1

│ │ │ ├─16-HTTP-2是怎样提升性能的？

│ │ │ ├─17-Protobuf是如何进一步提高编码效率的？

│ │ │ ├─18-如何通过gRPC实现高效远程过程调用？

│ │ │ ├─19-如何通过监控找到性能瓶颈？

│ │ │ ├─20-CAP理论：怎样舍弃一致性去换取性能？

│ │ │ ├─21-AKF立方体：怎样通过可扩展性来提高性能？

│ │ │ ├─22-NWR算法：如何修改读写模型以提升性能？

│ │ │ ├─23-负载均衡：选择Nginx还是OpenResty？

│ │ │ ├─24-一致性哈希：如何高效地均衡负载？

│ │ │ ├─25-过期缓存：如何防止缓存被流量打穿？

│ │ │ ├─26-应用层多播：如何快速地分发内容？

│ │ │ ├─27-消息队列：如何基于异步消息提升性能？

│ │ │ ├─28-MapReduce：如何通过集群实现离线计算？

│ │ │ ├─29-流式计算：如何通过集群实现实时计算？

│ │ │ ├─30-如何权衡关系数据库与NoSQL数据库？

│ │ │ ├─加餐1｜特别福利：陶辉视频课精选

│ │ │ ├─加餐2｜答疑精选：这些问题你都清楚吗？

│ │ │ ├─加餐3-大厂面试到底在考些什么？

│ │ │ ├─加餐4｜百万并发下Nginx的优化之道

│ │ │ ├─加餐5-如何理解分布式系统？

│ │ │ ├─加餐6｜分布式系统的本质是什么？

│ │ │ ├─加餐7｜深入剖析HTTP-3协议

│ │ │ ├─大咖助场1-李玥：高并发场景下如何优化微服务的性能

│ │ │ ├─大咖助场2｜庄振运：与程序员相关的SSD性能知识

│ │ │ ├─大咖助场3｜傅健：那些年，影响我们达到性能巅峰的常见绊脚石（上）

│ │ │ ├─大咖助场4｜傅健：那些年，影响我们达到性能巅峰的常见绊脚石（下）

│ │ │ ├─开篇词-万变不离其宗，性能优化也有章可循

│ │ │ ├─期中考试｜行至半程，你的收获如何呢？

│ │ │ ├─期末测试｜对于性能优化，你掌握了多少呢？

│ │ │ ├─来领奖啦！你填写毕业问卷了吗？

│ │ │ ├─毕业问卷获奖用户名单

│ │ │ ├─结束语-从业IT20年后，我将最看重什么？

│ │ │ └─结束语-从业IT20年后，我将最看重什么？

│ │ ├─097-罗剑锋的C++实战笔记

│ │ │ ├─01-重新认识C++：生命周期和编程范式

│ │ │ ├─02-编码阶段能做什么：秀出好的codestyle

│ │ │ ├─03-预处理阶段能做什么：宏定义和条件编译

│ │ │ ├─04-编译阶段能做什么：属性和静态断言

│ │ │ ├─05-面向对象编程：怎样才能写出一个“好”的类？

│ │ │ ├─06-auto-decltype：为什么要有自动类型推导？

│ │ │ ├─07-const-volatile-mutable：常量-变量究竟是怎么回事？

│ │ │ ├─08-smartptr：智能指针到底“智能”在哪里？

│ │ │ ├─09-exception：怎样才能用好异常？

│ │ │ ├─097-罗剑锋的C++实战笔记

│ │ │ ├─10-lambda：函数式编程带来了什么？

│ │ │ ├─11-一枝独秀的字符串：C++也能处理文本？

│ │ │ ├─12-三分天下的容器：恰当选择，事半功倍

│ │ │ ├─13-五花八门的算法：不要再手写for循环了

│ │ │ ├─14-十面埋伏的并发：多线程真的很难吗？

│ │ │ ├─15-序列化：简单通用的数据交换格式有哪些？

│ │ │ ├─16-网络通信：我不想写原生Socket

│ │ │ ├─17-脚本语言：搭建高性能的混合系统

│ │ │ ├─18-性能分析：找出程序的瓶颈

│ │ │ ├─19-设计模式（上）：C++与设计模式有啥关系？

│ │ │ ├─20-设计模式（下）：C++是怎么应用设计模式的？

│ │ │ ├─21-知识串讲（上）：带你开发一个书店应用

│ │ │ ├─22-知识串讲（下）：带你开发一个书店应用

│ │ │ ├─开篇词-把C++从“神坛”上拉下来，这次咱这么学

│ │ │ ├─期末测试-这些C++核心知识，你都掌握了吗？

│ │ │ ├─特别放送-和你聊聊现代C++里的“特殊容器”

│ │ │ ├─结束语-路远，未有穷期

│ │ │ ├─罗剑锋老师出新课了？

│ │ │ ├─课前准备-搭建实验环境

│ │ │ ├─轻松话题（一）-4本值得一读再读的经典好书

│ │ │ ├─轻松话题（三）-提高生活质量的App

│ │ │ ├─轻松话题（二）-给你分享我的工作百宝箱

│ │ │ ├─轻松话题（四）-真正高效的生活，是张弛有度

│ │ │ └─轻松话题（四）-真正高效的生活，是张弛有度

│ │ ├─098-互联网人的英语私教课

│ │ │ ├─01｜导读：背景知识对于理解文章究竟有多重要？

│ │ │ ├─02-什么时候适合用“词根词缀法”来背单词？

│ │ │ ├─03｜到底要不要学语法？什么时候学比较好？

│ │ │ ├─04-从那些不规范的表达中，我们可以学到什么？

│ │ │ ├─05｜tradeoff还是trade-off？用连字符到底对不对？

│ │ │ ├─06｜小心那些平淡无奇、人畜无害的简单小词！

│ │ │ ├─07｜为什么虚拟语气一看就懂、一用就忘？

│ │ │ ├─08｜带你一次性搞懂非限定性和限定性定语从句

│ │ │ ├─09-导读：通过阅读序言段了解文章的背景知识

│ │ │ ├─098-互联网人的英语私教课

│ │ │ ├─10｜一切始于“主干”，万变不离其宗

│ │ │ ├─11｜并列句=简单句+并列连词+简单句

│ │ │ ├─12-谓语动词永远是英语句子的核心

│ │ │ ├─13-导读：如何逐渐培养阅读习惯，快速抓住文章大意？

│ │ │ ├─14｜为什么介词如此“烦人”？

│ │ │ ├─15｜同位语的两个重要作用

│ │ │ ├─16｜动词：英语宇宙的中心

│ │ │ ├─17｜参透“主从分明”的树状结构，即可“庖丁解牛”

│ │ │ ├─18｜全篇通读（上）：从读懂一句话慢慢转向读懂一篇文章

│ │ │ ├─19｜全篇通读（下）：不是所有的文章和书籍都值得读完

│ │ │ ├─20｜英语词汇学习的唯一有效途径：阅读、阅读、阅读

│ │ │ ├─21｜你和所有见过的单词或短语都只是加了“好友”而已

│ │ │ ├─22｜paraphrase：跨越阅读和写作两项技能的练习法

│ │ │ ├─23｜练习paraphrase的最终目的，是有一天可以不再需要它

│ │ │ ├─24｜如何用“金字塔原理”来练习阅读和写作？

│ │ │ ├─25｜如何利用“30秒电梯原则”写出言简意赅的读书总结？

│ │ │ ├─26-阅读准备：当我们谈论快速阅读时，我们究竟在谈论什么？

│ │ │ ├─27-行业预测类文章，动词就是它的全部

│ │ │ ├─28-没有经过相关专业训练，如何自学新的专业知识？

│ │ │ ├─29-如何通过定期的主题阅读计划，个性化定制专属的语料库？

│ │ │ ├─30-突破实用型、技术类阅读，外面还有另一片星辰大海

│ │ │ ├─学习指南-我想和你交代下这门课的设计思路

│ │ │ ├─开学直播回顾-程序员如何阅读英语资料？

│ │ │ ├─开篇词-把技能当知识，是学英语最大的坑

│ │ │ ├─每周一起背10句-week01

│ │ │ ├─每周一起背10句-week02

│ │ │ ├─每周一起背10句-week03

│ │ │ ├─每周一起背10句-week04

│ │ │ ├─每周一起背10句-week05

│ │ │ ├─每周一起背10句-week06

│ │ │ ├─每周一起背10句-week07

│ │ │ ├─每周一起背10句-week08

│ │ │ ├─每周一起背10句-week09

│ │ │ ├─用户故事-张理查：作为软件工程师，我怎么学习英语专栏？

│ │ │ ├─结束语-学英语也是修行

│ │ │ └─结束语-学英语也是修行

│ │ ├─099-职场求生攻略

│ │ │ ├─01丨优先级：工作中那么多事情，我要如何安排优先级？

│ │ │ ├─02丨沟通：邮件那么重要，你还在轻视邮件吗？

│ │ │ ├─03丨沟通：程序员为什么应该爱上交流？

│ │ │ ├─04丨主观能动性：为什么程序员，需要发挥主观能动性？

│ │ │ ├─05丨责任的边界：程序员的职责范围仅仅只是被安排的任务吗？

│ │ │ ├─06-职业素养篇热点问题答疑

│ │ │ ├─07-职业规划：如何选择一个公司？

│ │ │ ├─08丨管理者关系：怎么才叫“跟对人”？

│ │ │ ├─099-职场求生攻略

│ │ │ ├─09丨管理者关系：跟对人和做对事哪个更重要？

│ │ │ ├─10丨职业规划：跳槽之前你想清楚这些事情了吗？

│ │ │ ├─11丨面试：如何准备简历和面试？

│ │ │ ├─12丨外包：外包不也是写程序吗？有什么不一样的？

│ │ │ ├─13-外派：大家都在一个办公室工作，有什么不一样？

│ │ │ ├─14-职业规划：转管理是程序员的终极选择吗？

│ │ │ ├─15-职业规划：程序员加入创业公司，这些事情你想清楚了吗？

│ │ │ ├─16-答疑篇：为啥你工作八年，只抵别人一年？

│ │ │ ├─17-升职：看着周围的人都升职了，我什么时候才能升职？

│ │ │ ├─18-职场政治：我只想好好干活，职场政治和我有什么关系？

│ │ │ ├─19-职场政治：面对公司自上而下的技术更新，我该怎么办？

│ │ │ ├─20-沟通技巧：如何跟自己的同事请教问题？

│ │ │ ├─21-答疑篇：想升职，我该准备些什么？

│ │ │ ├─22-学习观：程序员如何定义自己的技术舒适区？

│ │ │ ├─23丨技术观：做程序员，技术观为何如此重要？

│ │ │ ├─24丨技术观：程序员在技术的成长之路上，有哪些陷阱？

│ │ │ ├─25-系统架构：如何从写代码的程序员，成长为软件系统架构师？

│ │ │ ├─26-系统集成：为什么最容易出问题的是系统集成？

│ │ │ ├─27-答疑篇：什么样的技术观能够更快成长？

│ │ │ ├─28-沟通中的冲突：什么时候应该妥协，什么时候应该坚持？

│ │ │ ├─29-加班：加班逃不过，如何用正确姿势加班？

│ │ │ ├─30-焦虑：程序员怎样才能越干越给力？

│ │ │ ├─31-数据观：在你眼里，数据到底是什么？

│ │ │ ├─开篇词-学会如何工作，和学习技术同等重要

│ │ │ ├─结束语-职场的攀岩之路

│ │ │ └─结课测试-这些职场相关问题，你能答对多少？

│ │ ├─100软件设计之美

│ │ │ ├─01-软件设计到底是什么？

│ │ │ ├─02-分离关注点：软件设计至关重要的第一步

│ │ │ ├─03-可测试性：一个影响软件设计的重要因素

│ │ │ ├─04-三步走：如何了解一个软件的设计？

│ │ │ ├─05-SpringDI容器：如何分析一个软件的模型？

│ │ │ ├─06-RubyonRails：如何分析一个软件的接口？

│ │ │ ├─07-Kafka：如何分析一个软件的实现？

│ │ │ ├─08-语言的模型：如何打破单一语言局限，让设计更好地落地？

│ │ │ ├─09-语言的接口：语法和程序库，软件设计的发力点

│ │ │ ├─10-语言的实现：运行时，软件设计的地基

│ │ │ ├─100软件设计之美

│ │ │ ├─11-DSL：你也可以设计一门自己的语言

│ │ │ ├─12-编程范式：明明写的是Java，为什么被人说成了C代码？

│ │ │ ├─13-结构化编程：为什么做设计时仅有结构化编程是不够的？

│ │ │ ├─14-面向对象之封装：怎样的封装才算是高内聚？

│ │ │ ├─15-面向对象之继承：继承是代码复用的合理方式吗？

│ │ │ ├─16-面向对象之多态：为什么“稀疏平常”的多态，是软件设计的大杀器？

│ │ │ ├─17-函数式编程：不用函数式编程语言，怎么写函数式的程序？

│ │ │ ├─18-函数式编程之组合性：函数式编程为什么如此吸引人？

│ │ │ ├─19-函数式编程之不变性：怎样保证我的代码不会被别人破坏？

│ │ │ ├─20-单一职责原则：你的模块到底为谁负责？

│ │ │ ├─21-开放封闭原则：不改代码怎么写新功能？

│ │ │ ├─22-Liskov替换原则：用了继承，子类就设计对了吗？

│ │ │ ├─23-接口隔离原则：接口里的方法，你都用得到吗？

│ │ │ ├─24-依赖倒置原则：高层代码和底层代码，到底谁该依赖谁？

│ │ │ ├─25-设计模式：每一种都是一个特定问题的解决方案

│ │ │ ├─26-简单设计：难道一开始就要把设计做复杂吗？

│ │ │ ├─27-领域驱动设计：如何从零开始设计一个软件？

│ │ │ ├─28-战略设计：如何划分系统的模块？

│ │ │ ├─29-战术设计：如何像写故事一样找出模型？

│ │ │ ├─30-程序库的设计：Moco是如何解决集成问题的？

│ │ │ ├─31-应用的设计：如何设计一个数据采集平台？

│ │ │ ├─32-应用的改进：如何改进我们的软件设计？

│ │ │ ├─加餐-再八卦几门语言！

│ │ │ ├─加餐-函数式编程拾遗

│ │ │ ├─开篇词-软件设计，应对需求规模的“算法”

│ │ │ ├─结束语｜那些没讲的事儿

│ │ │ └─结课测试｜这些软件设计的知识你都掌握了吗？

│ │ ├─101编译原理实战课

│ │ │ ├─01-编译的全过程都悄悄做了哪些事情？

│ │ │ ├─02-词法分析：用两种方式构造有限自动机

│ │ │ ├─03-语法分析：两个基本功和两种算法思路

│ │ │ ├─04-语义分析：让程序符合语义规则

│ │ │ ├─05-运行时机制：程序如何运行，你有发言权

│ │ │ ├─06-中间代码：不是只有一副面孔

│ │ │ ├─07-代码优化：跟编译器做朋友，让你的代码飞起来

│ │ │ ├─08-代码生成：如何实现机器相关的优化？

│ │ │ ├─09-Java编译器（一）：手写的编译器有什么优势？

│ │ │ ├─10-Java编译器（二）：语法分析之后，还要做些什么？

│ │ │ ├─101编译原理实战课

│ │ │ ├─11-Java编译器（三）：属性分析和数据流分析

│ │ │ ├─12-Java编译器（四）：去除语法糖和生成字节码

│ │ │ ├─13-JavaJIT编译器（一）：动手修改Graal编译器

│ │ │ ├─14-JavaJIT编译器（二）：SeaofNodes为何如此强大？

│ │ │ ├─15-JavaJIT编译器（三）：探究内联和逃逸分析的算法原理

│ │ │ ├─16-JavaJIT编译器（四）：Graal的后端是如何工作的？

│ │ │ ├─17-Python编译器（一）：如何用工具生成编译器？

│ │ │ ├─18-Python编译器（二）：从AST到字节码

│ │ │ ├─19-Python编译器（三）：运行时机制

│ │ │ ├─20-JavaScript编译器（一）：V8的解析和编译过程

│ │ │ ├─21-JavaScript编译器（二）：V8的解释器和优化编译器

│ │ │ ├─22-Julia编译器（一）：如何让动态语言性能很高？

│ │ │ ├─23-Julia编译器（二）：如何利用LLVM的优化和后端功能？

│ │ │ ├─24-Go语言编译器：把它当作教科书吧

│ │ │ ├─25-MySQL编译器（一）：解析一条SQL语句的执行过程

│ │ │ ├─26-MySQL编译器（二）：编译技术如何帮你提升数据库性能？

│ │ │ ├─27-课前导读：学习现代语言设计的正确姿势

│ │ │ ├─28-前端总结：语言设计也有人机工程学

│ │ │ ├─29-中端总结：不遗余力地进行代码优化

│ │ │ ├─30-后端总结：充分发挥硬件的能力

│ │ │ ├─31-运行时（一）：从0到语言级的虚拟化

│ │ │ ├─32-运行时（二）：垃圾收集与语言的特性有关吗？

│ │ │ ├─33-并发中的编译技术（一）：如何从语言层面支持线程？

│ │ │ ├─34-并发中的编译技术（二）：如何从语言层面支持协程？

│ │ │ ├─35-并发中的编译技术（三）：Erlang语言厉害在哪里？

│ │ │ ├─36-高级特性（一）：揭秘元编程的实现机制

│ │ │ ├─37-高级特性（二）：揭秘泛型编程的实现机制

│ │ │ ├─38-综合实现（一）：如何实现面向对象编程？

│ │ │ ├─39-综合实现（二）：如何实现函数式编程？

│ │ │ ├─40-成果检验：方舟编译器的优势在哪里？

│ │ │ ├─不定期加餐1-远程办公，需要你我具备什么样的素质？

│ │ │ ├─不定期加餐2-学习技术的过程，其实是训练心理素质的过程

│ │ │ ├─不定期加餐3-这几年，打动我的两本好书

│ │ │ ├─不定期加餐4-从身边的牛人身上，我学到的一些优秀品质

│ │ │ ├─不定期加餐5-借助实例，探究C++编译器的内部机制

│ │ │ ├─划重点-7种编译器的核心概念与算法

│ │ │ ├─学习指南-如何学习这门编译原理实战课？

│ │ │ ├─开篇词-在真实世界的编译器中游历

│ │ │ ├─期中考试-这些编译原理知识，你都掌握了吗？

│ │ │ ├─期末答疑与总结-再次审视学习编译原理的作用

│ │ │ ├─期末考试-“编译原理实战课”100分试卷等你来挑战！

│ │ │ ├─热点问题答疑-如何吃透7种真实的编译器？

│ │ │ ├─用户故事-易昊：程序员不止有Bug和加班，还有诗和远方

│ │ │ ├─知识地图-一起来复习编译技术核心概念与算法

│ │ │ ├─结束语-实战是唯一标准！

│ │ │ └─结束语-实战是唯一标准！

│ │ ├─102正则表达式入门课

│ │ │ ├─01-元字符：如何巧妙记忆正则表达式的基本元件？

│ │ │ ├─02丨量词与贪婪：小小的正则，也可能把CPU拖垮！

│ │ │ ├─03-分组与引用：如何用正则实现更复杂的查找和替换操作？

│ │ │ ├─04-匹配模式：一次性掌握正则中常见的4种匹配模式

│ │ │ ├─05-断言：如何用断言更好地实现替换重复出现的单词？

│ │ │ ├─06-转义：正则中转义需要注意哪些问题？

│ │ │ ├─07-正则有哪些常见的流派及其特性？

│ │ │ ├─08-应用1：正则如何处理Unicode编码的文本？

│ │ │ ├─09-应用2：如何在编辑器中使用正则完成工作？

│ │ │ ├─10-应用3：如何在语言中用正则让文本处理能力上一个台阶？

│ │ │ ├─102正则表达式入门课

│ │ │ ├─11-如何理解正则的匹配原理以及优化原则？

│ │ │ ├─12-问题集锦：详解正则常见问题及解决方案

│ │ │ ├─加餐-从编程语言的角度来理解正则表达式

│ │ │ ├─导读-余晟：我是怎么学习和使用正则的？

│ │ │ ├─开篇词丨学习正则，我们到底要学什么？

│ │ │ ├─结束语-使用正则提高你的人生效率

│ │ │ └─结课测试-这些正则知识，你都掌握了吗？

│ │ ├─103跟月影学可视化

│ │ │ ├─01-浏览器中实现可视化的四种方式

│ │ │ ├─02-指令式绘图系统：如何用Canvas绘制层次关系图？

│ │ │ ├─03-声明式图形系统：如何用SVG图形元素绘制可视化图表？

│ │ │ ├─04-GPU与渲染管线：如何用WebGL绘制最简单的几何图形？

│ │ │ ├─05-如何用向量和坐标系描述点和线段？

│ │ │ ├─06-可视化中你必须要掌握的向量乘法知识

│ │ │ ├─07-如何用向量和参数方程描述曲线？

│ │ │ ├─08-如何利用三角剖分和向量操作描述并处理多边形？

│ │ │ ├─09-如何用仿射变换对几何图形进行坐标变换？

│ │ │ ├─10-图形系统如何表示颜色？

│ │ │ ├─103跟月影学可视化

│ │ │ ├─11｜图案生成：如何生成重复图案、分形图案以及随机效果？

│ │ │ ├─12-如何使用滤镜函数实现美颜效果？

│ │ │ ├─13-如何给简单的图案添加纹理和复杂滤镜？

│ │ │ ├─14-如何使用片元着色器进行几何造型？

│ │ │ ├─15-如何用极坐标系绘制有趣图案？

│ │ │ ├─16-如何使用噪声生成复杂的纹理？

│ │ │ ├─17-如何使用后期处理通道增强图像效果？

│ │ │ ├─18-如何生成简单动画让图形动起来？

│ │ │ ├─19-如何用着色器实现像素动画？

│ │ │ ├─20-如何用WebGL绘制3D物体？

│ │ │ ├─21-如何添加相机，用透视原理对物体进行投影？

│ │ │ ├─22-如何用仿射变换来移动和旋转3D物体？

│ │ │ ├─23-如何模拟光照让3D场景更逼真？（上）

│ │ │ ├─24-如何模拟光照让3D场景更逼真？（下）

│ │ │ ├─25-如何用法线贴图模拟真实物体表面

│ │ │ ├─26-如何绘制带宽度的曲线？

│ │ │ ├─27-案例：如何实现简单的3D可视化图表？

│ │ │ ├─28-Canvas、SVG与WebGL在性能上的优势与劣势

│ │ │ ├─29-怎么给Canvas绘制加速？

│ │ │ ├─30｜怎么给WebGL绘制加速？

│ │ │ ├─31-针对海量数据，如何优化性能？

│ │ │ ├─32-数据之美：如何选择合适的方法对数据进行可视化处理？

│ │ │ ├─33-数据处理（一）：可视化数据处理的一般方法是什么？

│ │ │ ├─34-数据处理（二）：如何处理多元变量？

│ │ │ ├─35-设计（一）：如何让可视化设计更加清晰？

│ │ │ ├─36-设计（二）：如何理解可视化设计原则？

│ │ │ ├─37-实战（一）：如何使用图表库绘制常用数据图表？

│ │ │ ├─38-实战（二）：如何使用数据驱动框架绘制常用数据图表？

│ │ │ ├─39-实战（三）：如何实现地理信息的可视化？

│ │ │ ├─40-实战（四）：如何实现3D地球可视化（上）？

│ │ │ ├─41-实战（五）：如何实现3D地球可视化（下）？

│ │ │ ├─42-如何整理出我们自己的可视化工具集？

│ │ │ ├─加餐1-作为一名程序员，数学到底要多好？

│ │ │ ├─加餐2-SpriteJS：我是如何设计一个可视化图形渲染引擎的？

│ │ │ ├─加餐3-轻松一刻：我想和你聊聊前端的未来

│ │ │ ├─加餐4-一篇文章，带你快速理解函数式编程

│ │ │ ├─加餐5｜周爱民：我想和你分享些学习的道理

│ │ │ ├─国庆策划-假期别闲着，一起来挑战“手势密码”

│ │ │ ├─国庆策划-快来看看怎么用原生JavaScript实现手势解锁组件

│ │ │ ├─开篇词-不写网页的前端工程师，还能干什么？

│ │ │ ├─有奖征集倒计时4天！你填写毕业问卷了吗？

│ │ │ ├─用户故事-非前端开发，我为什么要学可视化？

│ │ │ ├─结束语-可视化工程师的未来之路

│ │ │ ├─预习-Web前端与可视化到底有什么区别？

│ │ │ └─预习-Web前端与可视化到底有什么区别？

│ │ ├─104OAuth2

│ │ │ ├─01-OAuth2

│ │ │ ├─02-授权码许可类型中，为什么一定要有授权码？

│ │ │ ├─03-授权服务：授权码和访问令牌的颁发流程是怎样的？

│ │ │ ├─04-在OAuth2

│ │ │ ├─05-如何安全、快速地接入OAuth2

│ │ │ ├─06-除了授权码许可类型，OAuth2

│ │ │ ├─07-如何在移动App中使用OAuth2

│ │ │ ├─08-实践OAuth2

│ │ │ ├─09-实战：利用OAuth2

│ │ │ ├─10-串讲：OAuth2

│ │ │ ├─104OAuth2

│ │ │ ├─11-实战案例：使用SpringSecurity搭建一套基于JWT的OAuth2

│ │ │ ├─12-架构案例：基于OAuth2

│ │ │ ├─13-各大开放平台是如何使用OAuth2

│ │ │ ├─14-查漏补缺：OAuth2

│ │ │ ├─开篇词-为什么要学OAuth2

│ │ │ ├─结束语-把学习当成一种习惯

│ │ │ └─结束语-把学习当成一种习惯

│ │ ├─105Vim实用技巧必知必会

│ │ │ ├─01｜各平台下的Vim安装方法：上路前准备好你的宝马

│ │ │ ├─02｜基本概念和基础命令：应对简单的编辑任务

│ │ │ ├─03｜更多常用命令：应对稍复杂的编辑任务

│ │ │ ├─04｜初步定制：让你的Vim更顺手

│ │ │ ├─05｜多文件打开与缓冲区：复制粘贴的正确姿势

│ │ │ ├─06｜窗口和标签页：修改、对比多个文件的正确姿势

│ │ │ ├─07｜正则表达式：实现文件内容的搜索和替换

│ │ │ ├─08｜基本编程支持：规避、解决编程时的常见问题

│ │ │ ├─09｜七大常用技巧：让编辑效率再上一个台阶

│ │ │ ├─105Vim实用技巧必知必会

│ │ │ ├─10｜代码重构实验：在实战中提高编辑熟练度

│ │ │ ├─11｜文本的细节：关于字符、编码、行你所需要知道的一切

│ │ │ ├─12｜语法加亮和配色方案：颜即正义

│ │ │ ├─13｜YouCompleteMe：Vim里的自动完成

│ │ │ ├─14｜Vim脚本简介：开始你的深度定制

│ │ │ ├─15｜插件荟萃：不可或缺的插件

│ │ │ ├─16｜终端和GDB支持：不离开Vim完成开发任务

│ │ │ ├─导读｜池建强：Vim就是四个字“唯快不破”

│ │ │ ├─开篇词｜我们为什么要学Vim？

│ │ │ ├─拓展1｜纯文本编辑：使用Vim书写中英文文档

│ │ │ ├─拓展2｜C程序员的Vim工作环境：C代码的搜索、提示和自动完成

│ │ │ ├─拓展3｜Python程序员的Vim工作环境：完整的Python开发环境

│ │ │ ├─拓展4-插件样例分析：自己动手改进插件

│ │ │ ├─拓展5-其他插件和技巧：吴咏炜的箱底私藏

│ │ │ ├─结束语｜Vim森林探秘，一切才刚刚开始

│ │ │ └─结课测试｜这些Vim的知识你都掌握了吗？

│ │ ├─106如何看懂一幅画

│ │ │ ├─01-历史与流派：关于油画，你必须了解的事儿

│ │ │ ├─02-油画名词小清单：如何正确欣赏油画？

│ │ │ ├─03-梵高的画到底好在哪里？

│ │ │ ├─04-为什么戴珍珠耳环的少女比蒙娜丽莎更灵动？

│ │ │ ├─05｜《自由引导人民》超燃的秘密是什么？

│ │ │ ├─06-名画《呐喊》是怎么变成表情包的？

│ │ │ ├─07-抽象画究竟在画什么？

│ │ │ ├─08-油画圈里有哪些经久不衰的“梗”？

│ │ │ ├─09-如何在一幅画里观察艺术家的情绪？

│ │ │ ├─10-你知道最早的平面广告是什么吗？

│ │ │ ├─106如何看懂一幅画

│ │ │ ├─11-什么样的模仿才是高级的模仿？

│ │ │ ├─12-为什么戈雅的画风是奇异多变的？

│ │ │ ├─13-莫奈是怎样捕捉生命中每一个瞬间的？

│ │ │ ├─14-为什么毕加索画的情人都是天价名画？

│ │ │ ├─15-什么样的画才是一幅好画？

│ │ │ ├─加餐-拉斐尔逝世500年回顾展

│ │ │ ├─开篇词-先看懂一幅画，再去看这个世界

│ │ │ ├─拓展1-为什么画里的人不穿衣服？

│ │ │ ├─拓展2-油画里有哪些彩蛋和趣事？

│ │ │ ├─拓展3-如何从名画中学习穿搭技巧？

│ │ │ ├─拓展4-如何用欣赏油画的方式看电影？

│ │ │ ├─拓展5-如何在博物馆里优雅地观赏一幅画？

│ │ │ ├─结束语-艺术之旅，没有终点

│ │ │ ├─编辑手记-开一朵在技术石块里生长的小花

│ │ │ └─编辑手记-开一朵在技术石块里生长的小花

│ │ ├─107重学线性代数

│ │ │ ├─01-导读：如何在机器学习中运用线性代数工具？

│ │ │ ├─02-基本概念：线性代数研究的到底是什么问题？

│ │ │ ├─03-矩阵：为什么说矩阵是线性方程组的另一种表达？

│ │ │ ├─04-解线性方程组：为什么用矩阵求解的效率这么高？

│ │ │ ├─05-线性空间：如何通过向量的结构化空间在机器学习中做降维处理？

│ │ │ ├─06-线性无关：如何理解向量在N维空间的几何意义？

│ │ │ ├─07-基和秩：为什么说它表达了向量空间中“有用”的向量个数？

│ │ │ ├─08-线性映射：如何从坐标系角度理解两个向量空间之间的函数？

│ │ │ ├─09-仿射空间：如何在图形的平移操作中大显身手？

│ │ │ ├─10-解析几何：为什么说它是向量从抽象到具象的表达？

│ │ │ ├─107重学线性代数

│ │ │ ├─11-如何运用线性代数方法解决图论问题？

│ │ │ ├─12-如何通过矩阵转换让3D图形显示到二维屏幕上？

│ │ │ ├─13-如何通过有限向量空间加持的希尔密码，提高密码被破译的难度？

│ │ │ ├─14-如何在深度学习中运用数值代数的迭代法做训练？

│ │ │ ├─15-如何从计算机的角度来理解线性代数？

│ │ │ ├─基础通关-线性代数5道典型例题及解析

│ │ │ ├─开篇词-从今天起，学会线性代数

│ │ │ ├─强化通关-线性代数水平测试20题

│ │ │ ├─结束语-和数学打交道这么多年，我的三点感悟

│ │ │ └─结束语-和数学打交道这么多年，我的三点感悟

│ │ ├─108Redis核心技术与实战

│ │ │ ├─01-基本架构：一个键值数据库包含什么？

│ │ │ ├─02-数据结构：快速的Redis有哪些慢操作？

│ │ │ ├─03-高性能IO模型：为什么单线程Redis能那么快？

│ │ │ ├─04-AOF日志：宕机了，Redis如何避免数据丢失？

│ │ │ ├─05-内存快照：宕机后，Redis如何实现快速恢复？

│ │ │ ├─06-数据同步：主从库如何实现数据一致？

│ │ │ ├─07-哨兵机制：主库挂了，如何不间断服务？

│ │ │ ├─08-哨兵集群：哨兵挂了，主从库还能切换吗？

│ │ │ ├─09-切片集群：数据增多了，是该加内存还是加实例？

│ │ │ ├─10-第1～9讲课后思考题答案及常见问题答疑

│ │ │ ├─108Redis核心技术与实战

│ │ │ ├─11-“万金油”的String，为什么不好用了？

│ │ │ ├─12-有一亿个keys要统计，应该用哪种集合？

│ │ │ ├─13-GEO是什么？还可以定义新的数据类型吗？

│ │ │ ├─14-如何在Redis中保存时间序列数据？

│ │ │ ├─15-消息队列的考验：Redis有哪些解决方案？

│ │ │ ├─16-异步机制：如何避免单线程模型的阻塞？

│ │ │ ├─17-为什么CPU结构也会影响Redis的性能？

│ │ │ ├─18-波动的响应延迟：如何应对变慢的Redis？（上）

│ │ │ ├─19-波动的响应延迟：如何应对变慢的Redis？（下）

│ │ │ ├─20-删除数据后，为什么内存占用率还是很高？

│ │ │ ├─21-缓冲区：一个可能引发“惨案”的地方

│ │ │ ├─22-第11～21讲课后思考题答案及常见问题答疑

│ │ │ ├─23-旁路缓存：Redis是如何工作的？

│ │ │ ├─24-替换策略：缓存满了怎么办？

│ │ │ ├─25-缓存异常（上）：如何解决缓存和数据库的数据不一致问题？

│ │ │ ├─26-缓存异常（下）：如何解决缓存雪崩、击穿、穿透难题？

│ │ │ ├─27-缓存被污染了，该怎么办？

│ │ │ ├─28-Pika：如何基于SSD实现大容量Redis？

│ │ │ ├─29-无锁的原子操作：Redis如何应对并发访问？

│ │ │ ├─30-如何使用Redis实现分布式锁？

│ │ │ ├─31-事务机制：Redis能实现ACID属性吗？

│ │ │ ├─32-Redis主从同步与故障切换，有哪些坑？

│ │ │ ├─33-脑裂：一次奇怪的数据丢失

│ │ │ ├─34-第23~33讲课后思考题答案及常见问题答疑

│ │ │ ├─35-CodisVSRedisCluster：我该选择哪一个集群方案？

│ │ │ ├─36-Redis支撑秒杀场景的关键技术和实践都有哪些？

│ │ │ ├─37-数据分布优化：如何应对数据倾斜？

│ │ │ ├─38-通信开销：限制RedisCluster规模的关键因素

│ │ │ ├─39-Redis6

│ │ │ ├─40-Redis的下一步：基于NVM内存的实践

│ │ │ ├─41-第35～40讲课后思考题答案及常见问题答疑

│ │ │ ├─加餐（一）-经典的Redis学习资料有哪些？

│ │ │ ├─加餐（七）-从微博的Redis实践中，我们可以学到哪些经验？

│ │ │ ├─加餐（三）-用户Kaito：我希望成为在压力中成长的人

│ │ │ ├─加餐（二）-用户Kaito：我是如何学习Redis的？

│ │ │ ├─加餐（五）-Redis有哪些好用的运维工具？

│ │ │ ├─加餐（六）-Redis的使用规范小建议

│ │ │ ├─加餐（四）-Redis客户端如何与服务器端交换命令和数据？

│ │ │ ├─开篇词-这样学Redis，才能技高一筹

│ │ │ ├─期中测试题-一套习题，测出你的掌握程度

│ │ │ ├─期中测试题答案-这些问题，你都答对了吗？

│ │ │ ├─期末测试-这些Redis核心知识，你都掌握了吗？

│ │ │ ├─结束语-从学习Redis到向Redis学习

│ │ │ └─结束语-从学习Redis到向Redis学习

│ │ ├─109分布式数据库30讲

│ │ │ ├─01｜什么是分布式数据库？

│ │ │ ├─02｜强一致性：那么多数据一致性模型，究竟有啥不一样？

│ │ │ ├─03｜强一致性：别再用BASE做借口，来看看什么是真正的事务一致性

│ │ │ ├─04-架构风格：NewSQL和PGXC到底有啥不一样？

│ │ │ ├─05-全局时钟：物理时钟和逻辑时钟你Pick谁？

│ │ │ ├─06-分片机制：为什么说Range是更好的分片策略？

│ │ │ ├─07-数据复制：为什么有时候Paxos不是最佳选择？

│ │ │ ├─08-基础篇大串讲：重难点回顾+思考题答疑+知识全景图

│ │ │ ├─09｜原子性：2PC还是原子性协议的王者吗？

│ │ │ ├─10-原子性：如何打破事务高延迟的魔咒？

│ │ │ ├─109分布式数据库30讲

│ │ │ ├─11｜隔离性：读写冲突时，快照是最好的办法吗？

│ │ │ ├─12-隔离性：看不见的读写冲突，要怎么处理？

│ │ │ ├─13-隔离性：为什么使用乐观协议的分布式数据库越来越少

│ │ │ ├─14-隔离性：实现悲观协议，除了锁还有别的办法吗？

│ │ │ ├─15-分布式事务串讲：重难点回顾+思考题答疑+知识全景图

│ │ │ ├─16-为什么不建议你使用存储过程？

│ │ │ ├─17-为什么不建议你使用自增主键？

│ │ │ ├─18-HTAP是不是赢者通吃的游戏？

│ │ │ ├─19-查询性能优化：计算与存储分离架构下有哪些优化思路？

│ │ │ ├─20-关联查询：如何提升多表Join能力？

│ │ │ ├─21-查询执行引擎：如何让聚合计算加速？

│ │ │ ├─22｜RUM猜想：想要读写快还是存储省？又是三选二

│ │ │ ├─23-数据库查询串讲：重难点回顾+思考题答疑+知识全景图

│ │ │ ├─24-全球化部署：如何打造近在咫尺且永不宕机的数据库？

│ │ │ ├─25-容灾与备份：如何设计逃生通道保证业务连续性？

│ │ │ ├─26-容器化：分布式数据库要不要上云，你想好了吗？

│ │ │ ├─27-产品测试：除了性能跑分，还能测个啥？

│ │ │ ├─28-选型案例：银行是怎么选择分布式数据库的？

│ │ │ ├─29-产品图鉴：哪些分布式数据库值得看？

│ │ │ ├─30-实践篇大串讲：重难点回顾+思考题答疑+知识全景图

│ │ │ ├─开篇词｜为什么要学习分布式数据库？

│ │ │ ├─用户故事-李兆龙：博观而约取，厚积而薄发

│ │ │ ├─结束语-享受职业带给你的快乐

│ │ │ └─结课测试｜这些分布式数据库的问题，你都掌握了吗？

│ │ ├─110ToB市场品牌实战课

│ │ │ ├─01-ToB市场营销到底是做什么的？

│ │ │ ├─02-ToB消费心理学：如何把握客户CEO心理，让他买单？

│ │ │ ├─03-第一印象（上）：如何策划一场产品发布会？

│ │ │ ├─04-第一印象（下）：如何策划一场产品发布会？

│ │ │ ├─05-Leads：如何成体系地寻找高质量的Leads？

│ │ │ ├─06-案例：怎样0成本把一个新产品的市场认知率做到76%？

│ │ │ ├─07-产品世界观：如何构建一个好的对外产品故事体系？

│ │ │ ├─08-口碑：如何打造一个有影响力的Demo？

│ │ │ ├─09-后疫情时代，如何做ToB市场品牌内容的线上转型？

│ │ │ ├─10-如何用“周边”产品构建ToB影响力？

│ │ │ ├─11-打造案例（上）：如何做优质客户案例的选型和内容构造？

│ │ │ ├─110ToB市场品牌实战课

│ │ │ ├─12-打造案例（中）：如何引发现象级讨论，打赢PR战役？

│ │ │ ├─13-打造案例（下）：如何通过营销战役把商机转化为销量？

│ │ │ ├─14-颜值美学：如何体现ToB产品营销的设计感？

│ │ │ ├─15-如何给企业讲一个“降本”的故事？

│ │ │ ├─16｜如何给企业讲一个“增效”的故事？

│ │ │ ├─17｜市场中的禁忌：ToB营销中容易犯哪些错误？

│ │ │ ├─18-ToB营销的阵地：我们在哪里说话，也很重要

│ │ │ ├─ToB会客厅｜SDR是如何优化线索跟进策略，提升销售效能的？

│ │ │ ├─ToB会客厅｜如何通过整体营销迎接后疫情时代的市场挑战？

│ │ │ ├─开篇词-成为下一个万亿市场风口上的操盘人

│ │ │ ├─结束语-一个ToB的市场人应该具备怎样的特质？

│ │ │ └─结束语-一个ToB的市场人应该具备怎样的特质？

│ │ ├─111Linux内核技术实战课

│ │ │ ├─01基础篇-如何用数据观测PageCache？

│ │ │ ├─02基础篇-PageCache是怎样产生和释放的？

│ │ │ ├─03案例篇-如何处理PageCache难以回收产生的load飙高问题？

│ │ │ ├─04案例篇-如何处理PageCache容易回收引起的业务性能问题？

│ │ │ ├─05分析篇-如何判断问题是否由PageCache产生的？

│ │ │ ├─06基础篇-进程的哪些内存类型容易引起内存泄漏？

│ │ │ ├─07案例篇-如何预防内存泄漏导致的系统假死？

│ │ │ ├─08案例篇-Shmem：进程没有消耗内存，内存哪去了？

│ │ │ ├─09分析篇-如何对内核内存泄漏做些基础的分析？

│ │ │ ├─10分析篇-内存泄漏时，我们该如何一步步找到根因？

│ │ │ ├─111Linux内核技术实战课

│ │ │ ├─11基础篇-TCP连接的建立和断开受哪些系统配置影响？

│ │ │ ├─12基础篇-TCP收发包过程会受哪些配置项影响？

│ │ │ ├─13案例篇-TCP拥塞控制是如何导致业务性能抖动的？

│ │ │ ├─14案例篇-TCP端到端时延变大，怎样判断是哪里出现了问题？

│ │ │ ├─15分析篇-如何高效地分析TCP重传问题？

│ │ │ ├─16套路篇-如何分析常见的TCP问题？

│ │ │ ├─17基础篇-CPU是如何执行任务的？

│ │ │ ├─18案例篇-业务是否需要使用透明大页：水可载舟，亦可覆舟？

│ │ │ ├─19案例篇-网络吞吐高的业务是否需要开启网卡特性呢？

│ │ │ ├─20分析篇-如何分析CPU利用率飙高问题？

│ │ │ ├─加餐-我是如何使用tracepoint来分析内核Bug的？

│ │ │ ├─开篇词-如何让Linux内核更好地服务应用程序？

│ │ │ ├─结束语-第一次看内核代码，我也很懵逼

│ │ │ └─结课测试-这些Linux内核技术实战技能你都掌握了吗？

│ │ ├─112技术管理案例课

│ │ │ ├─01-领导力：如何在实践中应用不同层次的领导力？

│ │ │ ├─02-经理权：如何有效使用经理权？

│ │ │ ├─03-领导特质：一个合格经理人应有的4个待人处事原则

│ │ │ ├─04-避坑指南：从技术骨干到一线经理，你会遇到哪些坑？

│ │ │ ├─05｜事急则乱：上任第一个礼拜的教训

│ │ │ ├─06-员工沟通：怎么赢得之前平级的技术骨干的尊重？

│ │ │ ├─07-向上管理：你知不知道你领导真正的烦恼是啥？

│ │ │ ├─08-人才招聘：招人过程中容易犯的5种错误

│ │ │ ├─09-人才培养：御人也是育人，人才培养的5个维度

│ │ │ ├─10-裁人：“心要慈、刀要快”，做好裁人这件事

│ │ │ ├─11-员工关怀：发自内心地关心人，是一切的基础

│ │ │ ├─112技术管理案例课

│ │ │ ├─12-进阶心路：不要轻易跨过一线经理，给员工安排工作！

│ │ │ ├─13-变革管理：如何从“拥抱变化”到“发起变化”？

│ │ │ ├─14-冲突管理1：如何进行高压对话？

│ │ │ ├─15-冲突管理2：没有双赢的情况下，如何推进事情发展？

│ │ │ ├─16-冲突管理3：冲突不可怕，可怕的是引发信任危机

│ │ │ ├─17-招募高手：看人看本质，优秀的人才都是内驱的

│ │ │ ├─18-组织管理：如何突破团队效率提升的三大关？

│ │ │ ├─19-危机管理：摆明态度，不要做名义上的领导

│ │ │ ├─20-文化建设：哪些价值观能够提升团队凝聚力？

│ │ │ ├─21-内部考评：为什么说“一碗水端不平”才是公平？

│ │ │ ├─22-技术决策（1）：技术管理者做什么，团队效率才最高？

│ │ │ ├─23-技术决策（2）：拥有辩证思维，才能在纠结中负重前行

│ │ │ ├─24-技术决策（3）：持续跟进进度，执行细节决定成败

│ │ │ ├─开篇词-一个技术总监的管理“自白”

│ │ │ ├─用户故事-Weehua：愿每一个管理者都能勇往直前

│ │ │ ├─结束语-时时反思，优化管理能力

│ │ │ └─结课测试｜这些技术管理的问题，你都掌握了么？

│ │ ├─113用户体验设计实战课

│ │ │ ├─01-商业的天时：如何选择正确的体验策略？

│ │ │ ├─02-如何判断产品体验的商业化潜能？

│ │ │ ├─03-体验设计的模型：找到体验设计的关键规律

│ │ │ ├─04-体验进化：选择正确的增长路径

│ │ │ ├─05-拆解体验量化模型的5个维度

│ │ │ ├─06-如何构建适合体验驱动商业的组织？

│ │ │ ├─07-认知用户：为什么要成为用户企业？

│ │ │ ├─08-三个基因维度，看清用户企业特性

│ │ │ ├─09-如何建立用户数据模型，驱动运营？

│ │ │ ├─10-如何分层理解用户需求？

│ │ │ ├─11-如何重构用户生命周期，指导体验设计？

│ │ │ ├─113用户体验设计实战课

│ │ │ ├─12-你的用户研究方法是正确的吗？

│ │ │ ├─13-场景服务设计：拿到新商业的支点

│ │ │ ├─14｜如何精确洞察场景用户需求？

│ │ │ ├─15｜构建用户体验地图的4个关键步骤

│ │ │ ├─16-如何借助体验地图为用户打造沉浸体验？

│ │ │ ├─17-如何提炼并兑现服务设计的生活主张？

│ │ │ ├─18-如何搭建服务的组织体系？

│ │ │ ├─19-精通产品体验设计：获得润物细无声的力量

│ │ │ ├─20-依靠设计系统，提升体验品质

│ │ │ ├─21-七步判断互联网产品交互设计质量

│ │ │ ├─22-如何为产品设计优雅的界面？

│ │ │ ├─23-产品设计的高级感，是怎么做出来的？

│ │ │ ├─24-如何搭建发挥产品设计价值的流程架构？

│ │ │ ├─25-体验品牌：用户与企业的精神图腾

│ │ │ ├─26-如何打造产品的文化？

│ │ │ ├─27-如何打造用户企业的品牌IP？

│ │ │ ├─28-如何打造场景化的传播策略？

│ │ │ ├─29-如何打造用户同盟？

│ │ │ ├─30-串讲：用体验策略打通商业与用户，手眼通天

│ │ │ ├─开篇词-用户体验，未来十年撬动商业的思维

│ │ │ ├─用户故事-以学习为储备，以实践为阶梯

│ │ │ ├─答疑-找到理论联系实际的钥匙

│ │ │ ├─结束语-设计的智慧，就是不断链接世界与人

│ │ │ └─结课测试-一套习题，测出你的掌握程度

│ │ ├─114WebAssembly入门课

│ │ │ ├─01-基础篇：学习此课程你需要了解哪些基础知识？

│ │ │ ├─02-历史篇：为什么会有WebAssembly这样一门技术？

│ │ │ ├─03-WebAssembly是一门新的编程语言吗？

│ │ │ ├─04-WebAssembly模块的基本组成结构到底有多简单？

│ │ │ ├─05-二进制编码：WebAssembly微观世界的基本数据规则是什么？

│ │ │ ├─06-WAT：如何让一个WebAssembly二进制模块的内容易于解读？

│ │ │ ├─07-WASI：你听说过WebAssembly操作系统接口吗？

│ │ │ ├─08-API：在WebAssemblyMVP标准下你能做到哪些事？

│ │ │ ├─09-WebAssembly能够为Web前端框架赋能吗？

│ │ │ ├─10-有哪些已经投入生产的WebAssembly真实案例？

│ │ │ ├─11-WebAssembly在物联网、多媒体与云技术方面有哪些创新实践？

│ │ │ ├─114WebAssembly入门课

│ │ │ ├─12-有哪些优秀的WebAssembly编译器与运行时？

│ │ │ ├─13-LLVM：如何将自定义的语言编译到WebAssembly？

│ │ │ ├─14-有哪些正在行进中的WebAssemblyPost-MVP提案？

│ │ │ ├─15-如何实现一个WebAssembly在线多媒体处理应用（一）？

│ │ │ ├─16-如何实现一个WebAssembly在线多媒体处理应用（二）？

│ │ │ ├─17-如何实现一个WebAssembly在线多媒体处理应用（三）？

│ │ │ ├─18-如何进行Wasm应用的调试与分析？

│ │ │ ├─19-如何应用WASI及其相关生态？

│ │ │ ├─20-总结与答疑

│ │ │ ├─开篇词-我们为什么要了解WebAssembly？

│ │ │ ├─期末测试｜这些WebAssembly的问题，你都掌握了吗？

│ │ │ ├─结束语-WebAssembly，未来已来

│ │ │ └─结束语-WebAssembly，未来已来

│ │ ├─115动态规划面试宝典

│ │ │ ├─01-硬币找零问题：从贪心算法说起

│ │ │ ├─02-暴力递归：当贪心失效了怎么办？

│ │ │ ├─03-备忘录：如何避免递归中的重复计算？

│ │ │ ├─04-动态规划：完美解决硬币找零

│ │ │ ├─05｜面试即正义第一期：什么样的问题应该使用动态规划？

│ │ │ ├─06-0-1背包：动态规划的HelloWorld

│ │ │ ├─07｜完全背包：深入理解背包问题

│ │ │ ├─08｜子数组问题：从解决动归问题套路到实践解题思路

│ │ │ ├─09｜子序列问题：详解重要的一大类动态规划问题

│ │ │ ├─10｜面试即正义第二期：常见的动态规划面试题串烧

│ │ │ ├─115动态规划面试宝典

│ │ │ ├─11｜动态规划新问题1：攻破最长递增子序列问题

│ │ │ ├─12｜动态规划新问题2：攻破最大子数组问题

│ │ │ ├─13｜动态规划算法设计的关键：最优子结构与状态依赖

│ │ │ ├─14｜面试即正义第三期：刷题指南，熟能生巧

│ │ │ ├─15｜课程回顾与总结（上）

│ │ │ ├─16｜课程回顾与总结（下）

│ │ │ ├─加餐｜买卖股票：常见且必考的动态规划面试题

│ │ │ ├─导读｜动态规划问题纷繁复杂，如何系统学习和掌握它？

│ │ │ ├─开篇词｜为什么大厂都爱考动态规划？

│ │ │ ├─有奖征集倒计时3天！你填写毕业问卷了吗？

│ │ │ ├─期末测试｜有关动态规划，你掌握了多少呢？

│ │ │ ├─结束语｜在我家的后院养长颈鹿

│ │ │ └─结课问卷获奖用户名单

│ │ ├─116深度学习推荐系统实战

│ │ │ ├─01-技术架构：深度学习推荐系统的经典技术架构长啥样？

│ │ │ ├─02-SparrowRecSys：我们要实现什么样的推荐系统？

│ │ │ ├─03-深度学习基础：你打牢深度学习知识的地基了吗？

│ │ │ ├─04-特征工程：推荐系统有哪些可供利用的特征？

│ │ │ ├─05-特征处理：如何利用Spark解决特征处理问题？

│ │ │ ├─06-Embedding基础：所有人都在谈的Embedding技术到底是什么？

│ │ │ ├─07-Embedding进阶：如何利用图结构数据生成GraphEmbedding？

│ │ │ ├─08-Embedding实战：如何使用Spark生成Item2vec和GraphEmbedding？

│ │ │ ├─09-线上服务：如何在线上提供高并发的推荐服务？

│ │ │ ├─10-存储模块：如何用Redis解决推荐系统特征的存储问题？

│ │ │ ├─11-召回层：如何快速又准确地筛选掉不相关物品？

│ │ │ ├─116深度学习推荐系统实战

│ │ │ ├─12-局部敏感哈希：如何在常数时间内搜索Embedding最近邻？

│ │ │ ├─13-模型服务：怎样把你的离线模型部署到线上？

│ │ │ ├─14-融会贯通：SparrowRecSys中的电影相似推荐功能是如何实现的？

│ │ │ ├─15-协同过滤：最经典的推荐模型，我们应该掌握什么？

│ │ │ ├─16-深度学习革命：深度学习推荐模型发展的整体脉络是怎样的？

│ │ │ ├─17-Embedding+MLP：如何用TensorFlow实现经典的深度学习模型？

│ │ │ ├─18｜Wide&Deep：怎样让你的模型既有想象力又有记忆力？

│ │ │ ├─19｜NeuralCF：如何用深度学习改造协同过滤？

│ │ │ ├─20-DeepFM：如何让你的模型更好地处理特征交叉？

│ │ │ ├─21｜注意力机制、兴趣演化：推荐系统如何抓住用户的心？

│ │ │ ├─22｜强化学习：让推荐系统像智能机器人一样自主学习

│ │ │ ├─23｜实战：如何用深度学习模型实现SparrowRecSys的个性化推荐功能？

│ │ │ ├─24-离线评估：常用的推荐系统离线评估方法有哪些？

│ │ │ ├─25-评估指标：我们可以用哪些指标来衡量模型的好坏？

│ │ │ ├─26-在线测试：如何在推荐服务器内部实现A-B测试？

│ │ │ ├─27-评估体系：如何解决A-B测试资源紧张的窘境？

│ │ │ ├─28-业界经典：YouTube深度学习推荐系统的经典架构长什么样？

│ │ │ ├─29-图神经网络：Pinterest是如何应用图神经网络的？

│ │ │ ├─30-流处理平台：Flink是如何快速识别用户兴趣，实现实时推荐的？

│ │ │ ├─31｜模型迭代：阿里巴巴是如何迭代更新推荐模型的？

│ │ │ ├─32-强化学习案例：美团是如何在推荐系统中落地强化学习的？

│ │ │ ├─33｜技术权衡：解决方案这么多，哪个最合适？

│ │ │ ├─国庆策划-关于深度学习推荐系统，我有这些资料想推荐给你

│ │ │ ├─国庆策划-深度学习推荐系统基础，你掌握了多少？

│ │ │ ├─开篇词-从0开始搭建一个深度学习推荐系统

│ │ │ ├─期末考试-“深度学习推荐系统”100分试卷等你来挑战！

│ │ │ ├─模型实战准备（一）-TensorFlow入门和环境配置

│ │ │ ├─模型实战准备（二）-模型特征、训练样本的处理

│ │ │ ├─特别加餐-“银弹”不可靠，最优的模型结构该怎么找？

│ │ │ ├─特别加餐｜TensorFlow的模型离线评估实践怎么做？

│ │ │ ├─答疑-基础架构篇+特征工程篇常见问题解答

│ │ │ ├─答疑-线上服务篇留言问题详解

│ │ │ ├─结束语｜深度学习时代需要什么样的推荐工程师？

│ │ │ └─结束语｜深度学习时代需要什么样的推荐工程师？

│ │ ├─117爱上跑步

│ │ │ ├─01-跑两步就喘了，是不是我不适合跑步？

│ │ │ ├─02-正确的跑步姿势是什么样的？

│ │ │ ├─03-为什么跑步要先热身？

│ │ │ ├─04-怎样制定你的第一个10公里跑步计划？

│ │ │ ├─05-快跑和慢跑，哪个更燃脂？

│ │ │ ├─06-普通跑步者应该如何选择跑鞋？

│ │ │ ├─07-买跑步装备，不要踩这些坑儿

│ │ │ ├─08-跑步前到底应不应该吃东西？

│ │ │ ├─09-跑步到底伤不伤膝盖？

│ │ │ ├─10-参加了20场马拉松，我是如何准备的？

│ │ │ ├─11-除了马拉松，还能参加哪些跑步赛事？

│ │ │ ├─117爱上跑步

│ │ │ ├─12-热点问题答疑：跑完第二天浑身疼，还要不要继续跑？

│ │ │ ├─开篇词-跑步，不那么简单的事儿

│ │ │ └─开篇词-跑步，不那么简单的事儿

│ │ ├─118Go并发编程实战课

│ │ │ ├─01-Mutex：如何解决资源并发访问问题？

│ │ │ ├─02-Mutex：庖丁解牛看实现

│ │ │ ├─03｜Mutex：4种易错场景大盘点

│ │ │ ├─04｜Mutex：骇客编程，如何拓展额外功能？

│ │ │ ├─05｜RWMutex：读写锁的实现原理及避坑指南

│ │ │ ├─06-WaitGroup：协同等待，任务编排利器

│ │ │ ├─07-Cond：条件变量的实现机制及避坑指南

│ │ │ ├─08-Once：一个简约而不简单的并发原语

│ │ │ ├─09-map：如何实现线程安全的map类型？

│ │ │ ├─10-Pool：性能提升大杀器

│ │ │ ├─11-Context：信息穿透上下文

│ │ │ ├─118Go并发编程实战课

│ │ │ ├─12-atomic：要保证原子操作，一定要使用这几种方法

│ │ │ ├─13-Channel：另辟蹊径，解决并发问题

│ │ │ ├─14-Channel：透过代码看典型的应用模式

│ │ │ ├─15-内存模型：Go如何保证并发读写的顺序？

│ │ │ ├─16-Semaphore：一篇文章搞懂信号量

│ │ │ ├─17-SingleFlight和CyclicBarrier：请求合并和循环栅栏该怎么用？

│ │ │ ├─18-分组操作：处理一组子任务，该用什么并发原语？

│ │ │ ├─19-在分布式环境中，Leader选举、互斥锁和读写锁该如何实现？

│ │ │ ├─20-在分布式环境中，队列、栅栏和STM该如何实现？

│ │ │ ├─开篇词-想吃透Go并发编程，你得这样学！

│ │ │ ├─结束语-再聊Go并发编程的价值和精进之路

│ │ │ └─结束语-再聊Go并发编程的价值和精进之路

│ │ ├─119人人都用得上的写作课

│ │ │ ├─01｜写作前戏：如何让阅读真正帮到写作？

│ │ │ ├─02｜以正合以奇胜：好文章都有哪些标志？

│ │ │ ├─03｜躲雷指南：你一定要避开的4大写作误区

│ │ │ ├─04｜重中之重：如何量身打造一个好的写作主题？

│ │ │ ├─05｜谋篇布局：如何为主题搭建一个好的结构？

│ │ │ ├─06｜开篇制胜：必学必会的几大开题手段

│ │ │ ├─07｜生动叙事：如何让读者紧跟你的节奏？

│ │ │ ├─08｜人物出场：为他们设置戏剧化场景的妙招

│ │ │ ├─09｜细节打磨：如何设计出令人过目不忘的细节？

│ │ │ ├─10｜遣词造句：如何让字和句吸引用户的眼球？

│ │ │ ├─119人人都用得上的写作课

│ │ │ ├─11｜有效修改：文章反复推敲的诀窍

│ │ │ ├─12｜如何快速写出一篇高质量的热点文章？

│ │ │ ├─13｜如何写出一篇兼具营销性的好软文？

│ │ │ ├─14｜如何完成一篇出彩的演讲稿？

│ │ │ ├─15｜如何用心讲好一个故事？

│ │ │ ├─开篇词｜碎片化时代如何写出吸引人的好文章？

│ │ │ ├─有奖征集最后1天！你填写毕业问卷了吗？

│ │ │ ├─期中阶段作业打卡：恭喜！5位同学获课程免单

│ │ │ ├─期末阶段作业打卡：恭喜！5位同学获100元充值码

│ │ │ ├─结束语｜写作有时候是一面镜子

│ │ ├─120手机摄影

│ │ │ ├─01｜拍摄前，我们需要做什么？

│ │ │ ├─02｜一张好照片的背后，都隐含着哪些要素？

│ │ │ ├─03｜你的照片里是否有内容？

│ │ │ ├─04-除了横平竖直，照片还能怎么拍？

│ │ │ ├─05｜拍照的光影有最优解吗？

│ │ │ ├─06｜后期概述：工具选择与调色倾向

│ │ │ ├─07｜后期调色：基础工具使用

│ │ │ ├─08｜后期调色：HSL、局部

│ │ │ ├─09｜建筑和场景摄影

│ │ │ ├─10｜人像摄影

│ │ │ ├─11｜食物摄影

│ │ │ ├─120手机摄影

│ │ │ ├─12｜专业相机功能与LivePhotos的使用

│ │ │ ├─13｜忘记构图规则

│ │ │ ├─14｜从零到“零”：多拍与多看

│ │ │ ├─开篇词｜手机拍照这件小事

│ │ │ ├─结束语｜记录生活这件大事

│ │ │ └─结束语｜记录生活这件大事

│ │ ├─121乔新亮的CTO成长复盘

│ │ │ ├─01-职业生涯发展规划：每五年登上一个新台阶

│ │ │ ├─02-到底该怎么理解工作与薪资的关系？

│ │ │ ├─03-看透本质：研发出了生产事故，到底要不要罚钱？

│ │ │ ├─07-管理者最重要的三个任务（一）：组织调整到位

│ │ │ ├─08-管理者最重要的三个任务（二）：加强组织协同效率

│ │ │ ├─09-管理者最重要的三个任务（三）：激发团队活力

│ │ │ ├─10-管理的人性哲学：金刚之怒，菩萨慈悲

│ │ │ ├─11-全局思维和持续完善体系的建立，让团队持续成长

│ │ │ ├─12-管理战略上的聚焦和放弃：有舍才有得

│ │ │ ├─121乔新亮的CTO成长复盘

│ │ │ ├─13-风险管理：世界是脆弱的，持续管理风险非常重要

│ │ │ ├─14-需求做不完，应该怎么办？（初-中级管理者篇）

│ │ │ ├─15-需求做不完，应该怎么办？（高级管理者篇）

│ │ │ ├─17-架构决策，是技术管理者最重要的能力

│ │ │ ├─18-架构设计，专业分工和协作精神的体现

│ │ │ ├─19-产品思维，契约精神是基础，洞察人性才能成就卓越

│ │ │ ├─20-高可用设计，让产品没有后顾之忧

│ │ │ ├─21-高性能设计，一切都围绕着契约精神

│ │ │ ├─22-扩展性设计，看透业务的本质

│ │ │ ├─23-考虑限制，让自己的产品不入险地

│ │ │ ├─24-监控设计，让一切都有迹可循，尽在掌控

│ │ │ ├─25-异常设计，让错误无处遁形

│ │ │ ├─26-上云设计，融合云计算的未来

│ │ │ ├─加餐（一）-大学毕业，我要不要留在一线城市互联网公司？

│ │ │ ├─加餐（一）-如何通过演讲分享，打造自己的影响力？

│ │ │ ├─加餐（三）-选择决定上限，努力决定下限

│ │ │ ├─加餐（二）-工作遇到不懂的问题：何时可以求助，如何正确提问？

│ │ │ ├─开篇词-削弱运气的价值

│ │ │ ├─结束语-做时间的朋友

│ │ │ ├─编辑手记-我被老乔洗脑了

│ │ │ └─编辑手记-我被老乔洗脑了

│ │ ├─122物联网开发实战

│ │ │ ├─01-入门介绍：如何定义物联网？

│ │ │ ├─02-通信技术：设备接入网络的方式有哪些？

│ │ │ ├─03-网络协议：设备使用什么语言与互联网对话？

│ │ │ ├─04-数据分析：数据的价值有哪些？

│ │ │ ├─05-系统实例：怎样设计一个简易物联网系统？

│ │ │ ├─06-物模型：如何定义智能电灯？

│ │ │ ├─07-零配置组网：设备如何发现彼此？

│ │ │ ├─08-MQTT：在实践中掌握一个通信协议

│ │ │ ├─09-边缘中心：物联网网关有多重要？

│ │ │ ├─10-数据处理框架：批处理还是流处理？

│ │ │ ├─11-数据存储：物联网中的数据库有哪些？

│ │ │ ├─12-IoTHub：面对海量设备如何打造高性能设备接入层？

│ │ │ ├─122物联网开发实战

│ │ │ ├─13-隐私：在实践中如何保护用户隐私？

│ │ │ ├─14-安全：物联网平台如何应对安全风险？

│ │ │ ├─15-平台：智能家居开源平台的生态是怎样的？

│ │ │ ├─16-实战准备：如何搭建硬件开发环境？

│ │ │ ├─17-远程控制：怎样打造联网的智能电灯？

│ │ │ ├─18-场景联动：智能电灯如何感知光线？（上）

│ │ │ ├─19-场景联动：智能电灯如何感知光线？（下）

│ │ │ ├─20-智能语音：好玩的语音控制是怎么实现的？

│ │ │ ├─21-多传感器集成：浇花怎么实现自动化？

│ │ │ ├─22-掌控数据：家里的数据可以怎么利用？

│ │ │ ├─假期快乐｜这是一份暂时停更的声明

│ │ │ ├─加餐一-这5本关于物联网的好书，值得一读

│ │ │ ├─加餐三-行业应用：物联网的发展将如何升级第一、第二产业？

│ │ │ ├─加餐二-行业应用：物联网的发展将如何重塑我们的生活？

│ │ │ ├─加餐五-投身物联网行业，如何做好职业规划？

│ │ │ ├─加餐四-5G技术将如何推动物联网的发展？

│ │ │ ├─实战一｜嵌入式开发：如何使用C语言开发智能电灯？

│ │ │ ├─实战二｜MQTT开发：如何实现联网控制？

│ │ │ ├─开篇词-物联网这个趋势，你不应该错过

│ │ │ ├─引子｜RISC-V：物联网领域值得关注的芯片趋势是什么？

│ │ │ ├─用户故事-让野蛮生长成为职业发展的助推剂

│ │ │ ├─用户故事-转战物联网，我相信天道酬勤

│ │ │ ├─结束语-永远做一个具有极客精神的人

│ │ │ └─结课测试-这些物联网的问题，你都掌握了吗？

│ │ ├─123容器实战高手课

│ │ │ ├─01-认识容器：容器的基本操作和实现原理

│ │ │ ├─02-理解进程（1）：为什么我在容器中不能kill1号进程？

│ │ │ ├─03｜理解进程（2）：为什么我的容器里有这么多僵尸进程？

│ │ │ ├─04-理解进程（3）：为什么我在容器中的进程被强制杀死了？

│ │ │ ├─05｜容器CPU（1）：怎么限制容器的CPU使用？

│ │ │ ├─06-容器CPU（2）：如何正确地拿到容器CPU的开销？

│ │ │ ├─07-LoadAverage：加了CPUCgroup限制，为什么我的容器还是很慢？

│ │ │ ├─08-容器内存：我的容器为什么被杀了？

│ │ │ ├─09-PageCache：为什么我的容器内存使用量总是在临界点

│ │ │ ├─10-Swap：容器可以使用Swap空间吗？

│ │ │ ├─11-容器文件系统：我在容器中读写文件怎么变慢了？

│ │ │ ├─12-容器文件Quota：容器为什么把宿主机的磁盘写满了？

│ │ │ ├─123容器实战高手课

│ │ │ ├─13-容器磁盘限速：我的容器里磁盘读写为什么不稳定

│ │ │ ├─14-容器中的内存与I-O：容器写文件的延时为什么波动很大？

│ │ │ ├─15-容器网络：我修改了-proc-sys-net下的参数，为什么在容器中不起效？

│ │ │ ├─16-容器网络配置（1）：容器网络不通了要怎么调试

│ │ │ ├─17｜容器网络配置（2）：容器网络延时要比宿主机上的高吗

│ │ │ ├─18-容器网络配置（3）：容器中的网络乱序包怎么这么高？

│ │ │ ├─19-容器安全（1）：我的容器真的需要privileged权限吗

│ │ │ ├─20-容器安全（2）：在容器中，我不以root用户来运行程序可以吗？

│ │ │ ├─加餐01-案例分析：怎么解决海量IPVS规则带来的网络延时抖动问题？

│ │ │ ├─加餐02-理解perf：怎么用perf聚焦热点函数？

│ │ │ ├─加餐03-理解ftrace（1）：怎么应用ftrace查看长延时内核函数？

│ │ │ ├─加餐04-理解ftrace（2）：怎么理解ftrace背后的技术tracepoint和kprobe？

│ │ │ ├─加餐05-eBPF：怎么更加深入地查看内核中的函数？

│ │ │ ├─加餐06-BCC：入门eBPF的前端工具

│ │ │ ├─加餐福利-课后思考题答案合集

│ │ │ ├─开篇词-一个态度两个步骤，成为容器实战高手

│ │ │ ├─用户故事-莫名：相信坚持的力量，终会厚积薄发

│ │ │ ├─结束语-跳出舒适区，突破思考的惰性

│ │ │ └─结课测试｜这些容器技术的问题，你都掌握了么？

│ │ ├─124实用密码学

│ │ │ ├─01-学习密码学有什么用？

│ │ │ ├─02｜单向散列函数：如何保证信息完整性？

│ │ │ ├─03｜如何设置合适的安全强度？

│ │ │ ├─04｜选择哈希算法应该考虑哪些因素？

│ │ │ ├─05｜如何有效避免长度延展攻击？

│ │ │ ├─06｜对称密钥：如何保护私密数据？

│ │ │ ├─07-怎么选择对称密钥算法？

│ │ │ ├─08-该怎么选择初始化向量？

│ │ │ ├─09-为什么ECB模式不安全？

│ │ │ ├─10-怎么防止数据重放攻击？

│ │ │ ├─11-怎么利用解密端攻击？

│ │ │ ├─12-怎么利用加密端攻击？

│ │ │ ├─124实用密码学

│ │ │ ├─13-如何防止数据被调包？

│ │ │ ├─14-加密数据能够自我验证吗？

│ │ │ ├─15-AEAD有哪些安全陷阱？

│ │ │ ├─16-为什么说随机数都是骗人的？

│ │ │ ├─17-加密密钥是怎么来的？

│ │ │ ├─18-如何管理对称密钥？

│ │ │ ├─19-量子时代，你准备好了吗？

│ │ │ ├─20-综合案例：如何解决约会难题？

│ │ │ ├─加餐-密码学，心底的冷暖

│ │ │ ├─开篇词-人人都要会点密码学

│ │ │ ├─结束语-深挖坑、广积粮

│ │ │ └─结课测试-这些密码学的知识，你都掌握了吗？

│ │ ├─125大厂晋升指南

│ │ │ ├─01-职级体系：你意识到级别鸿沟了吗？

│ │ │ ├─02｜晋升流程：你需要通过多少“关卡”才能晋升？

│ │ │ ├─03-晋升原则：什么样的人更容易晋升？

│ │ │ ├─04-晋升逻辑：别人怎么判断你有没有达到晋升要求？

│ │ │ ├─05-COMD能力模型：怎么把抽象的能力要求具体化？

│ │ │ ├─06-职级档次：你现在应该具备的核心能力是什么？

│ │ │ ├─07-P5提升攻略：怎么快速从学生转变为“打工人”？

│ │ │ ├─08-P6提升攻略：怎么成为独立自主的“项目能手”？

│ │ │ ├─09-P7提升攻略：怎么成为让人信服的“团队专家”？

│ │ │ ├─10-P8提升攻略：怎么成为有影响力的“领域专家”？

│ │ │ ├─11-P9提升攻略：怎么成为跨域整合的“业务导演”？

│ │ │ ├─12-PPT框架：标准的晋升PPT长什么样子？

│ │ │ ├─125大厂晋升指南

│ │ │ ├─13-PPT写作：怎么写才能展现自己真正的实力？

│ │ │ ├─14-PPT讲解：怎么讲才能让评委印象深刻？

│ │ │ ├─15-答辩技巧：回答评委提问有哪些技巧？

│ │ │ ├─16-导学：你应该掌握哪些学习方法？

│ │ │ ├─17-海绵学习法：怎么找到你的10000小时？

│ │ │ ├─18-三段分解法：怎么利用10000小时成为大牛？

│ │ │ ├─19-链式&比较&环式学习法：怎么多维度提升技术能力？

│ │ │ ├─20-Play&Teach：怎么摆脱“从入门到忘记”的学习困境？

│ │ │ ├─21-导学：你应该掌握哪些做事方法？

│ │ │ ├─22-OKR的优势：为什么要用OKR来取代KPI做团队规划？

│ │ │ ├─23-OKR规划法：TeamLeader怎么做团队规划？

│ │ │ ├─24-3C方案设计法：怎么让你的方案有理有据？

│ │ │ ├─25-PDCA执行法：怎么推动落地才能“步步为赢”？

│ │ │ ├─26-5W根因分析法：怎么找准问题源头才能治标又治本？

│ │ │ ├─27-5S问题处理法：怎么应对问题才能转危为机？

│ │ │ ├─28-4D总结法：怎么展示你的工作亮点？

│ │ │ ├─29-金字塔汇报法：怎么汇报才能让领导认可你的成果？

│ │ │ ├─30-四线复盘法：怎么避免成为背锅侠？

│ │ │ ├─31-导学：为什么业务和管理是晋升高级别的基石？

│ │ │ ├─32-5W1H8C1D分析法：P5-P6怎么理解业务功能？

│ │ │ ├─33-AARRR漏斗模型：P7-P8怎么掌握业务领域？

│ │ │ ├─34-宝洁战略模型：P8+-P9怎么看懂业务战略？

│ │ │ ├─35-管理四象限：小白要怎么快速入门带团队？

│ │ │ ├─36-管理五模式：高手常用的管理模式有哪些？

│ │ │ ├─加餐一-晋升等级：不同的职级体系如何对标？

│ │ │ ├─加餐三-10000小时定律：成为大牛的秘密是什么？

│ │ │ ├─加餐二-提名词：怎么夸自己才最加分？

│ │ │ ├─加餐五-《大厂晋升指南》推荐书单

│ │ │ ├─加餐四-学习基础技术：你对“基础”的理解准确吗？

│ │ │ ├─开篇词-重新理解晋升

│ │ │ ├─放学别走-如何画好领域分层图？

│ │ │ ├─结束语-晋升也是一种修行

│ │ │ └─结课测试题｜这些晋升的知识，你都掌握了吗？

│ │ ├─126A-B测试从0到1

│ │ │ ├─01-统计基础（上）：系统掌握指标的统计属性

│ │ │ ├─02｜统计基础（下）：深入理解A-B测试中的假设检验

│ │ │ ├─03｜确定目标和假设：好的目标和假设是什么？

│ │ │ ├─04｜确定指标：指标这么多，到底如何来选择？

│ │ │ ├─05｜选取实验单位：什么样的实验单位是合适的？

│ │ │ ├─06-选择实验样本量：样本量越多越好吗？

│ │ │ ├─07｜分析测试结果：你得到的测试结果真的靠谱吗？

│ │ │ ├─08-案例串讲：从0开始，搭建一个规范的A-B测试框架

│ │ │ ├─09｜测试结果不显著，要怎么改善？

│ │ │ ├─10｜常见误区及解决方法（上）：多重检验问题和学习效应

│ │ │ ├─11-常见误区及解决方法（下）：辛普森悖论和实验组-对照组的独立性

│ │ │ ├─126A-B测试从0到1

│ │ │ ├─12｜什么情况下不适合做A-B测试？

│ │ │ ├─13｜融会贯通：A-B测试面试必知必会（上）

│ │ │ ├─14｜举一反三：A-B测试面试必知必会（下）

│ │ │ ├─15｜用R-Shiny，教你制作一个样本量计算器

│ │ │ ├─加餐｜试验意识改变决策模式，推动业务增长

│ │ │ ├─导读-科学、规范的A-B测试流程，是什么样的？

│ │ │ ├─开篇词｜用好A-B测试，你得这么学

│ │ │ ├─结束语｜实践是检验真理的唯一标准

│ │ │ └─结课测试题｜这些A-B测试的知识你都掌握了吗？

│ │ ├─127成为AI产品经理

│ │ │ ├─01-行业视角：产品经理眼中的人工智能

│ │ │ ├─02-个人视角：成为AI产品经理，要先搞定这两个问题

│ │ │ ├─03-技术视角：AI产品经理需要懂的技术全景图

│ │ │ ├─04-过来人讲：成为AI产品经理的两条路径

│ │ │ ├─05-通过一个AI产品的落地，掌握产品经理工作全流程

│ │ │ ├─06-AI模型的构建过程是怎样的？（上）

│ │ │ ├─07-AI模型的构建过程是怎样的（下）

│ │ │ ├─08-算法全景图：AI产品经理必须要懂的算法有哪些？

│ │ │ ├─09-K近邻算法：机器学习入门必学算法

│ │ │ ├─10-线性回归：教你预测，投放多少广告带来的收益最大

│ │ │ ├─11-逻辑回归：如何预测用户是否会购买商品？

│ │ │ ├─12-朴素贝叶斯：让AI告诉你，航班延误险该不该买？

│ │ │ ├─127成为AI产品经理

│ │ │ ├─13-决策树与随机森林：如何预测用户会不会违约？

│ │ │ ├─14-支持向量机：怎么预测股票市场的涨与跌？

│ │ │ ├─15-K-means聚类算法：如何挖掘高价值用户？

│ │ │ ├─16-深度学习：当今最火的机器学习技术，你一定要知道

│ │ │ ├─17-模型评估：从一个失控的项目看优秀的产品经理如何评估AI模型？

│ │ │ ├─18-核心技能：产品经理评估模型需要关注哪些指标？

│ │ │ ├─19-模型性能评估（一）：从信用评分产品看什么是混淆矩阵？

│ │ │ ├─20-模型性能评估（二）：从信用评分产品看什么是KS、AUC？

│ │ │ ├─21-模型性能评估（三）：从股价预测产品看回归算法常用的评估指标

│ │ │ ├─22-模型稳定性评估：如何用PSI来评估信用评分产品的稳定性？

│ │ │ ├─23-模型监控：产品经理如何建设算法模型监控指标体系？

│ │ │ ├─24-推荐类产品（一）：推荐系统产品经理的工作职责与必备技能

│ │ │ ├─25-推荐类产品（二）：从0打造电商个性化推荐系统产品

│ │ │ ├─26-预测类产品（一）：用户复购意向预测的底层逻辑是什么？

│ │ │ ├─27-预测类产品（二）：从0打造一款预测用户复购意向的产品

│ │ │ ├─28-预测类产品（三）：从0打造一款“大白信用评分产品”

│ │ │ ├─29-自然语言处理产品：从0打造一款智能客服产品

│ │ │ ├─30-AI产品经理，你该如何提升自己的价值？

│ │ │ ├─31-AI产品经理面试，这些问题你必须会答！

│ │ │ ├─开篇词-你好，产品经理！你的未来价值壁垒在哪儿？

│ │ │ ├─春节加餐1-用户增长模型：怎么利用AI技术判断新渠道性价比？

│ │ │ ├─春节加餐2-一次答疑，带你回顾模型评估的所有基础概念

│ │ │ ├─期中周测试题，你做对了吗？

│ │ │ ├─期中答疑-AI产品经理热门问题答疑合集

│ │ │ ├─期末考试-“AI产品经理”100分试卷等你来挑战！

│ │ │ ├─结束语-唯一不变的，就是变化本身！

│ │ │ └─结束语-唯一不变的，就是变化本身！

│ │ ├─128分布式金融架构课

│ │ │ ├─01-业务初探：扫了二维码之后发生了什么？

│ │ │ ├─02-原理解读：如何理解第三方支付的业务逻辑和系统组件？

│ │ │ ├─03-产品大观：不同金融业务都有哪些技术实现要点？

│ │ │ ├─04-领域驱动设计（上）：如何设计金融软件顶层架构？

│ │ │ ├─05-领域驱动设计（下）：如何设计统一的金融业务模型？

│ │ │ ├─06-计算输入的正确性：怎么选择正确时间的数据？

│ │ │ ├─07-计算过程的正确性：如何设计正确的数据处理架构？

│ │ │ ├─08-计算结果的正确性：怎么保证计算结果是正确的？

│ │ │ ├─09-数据传输的质量：金融业务对数据传输有什么要求？

│ │ │ ├─10-数据存储的合理性：金融业务可以不用关系型数据库吗？

│ │ │ ├─11-系统优化：如何让金融系统运行得更快？

│ │ │ ├─12-正确性分级（上）：单机无备份有哪几种不同的一致性？

│ │ │ ├─128分布式金融架构课

│ │ │ ├─13-正确性分级（中）：多机无容灾有哪几种不同的一致性实现？

│ │ │ ├─14-正确性分级（下）：多机有容灾有哪几种不同的一致性？

│ │ │ ├─15-分布式正确性的存在性（上）：什么情况下不存在分布式共识算法？

│ │ │ ├─16-分布式一致性（下）：怎么理解最简单的分布式一致性算法？

│ │ │ ├─17-正确性案例（上）：如何实现分布式的事件溯源架构？

│ │ │ ├─18-正确性案例（中）：常见分布式数据方案的设计原理是什么？

│ │ │ ├─19-正确性案例（下）：如何在运行时进行数据系统的动态分库？

│ │ │ ├─20-容灾（上）如何实现正确的跨机房实时容灾？

│ │ │ ├─21-容灾（下）：如何通过混沌工程提高系统稳定性？

│ │ │ ├─开篇词-如何成为金融级人才？

│ │ │ ├─春节策划第1期-分布式金融系统知识，你掌握了多少？

│ │ │ ├─春节策划第2期-读书如抽丝，为你推荐一些我读过的好书

│ │ │ ├─春节策划第3期-如何运用架构知识解读春运买票和手游案例？

│ │ │ ├─答疑集锦（一）-思考题解析与外汇架构知识拓展

│ │ │ ├─答疑集锦（三）-思考题解析与数据库底层实现

│ │ │ ├─答疑集锦（二）-思考题解析与账务系统优化

│ │ │ ├─结束语-金融之道，与你同行，虽远尤欣

│ │ │ └─结课测试｜这些金融架构的问题，你都掌握了么？

│ │ ├─129代码之丑

│ │ │ ├─01-缺乏业务含义的命名：如何精准命名？

│ │ │ ├─02-乱用英语：站在中国人的视角来看英文命名

│ │ │ ├─03-重复代码：简单需求到处修改，怎么办？

│ │ │ ├─04-长函数：为什么你总是不可避免地写出长函数？

│ │ │ ├─05-大类：如何避免写出难以理解的大类？

│ │ │ ├─06-长参数列表：如何处理不同类型的长参数？

│ │ │ ├─07-滥用控制语句：出现控制结构，多半是错误的提示

│ │ │ ├─08-缺乏封装：如何应对火车代码和基本类型偏执问题？

│ │ │ ├─09-可变的数据：不要让你的代码“失控”

│ │ │ ├─10-变量声明与赋值分离：普通的变量声明，怎么也有坏味道？

│ │ │ ├─11-依赖混乱：你可能还没发现问题，代码就已经无法挽救了

│ │ │ ├─12-不一致的代码：为什么你的代码总被吐槽难懂？

│ │ │ ├─129代码之丑

│ │ │ ├─13-落后的代码风格：使用“新”的语言特性和程序库升级你的代码

│ │ │ ├─14-多久进行一次代码评审最合适？

│ │ │ ├─15-新需求破坏了代码，怎么办？

│ │ │ ├─16-熊节：什么代码应该被重构？

│ │ │ ├─17-课前作业点评：发现“你”代码里的坏味道

│ │ │ ├─开篇词-这一次，我们从“丑”代码出发

│ │ │ ├─结束语-写代码是一件可以一生精进的事

│ │ │ ├─结课测试｜这些代码坏味道的知识你都掌握了吗？

│ │ │ ├─课前热身-这些需求给到你，你会怎么写代码？

│ │ │ └─课前热身-这些需求给到你，你会怎么写代码？

│ │ ├─130体验设计案例课

│ │ │ ├─01-当别人说产品体验不好的时候，他在说什么？

│ │ │ ├─02-交互设计师可以被产品经理替代吗？

│ │ │ ├─03-你画像中的用户是真的还是假的？

│ │ │ ├─04-为什么你的竞品分析看起来像拼接抄袭？

│ │ │ ├─05-你会巧妙利用数据这个神助攻吗？

│ │ │ ├─06-如何给你的体验地图加一个设计导航？

│ │ │ ├─07-如何让你的设计更有温度？

│ │ │ ├─08-怎样搞定一场用户可用性测试？

│ │ │ ├─09-为什么你的设计方案总是通不过？

│ │ │ ├─10-B端设计师如何真正地接近你的用户？

│ │ │ ├─11-设计师的能力水平可以量化吗？

│ │ │ ├─12-如何用量化手段判断需求的优先级？

│ │ │ ├─13-设计量化会把创意扼杀在摇篮里吗？

│ │ │ ├─130体验设计案例课

│ │ │ ├─14-如何用量化的方式讲清设计价值？

│ │ │ ├─15-如何建立设计方案的验证模型？

│ │ │ ├─16-产品体验的评估也可以量化吗？

│ │ │ ├─17-如何轻松应对不同产品阶段的设计量化？

│ │ │ ├─18-怎样用量化的方式帮助设计成长？

│ │ │ ├─19-什么样的设计流程是最高效的？

│ │ │ ├─20-怎样利用设计中台让设计师不加班？

│ │ │ ├─21-如何打破设计师的成长天花板？

│ │ │ ├─22-体验设计如何从基础学科中借力？

│ │ │ ├─23-精力管理：你知道设计师的7-2-1黄金比例吗？

│ │ │ ├─24-设计总监到底还要不要画图？

│ │ │ ├─25-想进BAT等大厂，你要做好哪些准备？

│ │ │ ├─加餐-大厂的围城：你想进去，我想逃离

│ │ │ ├─开篇词-不解决实际问题的体验设计都是耍流氓

│ │ │ ├─春节加餐1-炒炒的2020：成长是不变的课题

│ │ │ ├─春节加餐2-用户故事：设计也要学以致用

│ │ │ ├─春节加餐3-书单分享：阅读是一种人生的体验

│ │ │ ├─结束语-你我共同成长，早日财富自由

│ │ │ └─这些用户体验设计的知识你都掌握了吗？

│ │ ├─131手把手教你玩音乐

│ │ │ ├─01｜基本操作：5分钟制作一段专属手机铃声

│ │ │ ├─02｜吉他&贝斯：跳过枯燥的乐器练习，让你成为吉他手

│ │ │ ├─03｜键盘：那么多炫酷的电子音色都是怎么做出来的？

│ │ │ ├─04｜弦乐&民乐：你以为很土，其实很酷

│ │ │ ├─05｜鼓：流行音乐里最重要的声部

│ │ │ ├─06｜和弦条与弹唱：你这么多年的生日歌可能都没唱对

│ │ │ ├─07｜学MIDI，像打字一样快速记录灵感

│ │ │ ├─08-实时循环乐段（上），像拼乐高一样做音乐

│ │ │ ├─09-实时循环乐段（下），一节课让你变身DJ

│ │ │ ├─10-百万混音师是怎样炼成的？帮你迈出第一步

│ │ │ ├─11｜技巧混搭，让你的创意快速实现

│ │ │ ├─12-外接设备，把你的库乐队变成移动录音棚

│ │ │ ├─13-功能串联：从无到有，做出你人生的第一首歌

│ │ │ ├─131手把手教你玩音乐

│ │ │ ├─14-乐队：2台iPhone就能实现乐队表演？

│ │ │ ├─开篇词｜听了那么多首歌，不如来动手“玩”音乐

│ │ │ ├─用户故事1｜不止学会了库乐队，还拓展了舒适边界

│ │ │ ├─用户故事2｜在库乐队中，你就是最好的架构师

│ │ │ ├─知识拓展1｜十九个乐理名词解释，让你把音乐玩得更开心

│ │ │ ├─知识拓展2｜八个问题，解答你学习中遇到的疑惑

│ │ │ ├─结束语｜让音乐陪伴你的生活

│ │ │ ├─结课测试题｜这些相关音乐知识你都掌握了吗？

│ │ │ ├─编辑手记｜音乐让生活更好玩儿

│ │ │ └─编辑手记｜音乐让生活更好玩儿

│ │ ├─132etcd实战课

│ │ │ ├─01-etcd的前世今生：为什么Kubernetes使用etcd？

│ │ │ ├─02-基础架构：etcd一个读请求是如何执行的？

│ │ │ ├─03-基础架构：etcd一个写请求是如何执行的？

│ │ │ ├─04-Raft协议：etcd如何实现高可用、数据强一致的？

│ │ │ ├─05-鉴权：如何保护你的数据安全？

│ │ │ ├─06-租约：如何检测你的客户端存活？

│ │ │ ├─07-MVCC：如何实现多版本并发控制？

│ │ │ ├─08-Watch：如何高效获取数据变化通知？

│ │ │ ├─09-事务：如何安全地实现多key操作？

│ │ │ ├─10-boltdb：如何持久化存储你的key-value数据？

│ │ │ ├─11-压缩：如何回收旧版本数据？

│ │ │ ├─12-一致性：为什么基于Raft实现的etcd还会出现数据不一致？

│ │ │ ├─13-db大小：为什么etcd社区建议db大小不超过8G？

│ │ │ ├─132etcd实战课

│ │ │ ├─14-延时：为什么你的etcd请求会出现超时？

│ │ │ ├─15-内存：为什么你的etcd内存占用那么高？

│ │ │ ├─16-性能及稳定性（上）：如何优化及扩展etcd性能？

│ │ │ ├─17-性能及稳定性（下）：如何优化及扩展etcd性能

│ │ │ ├─18-实战：如何基于Raft从0到1构建一个支持多存储引擎分布式KV服务？

│ │ │ ├─19-Kubernetes基础应用：创建一个Pod背后etcd发生了什么？

│ │ │ ├─20-Kubernetes高级应用：如何优化业务场景使etcd能支撑上万节点集群？

│ │ │ ├─21-分布式锁：为什么基于etcd实现分布式锁比Redis锁更安全？

│ │ │ ├─22-配置及服务发现：解析etcd在APIGateway开源项目中应用

│ │ │ ├─23-选型：etcd-ZooKeeper-Consul等我们该如何选择？

│ │ │ ├─24-运维：如何构建高可靠的etcd集群运维体系？

│ │ │ ├─开篇词｜为什么你要学习etcd

│ │ │ ├─特别放送-成员变更：为什么集群看起来正常，移除节点却会失败呢？

│ │ │ ├─结束语-搞懂etcd，掌握通往分布式存储系统之门的钥匙

│ │ │ └─结课测试题｜这些相关etcd知识你都掌握了吗？

│ │ ├─133恋爱必修课

│ │ │ ├─01｜是终点也是起点：你的恋爱目标是什么？

│ │ │ ├─02-拒绝焦虑状态：TA到底爱我吗？

│ │ │ ├─03｜冒犯有时是必要的：如何开启一段亲密关系？

│ │ │ ├─04-亲密关系的本质是分享：如何把握暧昧的窗口期？

│ │ │ ├─05-创造型与消费型活动：两个人在一起没事干怎么办？

│ │ │ ├─06-小心看上去平平无奇的陷阱：如何防范高级渣？

│ │ │ ├─07-无法回避的现实问题：“亲对象”也要明算账？

│ │ │ ├─08-七年未必痒：如何营造亲密关系的新鲜感？

│ │ │ ├─09-相亲与恋爱套路不一样：相亲有哪些需要注意的？

│ │ │ ├─10-恋爱成功不是只有结婚一条路：分手是我错了吗？

│ │ │ ├─11-独身主义也不赖：选择不结婚究竟是选择了什么？

│ │ │ ├─12-姐弟恋也很可爱：姐弟恋有什么好处和注意事项？

│ │ │ ├─13-千古难题真难办：如何跨越家庭背景的差异？

│ │ │ ├─133恋爱必修课

│ │ │ ├─开篇词-爱与被爱，是人一生最值得学习的能力

│ │ │ ├─春节加餐1-公主，快放开那只巨龙！

│ │ │ ├─春节加餐2-恋爱课答疑集锦：人潮之中彼此相视而窃喜

│ │ │ ├─春节加餐3-恋爱课直播集锦：恋爱这件小事儿

│ │ │ ├─结束语-但行好事，莫问前程

│ │ │ └─结束语-但行好事，莫问前程

│ │ ├─134跟着高手学复盘

│ │ │ ├─01-CLAP模型：一个优秀的复盘模型是什么样的？

│ │ │ ├─02-OPTM框架：怎么使用CLAP模型？

│ │ │ ├─03-教练技术：怎么做复盘才能化解冲突？

│ │ │ ├─04-制度和文化：怎么营造复盘环境？

│ │ │ ├─05-三角法：怎么组建复盘团队？

│ │ │ ├─06-MECE原则：怎么准备复盘资料？

│ │ │ ├─07-五步法：如何召开一次高效的复盘会议？

│ │ │ ├─08-事实比较：如何快速比较目标与结果？

│ │ │ ├─09-分析原因：梳理逻辑时怎样找到切入点？

│ │ │ ├─10-洞察规律：怎样更新认知才能找准发力点？

│ │ │ ├─11-OKR：怎样根据复盘结论制定计划？

│ │ │ ├─12-DoubleCheck：怎么检查评估一次复盘的效果？

│ │ │ ├─13-案例导学：我是怎么帮助企业做复盘的？

│ │ │ ├─134跟着高手学复盘

│ │ │ ├─14-战略升级：5年增长100倍的跨境电商做对了什么？

│ │ │ ├─15-业务关键点：改进一个点业绩增长50%？

│ │ │ ├─16-组织结构设计：变动一个职位，就能带来100万-月的增量吗？

│ │ │ ├─17-高效赋能：怎么建立流程才能把人效提升3倍？

│ │ │ ├─18-人才培养：怎么把人才转化成实际生产力？

│ │ │ ├─19-预算制定：人头和财务预算到底怎么定？

│ │ │ ├─开篇词-为什么每个人都应该学会复盘？

│ │ │ ├─春节荐书（一）-《原则》：在不确定中找到确定

│ │ │ ├─春节荐书（二）-《人类简史》：故事的力量

│ │ │ ├─结束语-复盘，见天地见众生见自己

│ │ │ └─结课测试题｜这些关于复盘的知识你都掌握了吗？

│ │ ├─135Python自动化办公实战课

│ │ │ ├─01-拆分与合并：如何快速地批量处理内容相似的Excel？

│ │ │ ├─02｜善用Python扩展库：如何批量合并多个文档？

│ │ │ ├─03｜图片转文字：如何提高识别准确率？

│ │ │ ├─04-函数与字典：如何实现多次替换

│ │ │ ├─05-图像处理库：如何实现长图拼接？

│ │ │ ├─06-jieba分词：如何基于感情色彩进行单词数量统计？

│ │ │ ├─07｜快速读写文件：如何实现跨文件的字数统计？

│ │ │ ├─08｜正则表达式：如何提高搜索内容的精确度？

│ │ │ ├─09｜扩展搜索：如何快速找到想要的文件？

│ │ │ ├─10｜按指定顺序给词语排序，提高查找效率

│ │ │ ├─11｜通过程序并行计算，避免CPU资源浪费

│ │ │ ├─12｜文本处理函数：三招解决数据对齐问题

│ │ │ ├─135Python自动化办公实战课

│ │ │ ├─13｜Excel插件：如何扩展Excel的基本功能？

│ │ │ ├─14｜VBA脚本编程：如何扩展Excel，实现文件的批量打印？

│ │ │ ├─15｜PowerShell脚本：如何实现文件批量处理的自动化？

│ │ │ ├─16｜循环与文件目录管理：如何实现文件的批量重命名？

│ │ │ ├─17｜不同操作系统下，如何通过网络同步文件？

│ │ │ ├─18｜http库：如何批量下载在线内容，解放鼠标（上）？

│ │ │ ├─19｜http库：如何批量下载在线内容，解放鼠标（下）？

│ │ │ ├─20｜不同文件混在一起，怎么快速分类？

│ │ │ ├─21｜SQLite文本数据库：如何进行数据管理（上）？

│ │ │ ├─22｜SQLite文本数据库：如何进行数据管理（下）？

│ │ │ ├─23｜怎么用数据透视表更直观地展示汇报成果？

│ │ │ ├─24｜条形、饼状、柱状图最适合用在什么场景下？

│ │ │ ├─25｜图表库：想要生成动态图表，用Echarts就够了

│ │ │ ├─26｜快速提取图片中的色块，模仿一张大师的照片

│ │ │ ├─27｜zipfile压缩库：如何给数据压缩&加密备份？

│ │ │ ├─28｜Celery库：让计算机定时执行任务，解放人力

│ │ │ ├─29｜网络和邮件库：定时收发邮件，减少手动操作

│ │ │ ├─30｜怎么快速把任意文件格式转成PDF，并批量加水印？

│ │ │ ├─导读｜入门Python的必备知识

│ │ │ ├─开篇词-重复工作这么多，怎样才能提高工作效率？

│ │ │ ├─春节特别放送1｜实体水果店转线上销售的数据统计问题

│ │ │ ├─春节特别放送2｜用自顶至底的思路解决数据统计问题

│ │ │ ├─春节特别放送3｜揭晓项目作业的答案

│ │ │ ├─结束语｜和我一起成为10X效率职场人

│ │ │ ├─结课测试题｜这些Python自动化办公的知识你都掌握了吗？

│ │ │ └─结课测试题｜这些Python自动化办公的知识你都掌握了吗？

│ │ ├─136基于人因的用户体验设计课

│ │ │ ├─01-什么是用户体验设计？

│ │ │ ├─02-怎样做到为用户而设计？

│ │ │ ├─03-重新认识感觉：眼见不一定为实

│ │ │ ├─04-重新认识视觉（上）：色彩有重量吗？

│ │ │ ├─05-重新认识视觉（中）：构图的力量

│ │ │ ├─06-重新认识视觉（下）：为何橱窗越空价格越贵？

│ │ │ ├─07-重新认识听觉：你的自然音效是否足够自然？

│ │ │ ├─08-重新认识触觉：为什么苹果放弃了3DTouch？

│ │ │ ├─09-视听触的协同性：从人感知世界的时间延迟去理解协同

│ │ │ ├─10-重新认识记忆和注意力：你的记性比你想象中的还要糟糕

│ │ │ ├─11-重新认识情感：愉悦性设计

│ │ │ ├─12-理解心流：如何达到专注的沉浸体验？

│ │ │ ├─13-认识人的思维缺陷：不理性的我们

│ │ │ ├─136基于人因的用户体验设计课

│ │ │ ├─14-理解触屏交互：方寸触屏大乾坤

│ │ │ ├─15-理解语音交互：手机和你聊天的正确姿势

│ │ │ ├─16-隐私与个性化：不要骗我

│ │ │ ├─17｜人的社会属性：购物节背后的玄机

│ │ │ ├─18-本地和全球化：你的偏好恰恰是他的禁忌

│ │ │ ├─19｜无障碍设计：人性之光

│ │ │ ├─20｜基于人因的动效设计：动效背后的物理认知

│ │ │ ├─21｜基于人因的美学设计：数学与心理学之美

│ │ │ ├─22｜正确运用智能交互：谁才是主人？

│ │ │ ├─23｜智能汽车交互：安全为王

│ │ │ ├─24｜新手机形态对触屏交互影响：折叠屏的创新体验

│ │ │ ├─25｜语言学在设计中运用：命名也有心理学

│ │ │ ├─26｜深色模式设计：深色也能有层次感

│ │ │ ├─27｜多模态交互：替代触屏的交互新可能？

│ │ │ ├─28｜空间交互：虚幻与现实

│ │ │ ├─29｜普适计算交互：如何和海量的设备进行交互？

│ │ │ ├─开篇词-你为什么要学人因学？

│ │ │ ├─期末测试｜来赴一场满分之约！

│ │ │ ├─用户故事｜CC：了解自己，了解用户

│ │ │ ├─用户故事｜JT：设计为生活赋能

│ │ │ ├─结束语｜重新认识你自己

│ │ │ └─结束语｜重新认识你自己

│ │ ├─137打造爆款短视频

│ │ │ ├─01-爆款短视频的底层逻辑：用心拍的短视频为啥没人看？

│ │ │ ├─02-爆款短视频的底层逻辑：如何轻松打造自我特色？

│ │ │ ├─03-精益创业法：如何快速跨过从0到1这道坎？

│ │ │ ├─04-SWOT法：这么明显的个人优势你为啥就是看不到？

│ │ │ ├─05-效用函数法：如何用量化的方式进行高效创作？

│ │ │ ├─06-二次创新实验法：如何打造个人的差异化定位？

│ │ │ ├─07-平台定位：如何选择最适合自己的创作平台？

│ │ │ ├─08-如何快速找到各大短视频平台的正确切入点？

│ │ │ ├─09-选题（上）：如何利用思考清单找到合适选题？

│ │ │ ├─10-选题（下）：如何为不同的内容定制合适选题？

│ │ │ ├─11-优劣分析法：如何快速筛选适合创作的视频素材？

│ │ │ ├─12-标题（上）：如何利用微创新巧妙找到爆款标题？

│ │ │ ├─13-标题（下）：如何用对号入座的方式抓住标题亮点？

│ │ │ ├─137打造爆款短视频

│ │ │ ├─14-视频封面（上）：如何快速抓住用户注意力？

│ │ │ ├─15-视频封面（下）：如何传递最有价值的信息？

│ │ │ ├─16-视频剪辑：如何轻松掌握视频化剪辑的三大公式？

│ │ │ ├─17-效果反馈法：剪辑很容易，为什么你却一直学不会？

│ │ │ ├─18-剪辑对比（上）：如何避开常见的短视频剪辑陷阱？

│ │ │ ├─19-剪辑对比（下）：如何利用剪辑技巧提升视频质量？

│ │ │ ├─20-拉片法：用电影创作的方式学习爆款短视频运营技巧

│ │ │ ├─21-用户留存率：为什么粉丝很多但忠实拥趸却很少？

│ │ │ ├─22-点赞率（上）：如何有效提升短视频的点赞量？

│ │ │ ├─23-点赞率（下）：三种方法轻松提升用户对内容的认可度

│ │ │ ├─24-上瘾机制：为什么视频观看量很高却没人留言？

│ │ │ ├─25-避坑指南：为什么很多短视频账号中途做不下去了？

│ │ │ ├─26-如何找到适合自己的短视频变现模式？

│ │ │ ├─27-多元化变现：如何明确不同创作阶段的变现任务？

│ │ │ ├─28-多内容变现：不同内容的主打变现模式是什么？

│ │ │ ├─开篇词-短视频时代下，怎么把握好变现风口？(1)

│ │ │ ├─开篇词-短视频时代下，怎么把握好变现风口？

│ │ │ ├─结束语-一切成大事者，都是终身学习者

│ │ │ ├─结课测试-一套习题，测出你的掌握程度

│ │ ├─138MySQL必知必会

│ │ │ ├─01-存储：一个完整的数据存储过程是怎样的？

│ │ │ ├─02-字段：这么多字段类型，该怎么定义？

│ │ │ ├─03-表：怎么创建和修改数据表？

│ │ │ ├─04-增删改查：如何操作表中的数据？

│ │ │ ├─05-主键：如何正确设置主键？

│ │ │ ├─06-外键和连接：如何做关联查询？

│ │ │ ├─07-条件语句：WHERE与HAVING有什么不同

│ │ │ ├─08-聚合函数：怎么高效地进行分组统计？

│ │ │ ├─09-时间函数：时间类数据，MySQL是怎么处理的？

│ │ │ ├─10-如何进行数学计算、字符串处理和条件判断？

│ │ │ ├─11-索引：怎么提高查询的速度？

│ │ │ ├─12-事务：怎么确保关联操作正确执行？

│ │ │ ├─13-临时表：复杂查询，如何保存中间结果？

│ │ │ ├─138MySQL必知必会

│ │ │ ├─14-视图：如何简化查询？

│ │ │ ├─15-存储过程：如何提高程序的性能和安全性？

│ │ │ ├─16-游标：对于数据集中的记录，该怎么逐条处理？

│ │ │ ├─17-触发器：如何让数据修改自动触发关联操作，确保数据一致性？

│ │ │ ├─18-权限管理：如何控制数据库访问，消除安全隐患？

│ │ │ ├─19-日志（上）：系统出现问题，如何及时发现？

│ │ │ ├─20-日志（下）：系统故障，如何恢复数据？

│ │ │ ├─21-数据备份：异常情况下，如何确保数据安全？

│ │ │ ├─22-范式：如何消除冗余，实现高效存取？

│ │ │ ├─23-ER模型：如何理清数据库设计思路？

│ │ │ ├─24-查询有点慢，语句该如何写？

│ │ │ ├─25-表太大了，如何设计才能提高性能？

│ │ │ ├─26-如何充分利用系统资源？

│ │ │ ├─27-手把手带你设计一个完整的连锁超市信息系统数据库（上）

│ │ │ ├─28-手把手带你设计一个完整的连锁超市信息系统数据库（下）

│ │ │ ├─开篇词-在实战中学习，是解锁MySQL技能的最佳方法

│ │ │ ├─期末测试-一套习题，测出你的掌握程度

│ │ │ ├─特别发送（一）-经典面试题讲解第一弹

│ │ │ ├─特别放送（三）-MySQL8都有哪些新特征？

│ │ │ ├─特别放送（二）-经典面试题讲解第二弹

│ │ │ ├─特别放送（四）-位置信息：如何进行空间定位？

│ │ │ ├─环境准备-带你安装MySQL和图形化管理工具Workbench

│ │ │ ├─结束语-不盲从于群体思维，走一条适合自己的路

│ │ │ └─结束语-不盲从于群体思维，走一条适合自己的路

│ │ ├─139流程型组织15讲

│ │ │ ├─01-拥抱客户还是老板？老板导向型组织的弊端

│ │ │ ├─02-打破企业两大根本问题，聚焦客户价值创造

│ │ │ ├─03-颠覆传统流程定义，真正实现以流程创造价值

│ │ │ ├─04-实现以客户为中心的核心，用流程重新定义职位

│ │ │ ├─05-流程变革实战案例一：研发流程的重整要点

│ │ │ ├─06-流程变革实战案例二：销售流程的重整要点

│ │ │ ├─07-流程变革实战案例三：战略流程的重整要点

│ │ │ ├─08-谁来驱动变革：让变革影响企业的每个人

│ │ │ ├─09-BPR项目运作的四个阶段：BOD模型的应用

│ │ │ ├─10-流程落地九步法：通过流程管理流程

│ │ │ ├─11-以流程驱动组织变革：实现多方共赢的局面

│ │ │ ├─12-职位的再造升级：实现减员增效涨薪的方法

│ │ │ ├─13-人力资源管理：干部如何转型

│ │ │ ├─139流程型组织15讲

│ │ │ ├─14-人力资源管理：关键人才成长

│ │ │ ├─15-人力资源管理：以奋斗者为本

│ │ │ ├─开篇词-成为一家“笨公司”

│ │ │ ├─测一测-流程型组织的这些概念、思想，你都吃透了吗？

│ │ │ ├─测一测-这些变革的方法论，你都消化了吗？

│ │ │ ├─结束语-企业管理的真谛：以客户为中心的流程型变革

│ │ │ └─结束语-企业管理的真谛：以客户为中心的流程型变革

│ │ ├─140Spark性能调优实战

│ │ │ ├─01-性能调优的必要性：Spark本身就很快，为啥还需要我调优？

│ │ │ ├─02-性能调优的本质：调优的手段五花八门，该从哪里入手？

│ │ │ ├─03-RDD：为什么你必须要理解弹性分布式数据集？

│ │ │ ├─04-DAG与流水线：到底啥叫“内存计算”？

│ │ │ ├─05-调度系统：“数据不动代码动”到底是什么意思？

│ │ │ ├─06-存储系统：空间换时间，还是时间换空间？

│ │ │ ├─07-内存管理基础：Spark如何高效利用有限的内存空间？

│ │ │ ├─08-应用开发三原则：如何拓展自己的开发边界？

│ │ │ ├─09-调优一筹莫展，配置项速查手册让你事半功倍！（上）

│ │ │ ├─10-调优一筹莫展，配置项速查手册让你事半功倍！（下）

│ │ │ ├─11-为什么说Shuffle是一时无两的性能杀手？

│ │ │ ├─12-广播变量（一）：克制Shuffle，如何一招制胜！

│ │ │ ├─13-广播变量（二）：如何让SparkSQL选择BroadcastJoins？

│ │ │ ├─14-CPU视角：如何高效地利用CPU？

│ │ │ ├─140Spark性能调优实战

│ │ │ ├─15-内存视角（一）：如何最大化内存的使用效率？

│ │ │ ├─16-内存视角（二）：如何有效避免Cache滥用？

│ │ │ ├─17-内存视角（三）：OOM都是谁的锅？怎么破？

│ │ │ ├─18-磁盘视角：如果内存无限大，磁盘还有用武之地吗？

│ │ │ ├─19-网络视角：如何有效降低网络开销？

│ │ │ ├─20-RDD和DataFrame：既生瑜，何生亮？

│ │ │ ├─21-Catalyst逻辑计划：你的SQL语句是怎么被优化的？（上）

│ │ │ ├─22-Catalyst物理计划：你的SQL语句是怎么被优化的（下）？

│ │ │ ├─23-钨丝计划：Tungsten给开发者带来了哪些福报？

│ │ │ ├─24-Spark3

│ │ │ ├─25-Spark3

│ │ │ ├─26-JoinHints指南：不同场景下，如何选择Join策略？

│ │ │ ├─27-大表Join小表：广播变量容不下小表怎么办？

│ │ │ ├─28-大表Join大表（一）：什么是“分而治之”的调优思路？

│ │ │ ├─29-大表Join大表（二）：什么是负隅顽抗的调优思路？

│ │ │ ├─30｜应用开发：北京市小客车（汽油车）摇号趋势分析

│ │ │ ├─31-性能调优：手把手带你提升应用的执行性能

│ │ │ ├─SparkUI（上）-深入解读Spark作业的“体检报告”

│ │ │ ├─SparkUI（下）：深入解读Spark作业的“体检报告”

│ │ │ ├─开篇词-Spark性能调优，你该掌握这些“套路”

│ │ │ ├─期末考试-“Spark性能调优”100分试卷等你来挑战！

│ │ │ ├─结束语-在时间面前，做一个笃定学习的人

│ │ │ └─结束语-在时间面前，做一个笃定学习的人

│ │ ├─141高楼的性能工程实战课

│ │ │ ├─01-性能工程：为什么很多性能测试人员无法对性能结果负责？

│ │ │ ├─02-关键概念：性能指标和场景的确定

│ │ │ ├─03-核心分析逻辑：所有的性能分析，靠这七步都能搞定

│ │ │ ├─04-如何构建性能分析决策树和查找瓶颈证据链？

│ │ │ ├─05-性能方案：你的方案是否还停留在形式上？

│ │ │ ├─06-如何抽取出符合真实业务场景的业务模型？

│ │ │ ├─07-性能场景的数据到底应该做成什么样子？

│ │ │ ├─08-并发、在线和TPS到底是什么关系？

│ │ │ ├─09-如何设计全局和定向监控策略？

│ │ │ ├─10-设计基准场景需要注意哪些关键点？

│ │ │ ├─11-打开首页之一：一个案例，带你搞懂基础硬件设施的性能问题

│ │ │ ├─12-打开首页之二：如何平衡利用硬件资源？

│ │ │ ├─13-用户登录：怎么判断线程中的Block原因？

│ │ │ ├─14-用户信息查询：如何解决网络软中断瓶颈问题？

│ │ │ ├─141高楼的性能工程实战课

│ │ │ ├─15-查询商品：资源不足有哪些性能表现？

│ │ │ ├─16-商品加入购物车：SQL优化和压力工具中的参数分析

│ │ │ ├─17-查询购物车：为什么铺底参数一定要符合真实业务特性？

│ │ │ ├─18-购物车信息确定订单：为什么动态参数化逻辑非常重要？

│ │ │ ├─19-生成订单信息之一：应用JDBC池优化和内存溢出分析

│ │ │ ├─20-生成订单信息之二：业务逻辑复杂，怎么做性能优化？

│ │ │ ├─21-支付前查询订单列表：如何分析优化一个固定的技术组件？

│ │ │ ├─22-支付订单信息：如何高效解决for循环产生的内存溢出？

│ │ │ ├─23-决定容量场景成败的关键因素有哪些？

│ │ │ ├─24-容量场景之一：索引优化和Kubernetes资源分配不均衡怎么办？

│ │ │ ├─25-容量场景之二：缓存对性能会有什么样的影响？

│ │ │ ├─26-稳定性场景之一：怎样搞定业务积累量产生的瓶颈问题？

│ │ │ ├─27-稳定性场景之二：怎样搞定磁盘不足产生的瓶颈问题？

│ │ │ ├─28-如何确定异常场景的范围和设计逻辑？

│ │ │ ├─29-异常场景：如何模拟不同组件层级的异常？

│ │ │ ├─30-如何确定生产系统配置？

│ │ │ ├─31-怎么写出有价值的性能报告？

│ │ │ ├─一套习题，测出你的掌握程度

│ │ │ ├─开篇词-打破四大认知局限，进阶高级性能工程师

│ │ │ ├─我们这个课程的系统是怎么搭建起来的？

│ │ │ ├─结束语-做真正的性能项目

│ │ │ └─结束语-做真正的性能项目

│ │ ├─142技术面试官识人手册

│ │ │ ├─01-评估体系：公司和团队到底需要怎样的技术人才？

│ │ │ ├─02-制定计划：好的计划是成功的一半

│ │ │ ├─03-问题设计（上）：三大原则理清面试考察方向

│ │ │ ├─04-问题设计（下）：五个技巧助攻技术问题设计

│ │ │ ├─05-流程把控：控好流程，让面试进程高效有温度

│ │ │ ├─06-算法和数据结构考察：怎样有层次地驾驭算法考察？

│ │ │ ├─07-系统设计能力考察：系统设计内功到底怎么考？

│ │ │ ├─08-其它技能考察：见微知著，不可忽略的其它考察点

│ │ │ ├─09-决策会准备：怎样全面收集事实，有效提炼数据？

│ │ │ ├─10-决策会开展（上）：怎样引导争辩，达成共识？

│ │ │ ├─11-决策会开展（下）：怎样确保评估全面且有深度？

│ │ │ ├─12-线上面试：隔屏对话，交流依然畅通

│ │ │ ├─13-简历识人：洞悉简历背后信息，动态调节面试策略

│ │ │ ├─142技术面试官识人手册

│ │ │ ├─开篇词-世事洞明皆学问，人情练达即文章：小面试，大道理

│ │ │ ├─答疑课堂01：面试计划篇热点问题解答

│ │ │ ├─答疑课堂02：面试实践篇热点问题解答

│ │ │ ├─答疑课堂03：面试决策篇热点问题解答

│ │ │ ├─结束语-操千曲而后晓声，观千剑而后识器

│ │ │ ├─结课测试｜这些面试问题，你都掌握了么？

│ │ │ └─结课测试｜这些面试问题，你都掌握了么？

│ │ ├─143说透数字化转型

│ │ │ ├─01-历史思维：什么是数字时代和数字化转型？

│ │ │ ├─02-生态思维：企业怎么找准自己的定位？

│ │ │ ├─03-架构思维：数字化转型如何落地？

│ │ │ ├─04-破除误解：企业架构真的做不做都行吗？

│ │ │ ├─05-业技融合：如何打破技术和业务的壁垒？

│ │ │ ├─06-玩转业架：怎么设计业务架构？

│ │ │ ├─07-转型路径：数字化转型该从何做起？

│ │ │ ├─08-战略先行：怎么制定数字化战略？

│ │ │ ├─09-转型痛点（上）：转型中都有哪些痛点问题？如何识别？

│ │ │ ├─10-转型痛点（下）：怎么解决转型中的痛点问题？

│ │ │ ├─11-外部资源：实现数字化需要哪些外部支持？

│ │ │ ├─12-价值链：如何使用价值链进行能力分解？

│ │ │ ├─13-技术展望：转型必备的关键技术有哪些？

│ │ │ ├─14-架构规划：如何用企业架构连通技术和业务？

│ │ │ ├─143说透数字化转型

│ │ │ ├─15-分段演进：数字化转型需要经历哪些阶段？

│ │ │ ├─16-人与工具：如何培养数字化人才和建立企业架构方法论？

│ │ │ ├─开篇词-数字化转型箭在弦上，如何抓住机遇？

│ │ │ ├─结束语-被时代挡在大门外的，往往是对变化视而不见的人

│ │ │ └─结束语-被时代挡在大门外的，往往是对变化视而不见的人

│ │ ├─144Spring编程常见错误50例

│ │ │ ├─01｜SpringBean定义常见错误

│ │ │ ├─02｜SpringBean依赖注入常见错误（上）

│ │ │ ├─03｜SpringBean依赖注入常见错误（下）

│ │ │ ├─04｜SpringBean生命周期常见错误

│ │ │ ├─05｜SpringAOP常见错误（上）

│ │ │ ├─06｜SpringAOP常见错误（下）

│ │ │ ├─07｜Spring事件常见错误

│ │ │ ├─08｜答疑现场：SpringCore篇思考题合集

│ │ │ ├─09｜SpringWebURL解析常见错误

│ │ │ ├─10-SpringWebHeader解析常见错误

│ │ │ ├─11-SpringWebBody转化常见错误

│ │ │ ├─12｜SpringWeb参数验证常见错误

│ │ │ ├─13-SpringWeb过滤器使用常见错误（上）

│ │ │ ├─14-SpringWeb过滤器使用常见错误（下）

│ │ │ ├─144Spring编程常见错误50例

│ │ │ ├─15-SpringSecurity常见错误

│ │ │ ├─16｜SpringException常见错误

│ │ │ ├─17｜答疑现场：SpringWeb篇思考题合集

│ │ │ ├─18-SpringData常见错误

│ │ │ ├─19-Spring事务常见错误（上）

│ │ │ ├─20-Spring事务常见错误（下）

│ │ │ ├─21-SpringRestTemplate常见错误

│ │ │ ├─22-SpringTest常见错误

│ │ │ ├─23｜答疑现场：Spring补充篇思考题合集

│ │ │ ├─导读｜5分钟轻松了解Spring基础知识

│ │ │ ├─导读｜5分钟轻松了解一个HTTP请求的处理过程

│ │ │ ├─开篇词｜贴心“保姆”Spring罢工了怎么办？

│ │ │ ├─期末测试｜来赴一场100分之约！

│ │ │ ├─知识回顾-系统梳理Spring编程错误根源

│ │ │ ├─结束语｜问题总比解决办法多

│ │ │ └─结束语｜问题总比解决办法多

│ │ ├─145操作系统实战45讲

│ │ │ ├─01-程序的运行过程：从代码到机器运行

│ │ │ ├─02-几行汇编几行C：实现一个最简单的内核

│ │ │ ├─03-黑盒之中有什么：内核结构与设计

│ │ │ ├─04-震撼的Linux全景图：业界成熟的内核架构长什么样？

│ │ │ ├─05-CPU工作模式：执行程序的三种模式

│ │ │ ├─06-虚幻与真实：程序中的地址如何转换？

│ │ │ ├─07-Cache与内存：程序放在哪儿？

│ │ │ ├─08-锁：并发操作中，解决数据同步的四种方法

│ │ │ ├─09-瞧一瞧Linux：Linux的自旋锁和信号量如何实现？

│ │ │ ├─10-设置工作模式与环境（上）：建立计算机

│ │ │ ├─11-设置工作模式与环境（中）：建造二级引导器

│ │ │ ├─12-设置工作模式与环境（下）：探查和收集信息

│ │ │ ├─13-第一个C函数：如何实现板级初始化？

│ │ │ ├─14-Linux初始化（上）：GRUB与vmlinuz的结构

│ │ │ ├─145操作系统实战45讲

│ │ │ ├─15-Linux初始化（下）：从start到第一个进程

│ │ │ ├─16-划分土地（上）：如何划分与组织内存？

│ │ │ ├─17-划分土地（中）：如何实现内存页面初始化？

│ │ │ ├─18-划分土地（下）：如何实现内存页的分配与释放？

│ │ │ ├─19-土地不能浪费：如何管理内存对象？

│ │ │ ├─20-土地需求扩大与保障：如何表示虚拟内存？

│ │ │ ├─21-土地需求扩大与保障：如何分配和释放虚拟内存？

│ │ │ ├─22-瞧一瞧Linux：伙伴系统如何分配内存？

│ │ │ ├─23-瞧一瞧Linux：SLAB如何分配内存？

│ │ │ ├─24-活动的描述：到底什么是进程？

│ │ │ ├─25-多个活动要安排（上）：多进程如何调度？

│ │ │ ├─26-多个活动要安排（下）：如何实现进程的等待与唤醒机制？

│ │ │ ├─27-瞧一瞧Linux：Linux如何实现进程与进程调度

│ │ │ ├─28-部门分类：如何表示设备类型与设备驱动？

│ │ │ ├─29-部门建立：如何在内核中注册设备？

│ │ │ ├─30-部门响应：设备如何处理内核I-O包？

│ │ │ ├─31-瞧一瞧Linux：如何获取所有设备信息？

│ │ │ ├─32-仓库结构：如何组织文件

│ │ │ ├─33-仓库划分：文件系统的格式化操作

│ │ │ ├─34-仓库管理：如何实现文件的六大基本操作？

│ │ │ ├─35-瞧一瞧Linux：虚拟文件系统如何管理文件？

│ │ │ ├─36-从URL到网卡：如何全局观察网络数据流动？

│ │ │ ├─37-从内核到应用：网络数据在内核中如何流转

│ │ │ ├─38-从单排到团战：详解操作系统的宏观网络架构

│ │ │ ├─39-瞧一瞧Linux：详解socket实现与网络编程接口

│ │ │ ├─40-瞧一瞧Linux：详解socket的接口实现

│ │ │ ├─41-服务接口：如何搭建沟通桥梁？

│ │ │ ├─42-瞧一瞧Linux：如何实现系统API？

│ │ │ ├─43-虚拟机内核：KVM是什么？

│ │ │ ├─44-容器：如何理解容器的实现机制？

│ │ │ ├─45-ARM新宠：苹果的M1芯片因何而快？

│ │ │ ├─46-AArch64体系：ARM最新编程架构模型剖析

│ │ │ ├─参考答案-对答案，是再次学习的一个机会

│ │ │ ├─大咖助场｜以无法为有法，以无限为有限

│ │ │ ├─开篇词-为什么要学写一个操作系统？

│ │ │ ├─用户故事-yiyang：我的上机实验“爬坑指南”

│ │ │ ├─用户故事-成为面向“知识库”的工程师

│ │ │ ├─用户故事-技术人如何做选择，路才越走越宽？

│ │ │ ├─用户故事-操作系统发烧友：看不懂？因为你没动手

│ │ │ ├─用户故事-用好动态调试，助力课程学习

│ │ │ ├─用户故事｜艾同学：路虽远，行则将至

│ │ │ ├─结束语-生活可以一地鸡毛，但操作系统却是心中的光

│ │ │ ├─结课测试｜这些操作系统的问题，你都掌握了么？

│ │ │ ├─编辑手记-升级认知，迭代自己的操作系统

│ │ │ └─编辑手记-升级认知，迭代自己的操作系统

│ │ ├─146容量保障核心技术与实战

│ │ │ ├─01-容量保障的目标：容量保障的目标是什么？该如何度量？

│ │ │ ├─02-容量测试与验证：怎样科学实施容量测试？

│ │ │ ├─03-容量指标分析经典5问：响应时间真的是越短越好吗？

│ │ │ ├─04-容量治理的三板斧：扩容、限流与降级

│ │ │ ├─05-全链路压测：系统整体容量保障的“核武器”（上）

│ │ │ ├─06-全链路压测：系统整体容量保障的“核武器”（下）

│ │ │ ├─07-工具进化：如何实现一个分布式压测平台

│ │ │ ├─08-容量预测（上）：第三只眼，通过AI预测服务容量瓶颈

│ │ │ ├─09-容量预测（下）：为不同服务“画像”，提升容量预测准确性

│ │ │ ├─10-浅谈排队论：数学之美，通过建模计算容量

│ │ │ ├─11-与时俱进：云原生下的容量保障新趋势

│ │ │ ├─12-大促容量保障体系建设：怎样做好大促活动的容量保障工作（上）

│ │ │ ├─13-大促容量保障体系建设：怎样做好大促活动的容量保障工作（下）

│ │ │ ├─14-容量保障组织建设：容量保障需要什么样的团队？

│ │ │ ├─146容量保障核心技术与实战

│ │ │ ├─15-小公司也能做好容量保障：建设经济实用型的容量保障体系

│ │ │ ├─加餐-学习容量保障的那些经典资料

│ │ │ ├─开篇词-互联网时代，人人肩负容量保障的职责

│ │ │ ├─结束语-做时间的朋友，成功是持续累积而成的

│ │ │ └─结课测试-这些容量保障知识，你都掌握了吗？

│ │ ├─147性能优化高手课

│ │ │ ├─01-性能建模设计：如何满足软件设计中的性能需求？

│ │ │ ├─02-并行设计（上）：如何利用并行设计挖掘性能极限？

│ │ │ ├─03-并行设计（下）：如何高效解决同步互斥问题？

│ │ │ ├─04-缓存设计：做好缓存设计的关键是什么？

│ │ │ ├─05-IO设计：如何设计IO交互来提升系统性能？

│ │ │ ├─06-通信设计：请不要让消息通信拖垮了系统的整体性能

│ │ │ ├─07-数据库选型：如何基于性能需求选择合适的数据库？

│ │ │ ├─08-可监控设计：如何利用eBPF来指导可监控设计？

│ │ │ ├─09-性能模式（上）：如何有效提升性能指标？

│ │ │ ├─10-性能模式（下）：如何解决核心的性能问题？

│ │ │ ├─11-如何针对特定业务场景设计数据结构和高性能算法？

│ │ │ ├─12-我们要先实现业务功能，还是先优化代码？

│ │ │ ├─13-编译期优化：只有修改业务代码才能提升系统性能？

│ │ │ ├─14-内存使用篇：如何高效使用内存来优化软件性能？

│ │ │ ├─147性能优化高手课

│ │ │ ├─15-并发实现：掌握不同并发框架的选择和使用秘诀

│ │ │ ├─16-技术探索：你真的把CPU的潜能都挖掘出来了吗？

│ │ │ ├─17-Benchmark测试（上）：如何做好微基准测试？

│ │ │ ├─18-Benchmark测试（下）：如何做好宏基准测试？

│ │ │ ├─19-性能测试工具：如何选择最合适的性能测试工具？

│ │ │ ├─20-性能看护：如何更好地守护产品性能？

│ │ │ ├─21-性能CI：性能测试也可以集成到Pipeline中吗？

│ │ │ ├─22-性能调优方法论：如何科学高效地定位性能问题？

│ │ │ ├─23-监控分析：你的性能调优工具足够有效吗？

│ │ │ ├─24-动态监控：你的产品系统中有动态监控的能力吗？

│ │ │ ├─25-性能调优什么时候应该停止？

│ │ │ ├─26-一个嵌入式实时系统都要从哪些方面做好性能优化？

│ │ │ ├─27-解决一个互斥问题，系统并发用户数提升了10倍！

│ │ │ ├─28-Web服务业务代码一行不动，性能提升20%，怎么做到的？

│ │ │ ├─开篇词-与我一起修炼，成为一名软件性能大师吧！

│ │ │ ├─结束语-千里之行，始于足下，你已踏上修炼之道！

│ │ │ └─结课测试-《性能优化高手课》100分试卷等你来挑战！

│ │ ├─148说透芯片

│ │ │ ├─01-核心概念：从晶体管到集成电路到摩尔定律

│ │ │ ├─02-从一部iPhone手机看芯片的分类

│ │ │ ├─03-芯片设计：一颗芯片到底是如何诞生的（上）

│ │ │ ├─04-芯片制造：一颗芯片到底是如何诞生的（下）

│ │ │ ├─05-Intel的发展史就是一部芯片行业的创新史（上）

│ │ │ ├─06-Intel的发展史就是一部芯片行业的创新史（下）

│ │ │ ├─07-三星：资本与技术共舞的40年

│ │ │ ├─08-台积电：摩尔定律的忠实执行者

│ │ │ ├─09-Nvidia与AI芯片：超越摩尔定律

│ │ │ ├─10｜德州仪器：模拟芯片的无冕之王

│ │ │ ├─11-其他半导体公司：美国双通与欧洲双雄

│ │ │ ├─12-中国芯片业的发展历史

│ │ │ ├─13-中国芯片现状与机会（上）

│ │ │ ├─148说透芯片

│ │ │ ├─14｜中国芯片现状与机会（下）

│ │ │ ├─15-聊聊芯片投资领域的机会

│ │ │ ├─16-拓展阅读：张忠谋分析台湾半导体晶圆制造的优势

│ │ │ ├─17｜拓展阅读：聊聊ARM与RISC-V

│ │ │ ├─18｜拓展阅读：再聊聊ARM、RISC-V与中国的机会

│ │ │ ├─开篇词-为什么你一定要了解芯片行业

│ │ │ ├─期末测试-这些芯片知识你都了解了吗？

│ │ │ ├─用户故事-学完课程，我更好地理解了芯片行业

│ │ │ ├─结束语-芯片人的升职之路

│ │ │ └─结束语-芯片人的升职之路

│ │ ├─149ReactHooks核心原理与实战

│ │ │ ├─01｜认识React：如何创建你的第一个React应用？

│ │ │ ├─02｜理解Hooks：React为什么要发明Hooks？

│ │ │ ├─03｜内置Hooks（1）：如何保存组件状态和使用生命周期？

│ │ │ ├─04｜内置Hooks（2）：为什么要避免重复定义回调函数？

│ │ │ ├─05｜进一步认识Hooks：如何正确理解函数组件的生命周期？

│ │ │ ├─06｜自定义Hooks：四个典型的使用场景

│ │ │ ├─07｜全局状态管理：如何在函数组件中使用Redux？

│ │ │ ├─08｜复杂状态处理：如何保证状态一致性？

│ │ │ ├─09｜异步处理：如何向服务器端发送请求？

│ │ │ ├─10｜函数组件设计模式：如何应对复杂条件渲染场景？

│ │ │ ├─11｜事件处理：如何创建自定义事件？

│ │ │ ├─12｜项目结构：为什么要按领域组织文件夹结构？

│ │ │ ├─13｜Form：Hooks给Form处理带来了哪些新变化？

│ │ │ ├─14-使用浮动层：如何展示对话框，并给对话框传递参数？

│ │ │ ├─149ReactHooks核心原理与实战

│ │ │ ├─15-路由管理：为什么每一个前端应用都需要使用路由机制？

│ │ │ ├─16-按需加载：如何提升应用打开速度？

│ │ │ ├─17-打包部署：你的应用是如何上线的？

│ │ │ ├─18-单元测试：自定义Hooks应该如何进行单元测试？

│ │ │ ├─19｜第三方工具库：最常用的第三方工具库有哪些？

│ │ │ ├─20-React的未来：什么是服务器端组件？

│ │ │ ├─开篇词-全面拥抱Hooks，掌握最新React开发方式

│ │ │ ├─答疑解惑01｜如何转换应用ReactHooks的思路？

│ │ │ ├─答疑解惑02

│ │ │ ├─结束语｜抓住本质，方能事半功倍

│ │ │ ├─结课测试题｜这些ReactHooks的知识你都掌握了吗？

│ │ │ └─结课测试题｜这些ReactHooks的知识你都掌握了吗？

│ │ ├─150Go语言项目开发实战

│ │ │ ├─01-IAM系统概述：我们要实现什么样的Go项目？

│ │ │ ├─02-环境准备：如何安装和配置一个基本的Go开发环境？

│ │ │ ├─03-项目部署：如何快速部署IAM系统？

│ │ │ ├─04-规范设计（上）：项目开发杂乱无章，如何规范？

│ │ │ ├─05-规范设计（下）：commit信息风格迥异、难以阅读，如何规范？

│ │ │ ├─06-目录结构设计：如何组织一个可维护、可扩展的代码目录？

│ │ │ ├─07-工作流设计：如何设计合理的多人开发模式？

│ │ │ ├─08-研发流程设计（上）：如何设计Go项目的开发流程？

│ │ │ ├─09-研发流程设计（下）：如何管理应用的生命周期？

│ │ │ ├─10-设计方法：怎么写出优雅的Go项目？

│ │ │ ├─11-设计模式：Go常用设计模式概述

│ │ │ ├─12-API风格（上）：如何设计RESTfulAPI？

│ │ │ ├─13-API风格（下）：RPCAPI介绍

│ │ │ ├─14-项目管理：如何编写高质量的Makefile？

│ │ │ ├─15-研发流程实战：IAM项目是如何进行研发流程管理的？

│ │ │ ├─150Go语言项目开发实战

│ │ │ ├─16-代码检查：如何进行静态代码检查？

│ │ │ ├─17-API文档：如何生成SwaggerAPI文档？

│ │ │ ├─18-错误处理（上）：如何设计一套科学的错误码？

│ │ │ ├─19-错误处理（下）：如何设计错误包？

│ │ │ ├─20-日志处理（上）：如何设计日志包并记录日志？

│ │ │ ├─21-日志处理（下）：手把手教你从0编写一个日志包

│ │ │ ├─22-应用构建三剑客：Pflag、Viper、Cobra核心功能介绍

│ │ │ ├─23-应用构建实战：如何构建一个优秀的企业应用框架？

│ │ │ ├─24-Web服务：Web服务核心功能有哪些，如何实现？

│ │ │ ├─25-认证机制：应用程序如何进行访问认证？

│ │ │ ├─26-IAM项目是如何设计和实现访问认证功能的？

│ │ │ ├─27-权限模型：5大权限模型是如何进行资源授权的？

│ │ │ ├─28-控制流（上）：通过iam-apiserver设计，看Web服务的构建

│ │ │ ├─29｜控制流（下）：iam-apiserver服务核心功能实现讲解

│ │ │ ├─30-ORM：CURD神器GORM包介绍及实战

│ │ │ ├─31-数据流：通过iam-authz-server设计，看数据流服务的设计

│ │ │ ├─32-数据处理：如何高效处理应用程序产生的数据？

│ │ │ ├─33-SDK设计（上）：如何设计出一个优秀的GoSDK？

│ │ │ ├─34-SDK设计（下）：IAM项目GoSDK设计和实现

│ │ │ ├─35-效率神器：如何设计和实现一个命令行客户端工具？

│ │ │ ├─36-代码测试（上）：如何编写Go语言单元测试和性能测试用例？

│ │ │ ├─37-代码测试（下）：Go语言其他测试类型及IAM测试介绍

│ │ │ ├─38｜性能分析（上）：如何分析Go语言代码的性能？

│ │ │ ├─39｜性能分析（下）：APIServer性能测试和调优实战

│ │ │ ├─40-软件部署实战（上）：部署方案及负载均衡、高可用组件介绍

│ │ │ ├─41-软件部署实战（中）：IAM系统生产环境部署实战

│ │ │ ├─42-软件部署实战（下）：IAM系统安全加固、水平扩缩容实战

│ │ │ ├─43｜技术演进（上）：虚拟化技术演进之路

│ │ │ ├─44｜技术演进（下）：软件架构和应用生命周期技术演进之路

│ │ │ ├─45｜基于Kubernetes的云原生架构设计

│ │ │ ├─46-如何制作Docker镜像？

│ │ │ ├─47-如何编写Kubernetes资源定义文件？

│ │ │ ├─48-IAM容器化部署实战

│ │ │ ├─49-服务编排（上）：Helm服务编排基础知识

│ │ │ ├─50-服务编排（下）：基于Helm的服务编排部署实战

│ │ │ ├─51-基于GitHubActions的CI实战

│ │ │ ├─开篇词-从0开始搭建一个企业级Go应用

│ │ │ ├─期末考试｜《Go语言项目开发实战》满分试卷，等你来挑战！

│ │ │ ├─特别放送-GoModules依赖包管理全讲

│ │ │ ├─特别放送-GoModules实战

│ │ │ ├─特别放送-IAM排障指南

│ │ │ ├─特别放送-分布式作业系统设计和实现

│ │ │ ├─特别放送-给你一份Go项目中最常用的Makefile核心语法

│ │ │ ├─特别放送-给你一份清晰、可直接套用的Go编码规范

│ │ │ ├─直播加餐｜如何从小白进阶成Go语言专家？

│ │ │ ├─结束语-如何让自己的Go研发之路走得更远？

│ │ │ └─结束语-如何让自己的Go研发之路走得更远？

│ │ ├─151说透5G

│ │ │ ├─01｜从1G到3G：从野蛮生长到数据崭露头角

│ │ │ ├─02-从4G到5G：发展5G真的有必要吗？

│ │ │ ├─03｜用一通电话带你遍历移动通信基础

│ │ │ ├─04｜5G产业全景图：如何能高效、系统地掌握5G？

│ │ │ ├─05-决定5G产业生态的技术标准，是怎么制定出来的？

│ │ │ ├─06-5G关键性能指标是如何通过无线技术来实现的？

│ │ │ ├─07｜5G基站一定要重建吗？怎样才能节省投资？

│ │ │ ├─08-基于IT技术的开放式无线接入网，到底可不可行？

│ │ │ ├─09｜你真的了解5G的终端和芯片吗？

│ │ │ ├─10｜云上的通信核心网，会是未来的方向吗？

│ │ │ ├─11｜万物智联，先从搭建一套技术底座开始

│ │ │ ├─12｜AR-VR-超高清：开启全新的娱乐生活体验

│ │ │ ├─13｜工业互联网：为什么工业智能化数字化升级缺不了5G？

│ │ │ ├─14｜智能医疗：5G真的能让我们看病更快更方便吗

│ │ │ ├─15-车联网：5G能给车联网带来什么？

│ │ │ ├─151说透5G

│ │ │ ├─16-5G使能数字社会，6G成就数字社会？

│ │ │ ├─开篇词｜除了使用5G手机，你为什么还得了解5G行业？

│ │ │ ├─期末考试｜《说透5G》100分试卷等你来挑战！

│ │ │ ├─结束语｜持续学习，才能找到通往未来的“捷径”

│ │ │ └─结束语｜持续学习，才能找到通往未来的“捷径”

│ │ ├─152如何成为学习高手

│ │ │ ├─01｜如何减少对学习的排斥和厌恶心理，使其变得相对愉悦？

│ │ │ ├─02｜学会这4点，你也可以告别伪勤奋

│ │ │ ├─03｜掌握考试思维：成为一个特别会考试的人

│ │ │ ├─04｜用科学原理告诉你如何在考场上超常发挥

│ │ │ ├─05｜教你全面提升专注力，学习时不再走神

│ │ │ ├─06｜教你高效复习：巧用学习神器取得好成绩

│ │ │ ├─07｜我考北大中文系时，15天背下10门专业课的连点成线法

│ │ │ ├─08｜高效记忆的根本方法：主动思考和加工&组块化记忆

│ │ │ ├─09｜如何高效读书？如何记住读过的每一本书？

│ │ │ ├─10｜如何快速入门新领域？论述题如何答出高分？

│ │ │ ├─11｜如何快速完成学习和工作任务，以及快速学会新技能？

│ │ │ ├─12｜每个人都能学会：5分钟克服拖延症的方法

│ │ │ ├─13｜3个思路，让你成为一个真正自律的人

│ │ │ ├─14｜通过选择环境，来提高学习和工作效率

│ │ │ ├─152如何成为学习高手

│ │ │ ├─15｜一个人在家如何做到高度自律？

│ │ │ ├─16｜一玩手机就停不下来？教你如何戒手机

│ │ │ ├─17｜如何合理地制订计划？

│ │ │ ├─18｜如何保证100%完成你制订的计划？

│ │ │ ├─19｜如何高效完成复杂艰难的、不喜欢的任务？

│ │ │ ├─20｜如何做到每天高效学习12小时？

│ │ │ ├─21｜学霸为什么学什么都快？有哪些可以借鉴的方法论？

│ │ │ ├─22｜如何通过练习，让自己变得更聪明？

│ │ │ ├─23｜教你利用“双加工理论”，有效提高学习能力

│ │ │ ├─24｜重要：别再去找更好的学习方法了

│ │ │ └─24｜重要：别再去找更好的学习方法了

│ │ ├─153如何读懂一首诗

│ │ │ ├─01｜读诗句：溪柴火软蛮毡暖，还是火软溪柴蛮毡暖？

│ │ │ ├─02｜读诗人：连李贺生平都不熟，又怎能懂他的诗呢？

│ │ │ ├─03｜读诗意：恍惚之间，我从诗里找到了自己的影子

│ │ │ ├─04｜元白友情：什么样的人才算得上知己？

│ │ │ ├─05｜沈园之恋：74岁的陆游，念念不忘的初恋

│ │ │ ├─06｜骨肉情深：苏轼临死前最关心什么？

│ │ │ ├─07｜侠客李白：古今不变的大侠梦

│ │ │ ├─08｜文人风骨：张孝祥的孤光自照

│ │ │ ├─09｜家国情怀：35岁的辛弃疾老了吗？

│ │ │ ├─10｜山水诗词：给自己一座精神的“辋川”

│ │ │ ├─11｜诗中花语：宋人为什么觉得唐人不懂梅花？

│ │ │ ├─12｜漂啊漂啊：古代的“北漂”在想什么？

│ │ │ ├─13｜《甄嬛传》曲：为什么古代男子喜欢学女子说话？

│ │ │ ├─14｜民生疾苦：他们使杜甫成为诗圣

│ │ │ ├─153如何读懂一首诗

│ │ │ ├─15｜升迁贬谪：命犯“桃花”的刘禹锡

│ │ │ ├─16｜女性视角：李清照笔下独到的细腻

│ │ │ ├─17｜诗中哲学：读了这些理趣诗之后，我悟了！

│ │ │ ├─18｜乐观豁达：黄州重生的苏轼

│ │ │ ├─19｜返璞归真：王维佛系建议，万事不如吃好睡好

│ │ │ ├─20｜自强不息：什么样的宝刀配得上女侠秋瑾？

│ │ │ ├─加餐1｜辞职问题：古人怎么写高端辞职信？

│ │ │ ├─加餐2｜面试问题：古人怎么向别人推荐自己？

│ │ │ ├─好诗相伴01｜见情真：情到深处成文章

│ │ │ ├─好诗相伴02｜见古今：古今不变唯精神

│ │ │ ├─好诗相伴03｜见万物：世间万物在诗中

│ │ │ ├─好诗相伴04｜见众生：众生皆苦亦哲学

│ │ │ ├─好诗相伴05｜见自己：我在诗中渡自己

│ │ │ ├─开篇词｜有刷抖音的功夫，我们还不如读读诗词

│ │ │ ├─结束语｜诗词是一颗精神世界的种子

│ │ │ └─结束语｜诗词是一颗精神世界的种子

│ │ ├─154如何落地业务建模

│ │ │ ├─01｜领域驱动设计到底在讲什么？

│ │ │ ├─02｜统一语言是必要的吗？

│ │ │ ├─03｜我们要怎么理解领域驱动设计？

│ │ │ ├─04｜跨越现实的障碍（上）：要性能还是要模型？

│ │ │ ├─05｜跨越现实的障碍（中）：富含知识还是代码坏味道？

│ │ │ ├─06-跨越现实的障碍（下）：架构分层就对了吗？

│ │ │ ├─07｜统一语言可以是领域模型本身吗？

│ │ │ ├─08-什么办法可以在讨论中自然形成统一语言？

│ │ │ ├─09｜怎么才能更有效地获得事件流？

│ │ │ ├─10-将模型实现为RESTfulAPI（上）

│ │ │ ├─11｜将模型实现为RESTfulAPI（下）

│ │ │ ├─12｜云时代的挑战（上）：弹性边界还是业务边界？

│ │ │ ├─13｜云时代的挑战（下）：如何保持弹性边界的独立性？

│ │ │ ├─14-8XFlow（上）：何为业务？何为领域？

│ │ │ ├─154如何落地业务建模

│ │ │ ├─15｜8XFlow（中）：如何通过模型发现业务系统的变化点？

│ │ │ ├─16｜8XFlow（下）：多于一个例子

│ │ │ ├─17｜中台建模（上）：到底什么是中台？

│ │ │ ├─18｜中台建模（下）：如何寻找可复用的业务模式？

│ │ │ ├─19｜如何将模型实现为微服务？

│ │ │ ├─20｜云时代的下一站：SaaS化与魔球建模法

│ │ │ ├─开篇词｜为什么你需要学习业务建模？

│ │ │ ├─用户故事01｜知瑕：如何通过刻意练习，掌握建模方法？

│ │ │ ├─用户故事02｜邹海龙：大道千条，我选其一

│ │ │ ├─直播加餐01｜如何使用8XFlow实施面向业务设计？

│ │ │ ├─直播加餐02｜如何使用SmartDomain实现DDD？

│ │ │ ├─结束语｜吃喝玩乐如何让我成为更好的程序员？

│ │ │ ├─结课测试题｜这些业务建模知识你都掌握了吗？

│ │ │ ├─编辑手记01｜写给专栏读者的一封小信

│ │ │ ├─说点题外话01｜好耦和与坏耦和

│ │ │ ├─说点题外话02｜模式并不是解决方案

│ │ │ ├─说点题外话03｜银弹可以杀死狼人，但你怎么知道狼人不是你呢？

│ │ │ ├─说点题外话04｜面向对象的原则适用于RESTfulAPI吗？

│ │ │ └─说点题外话04｜面向对象的原则适用于RESTfulAPI吗？

│ │ ├─155讲好故事

│ │ │ ├─01-鸡同鸭讲：说者和听者的认知差异

│ │ │ ├─02-心驰神往：受众到底喜欢怎样的故事？

│ │ │ ├─03-行成于思：你是否有故事思维？

│ │ │ ├─04-笔酣墨饱：如何创建你的故事库？

│ │ │ ├─05-直指人心：故事之饵藏在哪里？

│ │ │ ├─06-身临其境：如何把故事写得精彩？

│ │ │ ├─07-入木三分：如何把故事讲得“入味”

│ │ │ ├─08-余音绕梁：故事中容易被忽略的文字魅力

│ │ │ ├─09-无中生有（上）：如何讲好短故事

│ │ │ ├─10-无中生有（下）：如何编排长故事

│ │ │ ├─11-动静有法：恪守故事的伦理法则

│ │ │ ├─12-职场：用故事呈现你的职业价值

│ │ │ ├─13-公开演讲：用故事吐露你的观点

│ │ │ ├─14-产品运营：用故事包装你的产品

│ │ │ ├─15-交友圈：用故事带动现场气氛

│ │ │ ├─155讲好故事

│ │ │ ├─开篇词-讲好故事是这个时代必备的技能

│ │ │ ├─结束语-人生，本来就是一个好故事

│ │ │ └─结束语-人生，本来就是一个好故事

│ │ ├─156程序员的个人财富课

│ │ │ ├─01-财富框架：建立属于你自己的财富双塔

│ │ │ ├─02｜个人发展：你自己的发展才是最大的财富源泉

│ │ │ ├─03｜理财金字塔：如何建立稳固的投资理财结构？

│ │ │ ├─04｜实战知识：有哪些收益稳健的经典资产配置组合？

│ │ │ ├─05｜支点投资法：主动投资是讲逻辑的！

│ │ │ ├─06｜不当韭菜：在财富管理的过程中摆正心态，知己知彼

│ │ │ ├─07｜职业方向：如何选择一个有前景的职业方向？

│ │ │ ├─08｜职业规划：大公司VS小公司，怎样选择更有前途？

│ │ │ ├─09｜期权股权：如何正确处理公司的期权、股权？

│ │ │ ├─10｜跳槽涨薪：如何规划一条合理的职业道路？

│ │ │ ├─11-财富拓展：35岁失业？程序员如何拓宽财富渠道？

│ │ │ ├─12｜房产投资：如何做出理性的买房决策？

│ │ │ ├─13｜实战知识：让我们编程计算下怎么还房贷最合适

│ │ │ ├─14｜基金投资：如何让专业人士帮你赚钱？

│ │ │ ├─156程序员的个人财富课

│ │ │ ├─15｜实战知识：如何选出一只优质的基金？

│ │ │ ├─16｜股票投资：最适合散户的股票投资方法是什么？

│ │ │ ├─17｜投资闭环：如何成为越来越专业的投资者？

│ │ │ ├─18｜技术优势：程序员如何用技术超越其他投资者？

│ │ │ ├─19｜量化投资：典型的量化投资系统都包含哪些模块？

│ │ │ ├─20｜价值投资：永远不过时的中长期投资策略

│ │ │ ├─21｜趋势跟踪：怎样跟着趋势一起赚钱？

│ │ │ ├─22｜轮动策略：如何踩准市场变换的节奏？

│ │ │ ├─23｜对冲思想：这个世界上有稳赚不赔的生意吗？

│ │ │ ├─24｜多因子模型：整合不同策略，形成合力的顶层框架

│ │ │ ├─25｜机器学习：我们能用机器学习来建立投资模型吗？

│ │ │ ├─26｜量化实战：从0到1搭建起一套简单的量化投资系统（上）

│ │ │ ├─27｜量化实战：从0到1搭建起一套简单的量化投资系统（下）

│ │ │ ├─开篇词｜为什么说程序员最适合学财富管理？

│ │ │ ├─期末考试｜《程序员的个人财富课》满分试卷，等你来挑战！

│ │ │ ├─番外一｜王喆对话李腾：程序员对基金经理的灵魂十问（上）

│ │ │ ├─番外三｜有哪些能够持续学习的参考资料和相关网站？

│ │ │ ├─番外二｜王喆对话李腾：程序员对基金经理的灵魂十问（下）

│ │ │ ├─番外四｜知识总结：这门课的全部思维导图

│ │ │ ├─答疑课堂（一）｜财富框架篇、个人发展篇思考题集锦

│ │ │ ├─答疑课堂（二）｜投资实战篇、投资进阶篇思考题集锦

│ │ │ ├─结束语-知行合一：财富管理是一生的事情

│ │ │ └─结束语-知行合一：财富管理是一生的事情

│ │ ├─157说透区块链

│ │ │ ├─01-回顾前世：解读区块链技术发展三阶段

│ │ │ ├─02-着眼今生：揭秘区块链技术的发展现状

│ │ │ ├─03-技术特性：用“铁锁连环”直观理解区块链特点

│ │ │ ├─04-存储：区块链的存储设计有定式吗？

│ │ │ ├─05-密码学：为什么说区块链站在了巨人肩膀上？

│ │ │ ├─06-网络：先有去中心化还是先有点对点？

│ │ │ ├─07-共识（上）：拜占廷将军也讲少数服从多数？

│ │ │ ├─08-共识（下）：区块链领域的两类常用算法

│ │ │ ├─09-智能合约：虚拟与现实的价值锚定载体

│ │ │ ├─10-技术迭代：美好背后的遗憾

│ │ │ ├─11-区块链+5G物联网：万物互联不止鸿蒙

│ │ │ ├─12-区块链+数字人民币：怎样理解数字人民币体系架构？

│ │ │ ├─13-区块链+新基建：数字社会的四驾马车

│ │ │ ├─14-区块链+电商：如何实现在线购物新体验？

│ │ │ ├─15-区块链+社会治理：区块链如何为治理提供新方案？

│ │ │ ├─157说透区块链

│ │ │ ├─16-困境与展望：区块链技术如何嵌入未来世界？

│ │ │ ├─开篇词-区块链，一种面向未来的思维方式

│ │ │ ├─结束语-未来已至，赢在区块链思维

│ │ │ ├─结课测试｜这些区块链的知识点，你都掌握了么？

│ │ │ └─结课测试｜这些区块链的知识点，你都掌握了么？

│ │ ├─158Redis源码剖析与实战

│ │ │ ├─01-带你快速攻略Redis源码的整体架构

│ │ │ ├─02-键值对中字符串的实现，用char-还是结构体？

│ │ │ ├─03-如何实现一个性能优异的Hash表？

│ │ │ ├─04-内存友好的数据结构该如何细化设计？

│ │ │ ├─05-有序集合为何能同时支持点查询和范围查询？

│ │ │ ├─06-从ziplist到quicklist，再到listpack的启发

│ │ │ ├─07-为什么Stream使用了RadixTree？

│ │ │ ├─08-Redisserver启动后会做哪些操作？

│ │ │ ├─09-Redis事件驱动框架（上）：何时使用select、poll、epoll？

│ │ │ ├─10-Redis事件驱动框架（中）：Redis实现了Reactor模型吗？

│ │ │ ├─11-Redis事件驱动框架（下）：Redis有哪些事件？

│ │ │ ├─12-Redis真的是单线程吗？

│ │ │ ├─13-Redis6

│ │ │ ├─14-从代码实现看分布式锁的原子性保证

│ │ │ ├─15-为什么LRU算法原理和代码实现不一样？

│ │ │ ├─158Redis源码剖析与实战

│ │ │ ├─16-LFU算法和其他算法相比有优势吗？

│ │ │ ├─17-LazyFree会影响缓存替换吗？

│ │ │ ├─18-如何生成和解读RDB文件？

│ │ │ ├─19-AOF重写（上）：触发时机与重写的影响

│ │ │ ├─20-AOF重写（下）：重写时的新写操作记录在哪里？

│ │ │ ├─21-主从复制：基于状态机的设计与实现

│ │ │ ├─22-哨兵也和Redis实例一样初始化吗？

│ │ │ ├─23-从哨兵Leader选举学习Raft协议实现（上）

│ │ │ ├─24-从哨兵Leader选举学习Raft协议实现（下）

│ │ │ ├─25-Pub-Sub在主从故障切换时是如何发挥作用的？

│ │ │ ├─26-从Ping-Pong消息学习Gossip协议的实现

│ │ │ ├─27-从MOVED、ASK看集群节点如何处理命令？

│ │ │ ├─28-RedisCluster数据迁移会阻塞吗？

│ │ │ ├─29-如何正确实现循环缓冲区？

│ │ │ ├─30-如何在系统中实现延迟监控？

│ │ │ ├─31-从Module的实现学习动态扩展功能

│ │ │ ├─32-如何在一个系统中实现单元测试？

│ │ │ ├─加餐1-Redis性能测试工具的使用

│ │ │ ├─加餐2-用户Kaito：我是怎么读Redis源码的？

│ │ │ ├─加餐3-从Redis到其他键值数据库的学习体会

│ │ │ ├─加餐4-RDB和AOF文件损坏了咋办？

│ │ │ ├─开篇词-阅读Redis源码能给你带来什么？

│ │ │ ├─期中测试-这些Redis源码知识，你都掌握了吗？

│ │ │ ├─期中测试题答案-这些问题你都答对了吗？

│ │ │ ├─用户故事-曾轼麟：世上无难事，只怕有心人

│ │ │ ├─答疑1-第1~6讲课后思考题答案及常见问题答疑

│ │ │ ├─答疑2-第7~12讲课后思考题答案及常见问题答疑

│ │ │ ├─答疑3-第13~18讲课后思考题答案及常见问题答疑

│ │ │ ├─答疑4-第19~24讲课后思考题答案及常见问题答疑

│ │ │ ├─答疑5-第25~32讲课后思考题答案及常见问题答疑

│ │ │ ├─结束语-Redis源码阅读，让我们从新开始

│ │ │ └─结课测试-一套习题，测测你的Redis源码知识掌握程度

│ │ ├─159数据分析思维课

│ │ │ ├─01-平均值：不要被骗了，它不能代表整体水平

│ │ │ ├─02-大数定律与小数陷阱：生活是随机还是有定数的？

│ │ │ ├─03-数据的期望值：为什么你坐的飞机总是晚点？

│ │ │ ├─04-随机对照试验：章鱼保罗真的是“预言帝”么？

│ │ │ ├─05-直方图与幂分布：为什么全世界1%的人掌握着50%的财富？

│ │ │ ├─06-数据分布：房子应该是买贵的还是买便宜的？

│ │ │ ├─07-散点图和相关性：怎样快速从数据当中找到规律？

│ │ │ ├─08-标准差：这人是不是“靠谱”其实看标准差？

│ │ │ ├─09-数据抽样：大数据来了还需要抽样么？

│ │ │ ├─10-指数和KPI：智商是怎么计算出来的？

│ │ │ ├─11-因果倒置：星座真的可以判定你的性格吗？

│ │ │ ├─12-精确率与置信区间：两种预测，你究竟应该相信哪一个？

│ │ │ ├─13-趋势分析与回归：父母高，孩子一定高么？

│ │ │ ├─14-初识聚类算法：物以类聚，让复杂事物简单化

│ │ │ ├─15-初识分类算法：分而治之，不断进化

│ │ │ ├─159数据分析思维课

│ │ │ ├─16-关联规则：为什么啤酒和尿布一起卖？

│ │ │ ├─17-蒙特卡洛与拉斯维加斯：有限时间内如何获得最优解？

│ │ │ ├─18-马尔可夫链：你的未来，只取决于你当下做什么

│ │ │ ├─19-协同过滤：你看到的短视频都是集体智慧的结晶

│ │ │ ├─20-人工智能初探：阿尔法狗是怎样的一只“狗”？

│ │ │ ├─21-确定问题：与利益无关的问题都不值得数据分析和挖掘

│ │ │ ├─22-采集数据：用好一手数据和二手数据

│ │ │ ├─23-写好故事线：你能用好数字推翻众人的理解吗？

│ │ │ ├─24-实践你的理论：数据驱动最终就是用结果说话

│ │ │ ├─25-数据分析：15种数据思维图（上）

│ │ │ ├─26-数据分析：15种数据思维图（下）

│ │ │ ├─27-我常用的数据分析工具图谱

│ │ │ ├─28-让你数据分析瞬间提效的18个基础功法（上）

│ │ │ ├─29-让你数据分析瞬间提效的18个基础功法（下）

│ │ │ ├─30-快速实现数据分析基础课中的分析模型

│ │ │ ├─31-最先进的数据分析工具展望

│ │ │ ├─中秋放送-数据分析基础回顾

│ │ │ ├─中秋放送-数据算法基础回顾

│ │ │ ├─加餐-升级头脑，用数据思维点亮生活

│ │ │ ├─国庆放送-书单推荐

│ │ │ ├─导读-万物背后的规律都是数据

│ │ │ ├─开篇词-数据给你一双看透本质的眼睛

│ │ │ ├─结束语-我们不是神：数据分析既是天使也是魔鬼

│ │ │ ├─编辑手记-让生活多一些科学，少一些神学

│ │ │ └─编辑手记-让生活多一些科学，少一些神学

│ │ ├─160程序员的测试课

│ │ │ ├─01-实战：实现一个ToDo的应用（上）

│ │ │ ├─02-实战：实现一个ToDo的应用（下）

│ │ │ ├─03-程序员的测试与测试人员的测试有什么不同？

│ │ │ ├─04-自动化测试：为什么程序员做测试其实是有优势的？

│ │ │ ├─05-一个好的自动化测试长什么样？

│ │ │ ├─06-测试不好做，为什么会和设计有关系？

│ │ │ ├─07-Mock框架：怎么让测试变得可控？

│ │ │ ├─08-单元测试应该怎么写？

│ │ │ ├─09-测试覆盖率：如何找出没有测试到的代码？

│ │ │ ├─10-为什么100%的测试覆盖率是可以做到的？

│ │ │ ├─11-集成测试：单元测试可以解决所有问题吗？

│ │ │ ├─12-实战：将ToDo应用扩展为一个REST服务

│ │ │ ├─13-在Spring项目中如何进行单元测试？

│ │ │ ├─14-在Spring项目如何进行集成测试？

│ │ │ ├─15-测试应该怎么配比？

│ │ │ ├─16-怎么在遗留系统上写测试？

│ │ │ ├─160程序员的测试课

│ │ │ ├─17-TDD就是先写测试后写代码吗？

│ │ │ ├─18-BDD是什么东西？

│ │ │ ├─开篇词-为什么写测试是程序员的本职工作？

│ │ │ ├─答疑解惑-那些东西怎么测？

│ │ │ ├─结束语-对代码的信心要从测试里来

│ │ │ └─结束语-对代码的信心要从测试里来

│ │ ├─161陈天·Rust编程第一课

│ │ │ ├─01｜内存：值放堆上还是放栈上，这是一个问题

│ │ │ ├─02｜串讲：编程开发中，那些你需要掌握的基本概念

│ │ │ ├─03｜初窥门径：从你的第一个Rust程序开始！

│ │ │ ├─04｜gethandsdirty：来写个实用的CLI小工具

│ │ │ ├─05｜gethandsdirty：做一个图片服务器有多难？

│ │ │ ├─06｜gethandsdirty：SQL查询工具怎么一鱼多吃？

│ │ │ ├─07｜所有权：值的生杀大权到底在谁手上？

│ │ │ ├─08｜所有权：值的借用是如何工作的？

│ │ │ ├─09｜所有权：一个值可以有多个所有者么？

│ │ │ ├─10｜生命周期：你创建的值究竟能活多久？

│ │ │ ├─11｜内存管理：从创建到消亡，值都经历了什么？

│ │ │ ├─12｜类型系统：Rust的类型系统有什么特点？

│ │ │ ├─13｜类型系统：如何使用trait来定义接口？

│ │ │ ├─14｜类型系统：有哪些必须掌握的trait？

│ │ │ ├─15｜数据结构：这些浓眉大眼的结构竟然都是智能指针？

│ │ │ ├─161陈天·Rust编程第一课

│ │ │ ├─16｜数据结构：Vec-T-、&[T]、Box-[T]-，你真的了解集合容器么？

│ │ │ ├─17｜数据结构：软件系统核心部件哈希表，内存如何布局？

│ │ │ ├─18｜错误处理：为什么Rust的错误处理与众不同？

│ │ │ ├─19｜闭包：FnOnce、FnMut和Fn，为什么有这么多类型？

│ │ │ ├─20｜4Steps：如何更好地阅读Rust源码？

│ │ │ ├─21｜阶段实操（1）：构建一个简单的KVserver-基本流程

│ │ │ ├─22｜阶段实操（2）：构建一个简单的KVserver-基本流程

│ │ │ ├─23｜类型系统：如何在实战中使用泛型编程？

│ │ │ ├─24｜类型系统：如何在实战中使用traitobject？

│ │ │ ├─25｜类型系统：如何围绕trait来设计和架构系统？

│ │ │ ├─26｜阶段实操（3）：构建一个简单的KVserver-高级trait技巧

│ │ │ ├─27｜生态系统：有哪些常有的Rust库可以为我所用？

│ │ │ ├─28｜网络开发（上）：如何使用Rust处理网络请求？

│ │ │ ├─29｜网络开发（下）：如何使用Rust处理网络请求？

│ │ │ ├─30｜UnsafeRust：如何用C++的方式打开Rust？

│ │ │ ├─31｜FFI：Rust如何和你的语言架起沟通桥梁？

│ │ │ ├─32｜实操项目：使用PyO3开发Python3模块

│ │ │ ├─33｜并发处理（上）：从atomics到Channel，Rust都提供了什么工具？

│ │ │ ├─34｜并发处理（下）：从atomics到Channel，Rust都提供了什么工具？

│ │ │ ├─35｜实操项目：如何实现一个基本的MPSCchannel？

│ │ │ ├─36｜阶段实操（4）：构建一个简单的KVserver-网络处理

│ │ │ ├─37｜阶段实操（5）：构建一个简单的KVserver-网络安全

│ │ │ ├─38｜异步处理：Future是什么？它和async-await是什么关系？

│ │ │ ├─39｜异步处理：async-await内部是怎么实现的？

│ │ │ ├─40｜异步处理：如何处理异步IO？

│ │ │ ├─41｜阶段实操（6）：构建一个简单的KVserver-异步处理

│ │ │ ├─42｜阶段实操（7）：构建一个简单的KVserver-如何做大的重构？

│ │ │ ├─43｜生产环境：真实世界下的一个Rust项目包含哪些要素？

│ │ │ ├─44｜数据处理：应用程序和数据如何打交道？

│ │ │ ├─45｜阶段实操（8）：构建一个简单的KVserver-配置-测试-监控-CI-CD

│ │ │ ├─46｜软件架构：如何用Rust架构复杂系统？

│ │ │ ├─加餐｜Rust2021版次问世了！

│ │ │ ├─加餐｜代码即数据：为什么我们需要宏编程能力？

│ │ │ ├─加餐｜宏编程（上）：用最“笨”的方式撰写宏

│ │ │ ├─加餐｜宏编程（下）：用syn-quote优雅地构建宏

│ │ │ ├─加餐｜愚昧之巅：你的Rust学习常见问题汇总

│ │ │ ├─加餐｜期中测试：参考实现讲解

│ │ │ ├─加餐｜期中测试：来写一个简单的grep命令行

│ │ │ ├─加餐｜这个专栏你可以怎么学，以及Rust是否值得学？

│ │ │ ├─大咖助场｜开悟之坡（上）：Rust的现状、机遇与挑战

│ │ │ ├─大咖助场｜开悟之坡（下）：Rust的现状、机遇与挑战

│ │ │ ├─开篇词｜让Rust成为你的下一门主力语言

│ │ │ ├─特别策划｜学习锦囊（一）：听听课代表们怎么说

│ │ │ ├─特别策划｜学习锦囊（三）：听听课代表们怎么说

│ │ │ ├─特别策划｜学习锦囊（二）：听听课代表们怎么说

│ │ │ ├─用户故事｜绝望之谷：改变从学习开始

│ │ │ ├─用户故事｜语言不仅是工具，还是思维方式

│ │ │ ├─结束语｜永续之原：Rust学习，如何持续精进？

│ │ │ └─结束语｜永续之原：Rust学习，如何持续精进？

│ │ ├─162手把手带你写一门编程语言

│ │ │ ├─01｜实现一门超简单的语言最快需要多久？

│ │ │ ├─02｜词法分析：识别Token也可以很简单吗？

│ │ │ ├─03｜支持表达式：解析表达式和解析语句有什么不同？

│ │ │ ├─04｜如何让我们的语言支持变量和类型？

│ │ │ ├─05｜函数实现：是时候让我们的语言支持函数和返回值了

│ │ │ ├─06｜怎么支持条件语句和循环语句？

│ │ │ ├─07｜怎么设计属于我们自己的虚拟机和字节码？

│ │ │ ├─08｜基于TypeScript的虚拟机（一）：实现一个简单的栈机

│ │ │ ├─09｜基于TypeScript的虚拟机（二）：丰富特性，支持跳转语句

│ │ │ ├─10｜基于C语言的虚拟机（一）：实现一个简单的栈机

│ │ │ ├─11｜基于C语言的虚拟机（二）：性能增长10倍的秘密

│ │ │ ├─12｜物理机上程序运行的硬件环境是怎么样的？

│ │ │ ├─13｜物理机上程序运行的软件环境是怎么样的？

│ │ │ ├─14｜汇编代码学习（一）：熟悉CPU架构和指令集

│ │ │ ├─15｜汇编语言学习（二）：熟悉X86汇编代码

│ │ │ ├─162手把手带你写一门编程语言

│ │ │ ├─16｜生成本地代码第1关：先把基础搭好

│ │ │ ├─17｜生成本地代码第2关：变量存储、函数调用和栈帧维护

│ │ │ ├─18｜生成本地代码第3关：实现完整的功能

│ │ │ ├─19｜怎么实现一个更好的寄存器分配算法：原理篇

│ │ │ ├─20｜怎么实现一个更好的寄存器分配算法：实现篇

│ │ │ ├─21｜加深对栈的理解：实现尾递归和尾调用优化

│ │ │ ├─22｜增强编译器前端功能第1步：再识数据流分析技术

│ │ │ ├─23｜增强编译器前端功能第2步：增强类型体系

│ │ │ ├─24｜增强编译器前端功能第3步：全面的集合运算

│ │ │ ├─25｜增强编译器前端功能第4步：综合运用多种语义分析技术

│ │ │ ├─26｜增强更丰富的类型第1步：如何支持浮点数？

│ │ │ ├─27｜增加更丰富的类型第2步：如何支持字符串？

│ │ │ ├─28｜增加更丰富的类型第3步：支持数组

│ │ │ ├─29｜面向对象编程第1步：先把基础搭好

│ │ │ ├─30｜面向对象编程第2步：剖析一些技术细节

│ │ │ ├─31｜面向对象编程第3步：支持继承和多态

│ │ │ ├─32｜函数式编程第1关：实现高阶函数

│ │ │ ├─33｜函数式编程第2关：实现闭包特性

│ │ │ ├─34｜内存管理第1关：Arena技术和元数据

│ │ │ ├─35｜内存管理第2关：实现垃圾回收

│ │ │ ├─36｜节点之海：怎么生成基于图的IR？

│ │ │ ├─37-从AST到IR：体会数据流和控制流思维

│ │ │ ├─38｜中端优化第1关：实现多种本地优化

│ │ │ ├─39｜中端优化第2关：全局优化要怎么搞？

│ │ │ ├─40｜中端优化第3关：一起来挑战过程间优化

│ │ │ ├─41｜后端优化：生成LIR和指令选择

│ │ │ ├─42｜到这里，我们的收获和未尽的工作有哪些？

│ │ │ ├─“他山之石”｜Sugar：这门课你可以试试这么学

│ │ │ ├─“屠龙之秘”｜实现计算机语言这样的技术能用在哪里？（一）

│ │ │ ├─开篇词｜让我们来写一门计算机语言吧

│ │ │ ├─期中测试｜快来检验你在起步篇的学习成果吧

│ │ │ ├─期末考试｜实现编程语言这些核心知识点，你掌握得咋样了？

│ │ │ ├─结束语｜等待你大展身手的那些领域

│ │ │ ├─课前热身｜开始学习之前我们要准备什么？

│ │ │ └─课前热身｜开始学习之前我们要准备什么？

│ │ ├─163零基础实战机器学习

│ │ │ ├─01｜打好基础：到底什么是机器学习？

│ │ │ ├─02｜工具准备：安装并使用JupyterNotebook

│ │ │ ├─03｜实战5步（上）：怎么定义问题和预处理数据？

│ │ │ ├─04｜实战5步（下）：怎么建立估计10万+软文点击率的模型？

│ │ │ ├─05-数据探索：怎样从数据中找到用户的RFM值？

│ │ │ ├─06-聚类分析：如何用RFM给电商用户做价值分组画像？

│ │ │ ├─07｜回归分析：怎样用模型预测用户的生命周期价值？

│ │ │ ├─08-模型优化（上）：怎么用特征工程提高模型效率？

│ │ │ ├─09｜模型优化（中）：防止过拟合，模型也不能太精细

│ │ │ ├─10｜模型优化（下）：交叉验证，同时寻找最优的参数

│ │ │ ├─11｜深度学习（上）：用CNN带你认识深度学习

│ │ │ ├─12｜深度学习（中）：如何用RNN预测激活率走势？

│ │ │ ├─13｜深度学习（下）：3招提升神经网络预测准确率

│ │ │ ├─14｜留存分析：哪些因素会影响用户的留存率？

│ │ │ ├─15｜二元分类：怎么预测用户是否流失？从逻辑回归到深度学习

│ │ │ ├─163零基础实战机器学习

│ │ │ ├─16｜性能评估：不平衡数据集应该使用何种评估指标？

│ │ │ ├─17｜集成学习：机器学习模型如何“博采众长”

│ │ │ ├─18-增长模型：用XGBoost评估裂变海报的最佳受众群体

│ │ │ ├─19-胸有成竹：如何快速定位合适的机器学习算法？

│ │ │ ├─20-模型部署：怎么发布训练好的机器学习模型？

│ │ │ ├─21｜持续精进：如何在机器学习领域中找准前进的方向？

│ │ │ ├─一套习题，测出你对机器学习的掌握程度

│ │ │ ├─开篇词｜开发者为什么要从实战出发学机器学习？

│ │ │ ├─结束语-可以不完美，但重要的是马上开始

│ │ │ └─结束语-可以不完美，但重要的是马上开始

│ │ ├─164零基础入门Spark

│ │ │ ├─01｜Spark：从“大数据的HelloWorld”开始

│ │ │ ├─02-RDD与编程模型：延迟计算是怎么回事？

│ │ │ ├─03-RDD常用算子（一）：RDD内部的数据转换

│ │ │ ├─04-进程模型与分布式部署：分布式计算是怎么回事？

│ │ │ ├─05-调度系统：如何把握分布式计算的精髓？

│ │ │ ├─06-Shuffle管理：为什么Shuffle是性能瓶颈？

│ │ │ ├─07-RDD常用算子（二）：Spark如何实现数据聚合？

│ │ │ ├─08-内存管理：Spark如何使用内存？

│ │ │ ├─09-RDD常用算子（三）：数据的准备、重分布与持久化

│ │ │ ├─10-广播变量&累加器：共享变量是用来做什么的？

│ │ │ ├─11-存储系统：数据到底都存哪儿了？

│ │ │ ├─12-基础配置详解：哪些参数会影响应用程序稳定性？

│ │ │ ├─13-SparkSQL：让我们从“小汽车摇号分析”开始

│ │ │ ├─14-台前幕后：DataFrame与SparkSQL的由来

│ │ │ ├─15-数据源与数据格式：DataFrame从何而来？

│ │ │ ├─16-数据转换：如何在DataFrame之上做数据处理？

│ │ │ ├─164零基础入门Spark

│ │ │ ├─17-数据关联：不同的关联形式与实现机制该怎么选？

│ │ │ ├─18-数据关联优化：都有哪些Join策略，开发者该如何取舍？

│ │ │ ├─19-配置项详解：哪些参数会影响应用程序执行性能？

│ │ │ ├─20-Hive+Spark强强联合：分布式数仓的不二之选

│ │ │ ├─21｜SparkUI（上）：如何高效地定位性能问题？

│ │ │ ├─22｜SparkUI（下）：如何高效地定位性能问题？

│ │ │ ├─23-SparkMLlib：从“房价预测”开始

│ │ │ ├─24-特征工程（上）：有哪些常用的特征处理函数？

│ │ │ ├─25-特征工程（下）：有哪些常用的特征处理函数？

│ │ │ ├─26-模型训练（上）：决策树系列算法详解

│ │ │ ├─27-模型训练（中）：回归、分类和聚类算法详解

│ │ │ ├─28-模型训练（下）：协同过滤与频繁项集算法详解

│ │ │ ├─29-SparkMLlibPipeline：高效开发机器学习应用

│ │ │ ├─30｜StructuredStreaming：从“流动的WordCount”开始

│ │ │ ├─31｜新一代流处理框架：Batchmode和Continuousmode哪家强？

│ │ │ ├─32｜Window操作&Watermark：流处理引擎提供了哪些优秀机制？

│ │ │ ├─33｜流计算中的数据关联：流与流、流与批

│ │ │ ├─34｜Spark+Kafka：流计算中的“万金油”

│ │ │ ├─开篇词-入门Spark，你需要学会“三步走”

│ │ │ ├─用户故事-小王：保持空杯心态，不做井底之蛙

│ │ │ ├─结束语-进入时间裂缝，持续学习

│ │ │ └─结束语-进入时间裂缝，持续学习

│ │ ├─165手把手带你写一个Web框架

│ │ │ ├─01｜net-http：使用标准库搭建Server并不是那么简单

│ │ │ ├─02｜Context：请求控制器，让每个请求都在掌控之中

│ │ │ ├─03｜路由：如何让请求更快寻找到目标函数？

│ │ │ ├─04｜中间件：如何提高框架的可拓展性？

│ │ │ ├─05｜封装：如何让你的框架更好用？

│ │ │ ├─06｜重启：如何进行优雅关闭？

│ │ │ ├─07｜目标：站在巨人肩膀，你的理想框架到底长什么样？

│ │ │ ├─08｜自研or借力（上）：集成Gin替换已有核心

│ │ │ ├─09｜自研or借力（下）：集成Gin替换已有核心

│ │ │ ├─10｜面向接口编程（上）：一切皆服务，服务基于协议

│ │ │ ├─11｜面向接口编程（下）：一切皆服务，服务基于协议

│ │ │ ├─12｜结构：如何系统设计框架的整体目录？

│ │ │ ├─13｜交互：可以执行命令行的框架才是好框架

│ │ │ ├─14｜定时任务：如何让框架支持分布式定时脚本？

│ │ │ ├─15｜配置和环境（上）：配置服务中的设计思路

│ │ │ ├─165手把手带你写一个Web框架

│ │ │ ├─16｜配置和环境（下）：配置服务中的设计思路

│ │ │ ├─17｜日志：如何设计多输出的日志服务？

│ │ │ ├─18｜一体化：前端和后端一定要项目分开吗

│ │ │ ├─19｜提效（上）：实现调试模式加速开发效率

│ │ │ ├─20｜提效（下）：实现调试模式加速开发效率

│ │ │ ├─21｜自动化（上）：DRY，如何自动化一切重复性劳动？

│ │ │ ├─22｜自动化（下）：DRY，如何自动化一切重复性劳动？

│ │ │ ├─23｜管理接口：如何集成swagger自动生成文件？

│ │ │ ├─24｜管理进程：如何设计完善的运行命令？

│ │ │ ├─25｜GORM（上）：数据库的使用必不可少

│ │ │ ├─26｜GORM（下）：数据库的使用必不可少

│ │ │ ├─27｜缓存服务：如何基于Redis实现封装？

│ │ │ ├─28｜SSH：如何生成发布系统让框架发布自动化？

│ │ │ ├─29｜周边：框架发布和维护也是重要的一环

│ │ │ ├─30｜设计先于实战：需求设计和框架搭建

│ │ │ ├─31｜通用模块（上）：用户模块开发

│ │ │ ├─32｜通用模块（下）：用户模块开发

│ │ │ ├─33｜业务开发（上）：问答业务开发

│ │ │ ├─34｜业务开发（下）：问答业务开发

│ │ │ ├─加餐｜国庆特别放送：什么是业务架构，什么是基础架构？

│ │ │ ├─加餐｜阶段答疑：这些代码里的小知识点你都知道吗？

│ │ │ ├─大咖助阵｜大明：抽象，抽象，还是抽象

│ │ │ ├─大咖助阵｜飞雪无情：十年面试经验忠告，不要被框架所束缚

│ │ │ ├─开篇词｜为什么我们要从零开发框架？

│ │ │ ├─结束语｜在语言的上升期投入最大热情，是最正确的投资

│ │ │ └─结束语｜在语言的上升期投入最大热情，是最正确的投资

│ │ ├─166大数据经典论文解读

│ │ │ ├─01-什么是大数据：从GFS到Dataflow，12年大数据生态演化图

│ │ │ ├─02-学习方法：建立你的大数据知识网络

│ │ │ ├─03-TheGoogleFileSystem（一）：Master的三个身份

│ │ │ ├─04-TheGoogleFileSystem（二）：如何应对网络瓶颈？

│ │ │ ├─05-TheGoogleFileSystem（三）：多写几次也没关系

│ │ │ ├─06-MapReduce（一）：源起Unix的设计思想

│ │ │ ├─07-MapReduce（二）：不怕失败的计算框架

│ │ │ ├─08-Bigtable（一）：错失百亿的Friendster

│ │ │ ├─09-Bigtable（二）：不认识“主人”的分布式架构

│ │ │ ├─10-Bigtable（三）：SSTable存储引擎详解

│ │ │ ├─11-通过Thrift序列化：我们要预知未来才能向后兼容吗？

│ │ │ ├─12-分布式锁Chubby（一）：交易之前先签合同

│ │ │ ├─13-分布式锁Chubby（二）：众口铄金的真相

│ │ │ ├─14-分布式锁Chubby（三）：移形换影保障高可用

│ │ │ ├─15-Hive：来来去去的DSL，永生不死的SQL

│ │ │ ├─16-从Dremel到Parquet（一）：深入剖析列式存储

│ │ │ ├─166大数据经典论文解读

│ │ │ ├─17-从Dremel到Parquet（二）：他山之石的MPP数据库

│ │ │ ├─18-Spark：别忘了内存比磁盘快多少

│ │ │ ├─19-Megastore（一）：全国各地都能写入的数据库

│ │ │ ├─20-Megastore（二）：把Bigtable玩出花来

│ │ │ ├─21-Megastore（三）：让Paxos跨越“国界”

│ │ │ ├─22-Spanner（一）：“重写”Bigtable和Megastore(1)

│ │ │ ├─22-Spanner（一）：“重写”Bigtable和Megastore

│ │ │ ├─23-Spanner（二）：时间的悖论

│ │ │ ├─24-Spanner（三）：严格串行化的分布式系统

│ │ │ ├─25-从S4到Storm（一）：当分布式遇上实时计算

│ │ │ ├─26-从S4到Storm（二）：位运算是个好东西

│ │ │ ├─27-Kafka（一）：消息队列的新标准

│ │ │ ├─28-Kafka（二）：从Lambda到Kappa，流批一体计算的起源

│ │ │ ├─29-Dataflow（一）：正确性、容错和时间窗口

│ │ │ ├─30-Dataflow（二）：MillWheel，一个早期实现

│ │ │ ├─31-Dataflow（三）：一个统一的编程模型

│ │ │ ├─32-Raft（一）：不会背叛的信使

│ │ │ ├─33-Raft（二）：服务器增减的“自举”实现

│ │ │ ├─34-Borg（一）：当电力成为成本瓶颈

│ │ │ ├─35-Borg（二）：互不“信任”的调度系统

│ │ │ ├─36-从Omega到Kubernetes：哺育云原生的开源项目

│ │ │ ├─37-当数据遇上AI，Twitter的数据挖掘实战（一）

│ │ │ ├─38-当数据遇上AI，Twitter的数据挖掘实战（二）

│ │ │ ├─39-十年一梦，一起来看Facebook的数据仓库变迁（一）

│ │ │ ├─40-十年一梦，一起来看Facebook的数据仓库变迁（二）

│ │ │ ├─加餐1-选择和努力同样重要：聊聊如何读论文和选论文

│ │ │ ├─加餐2-设置你的学习“母题”：如何选择阅读材料？

│ │ │ ├─加餐3-我该使用什么样的大数据系统？

│ │ │ ├─复习课（一）-TheGoogleFileSystem

│ │ │ ├─复习课（七）-Dremel

│ │ │ ├─复习课（三）-Bigtable

│ │ │ ├─复习课（九）-Megastore

│ │ │ ├─复习课（二）-MapReduce

│ │ │ ├─复习课（五）-Chubby

│ │ │ ├─复习课（八）-ResilientDistributedDatasets

│ │ │ ├─复习课（六）-Hive

│ │ │ ├─复习课（十）-Spanner

│ │ │ ├─复习课（四）-Thrift

│ │ │ ├─开篇词-读论文是成为优秀工程师的成年礼

│ │ │ ├─用户故事-核桃：95后的技术成长之路

│ │ │ ├─用户故事-许灵：不抛弃不放弃

│ │ │ ├─用户故事-陈煌：唯有自强不息，方能屹立不倒

│ │ │ ├─用户故事-黄涛：水滴石穿、坚持不懈，必能有所精进

│ │ │ ├─结束语-长风破浪会有时，直挂云帆济沧海

│ │ │ └─结束语-长风破浪会有时，直挂云帆济沧海

│ │ ├─167手把手带你搭建秒杀系统

│ │ │ ├─01｜直面痛点：秒杀系统的挑战和设计原则

│ │ │ ├─02｜蓄势待发：秒杀系统架构设计和环境准备

│ │ │ ├─03-指日可待：一步一步搭建秒杀系统（上）

│ │ │ ├─04-指日可待：一步一步搭建秒杀系统（下）

│ │ │ ├─05｜勇于担当：秒杀的隔离策略

│ │ │ ├─06｜谋定后动：秒杀的流量管控

│ │ │ ├─07｜乾坤大挪移：秒杀的削峰和限流

│ │ │ ├─08｜化骨绵掌：降级、热点和容灾处理

│ │ │ ├─09｜御敌国门外：黑产对抗——防刷和风控

│ │ │ ├─10｜不差毫厘：秒杀的库存与限购

│ │ │ ├─11｜高性能优化：物理机极致优化

│ │ │ ├─12｜高性能优化：单机Java极致优化

│ │ │ ├─13｜优化番外篇：Vertx介绍及快速入门

│ │ │ ├─14｜百万级流量秒杀系统的关键总结

│ │ │ ├─167手把手带你搭建秒杀系统

│ │ │ ├─加餐｜高并发场景：如何提升对突发事件的应急处理能力？

│ │ │ ├─开篇词｜如何设计一个高并发、高可用的秒杀系统？

│ │ │ ├─期末测试｜来赴一场满分之约吧！

│ │ │ ├─结束语｜秒杀系统之上的业务协同思考

│ │ │ └─结束语｜秒杀系统之上的业务协同思考

│ │ ├─168PyTorch深度学习实战

│ │ │ ├─01-PyTorch：网红中的顶流明星

│ │ │ ├─02-NumPy（上）：核心数据结构详解

│ │ │ ├─03-NumPy（下）：深度学习中的常用操作

│ │ │ ├─04-Tensor：PyTorch中最基础的计算单元

│ │ │ ├─05-Tensor变形记：快速掌握Tensor切分、变形等方法

│ │ │ ├─06-Torchvision（上）：数据读取，训练开始的第一步

│ │ │ ├─07-Torchvision（中）：数据增强，让数据更加多样性

│ │ │ ├─08-Torchvision（下）：其他有趣的功能

│ │ │ ├─09-卷积（上）：如何用卷积为计算机“开天眼”？

│ │ │ ├─10-卷积（下）：如何用卷积为计算机“开天眼”？

│ │ │ ├─11-损失函数：如何帮助模型学会“自省”？

│ │ │ ├─12-计算梯度：网络的前向与反向传播

│ │ │ ├─13-优化方法：更新模型参数的方法

│ │ │ ├─14-构建网络：一站式实现模型搭建与训练

│ │ │ ├─15-可视化工具：如何实现训练的可视化监控？

│ │ │ ├─168PyTorch深度学习实战

│ │ │ ├─16｜分布式训练：如何加速你的模型训练？

│ │ │ ├─17-图像分类（上）：图像分类原理与图像分类模型

│ │ │ ├─18-图像分类（下）：如何构建一个图像分类模型

│ │ │ ├─19-图像分割（上）：详解图像分割原理与图像分割模型

│ │ │ ├─20-图像分割（下）：如何构建一个图像分割模型？

│ │ │ ├─21-NLP基础（上）：详解自然语言处理原理与常用算法

│ │ │ ├─22-NLP基础（下）：详解语言模型与注意力机制

│ │ │ ├─23-情感分析：如何使用LSTM进行情感分析？

│ │ │ ├─24-文本分类：如何使用BERT构建文本分类模型？

│ │ │ ├─25-摘要：如何快速实现自动文摘生成？

│ │ │ ├─加餐-机器学习其实就那么几件事

│ │ │ ├─开篇词-如何高效入门PyTorch？

│ │ │ ├─用户故事-Tango：师傅领进门，修行在个人

│ │ │ ├─答疑篇｜思考题答案集锦

│ │ │ ├─结束语｜人生充满选择，选择与努力同样重要

│ │ │ └─结束语｜人生充满选择，选择与努力同样重要

│ │ ├─169TonyBai·Go语言第一课

│ │ │ ├─01｜前世今生：你不得不了解的Go的历史和现状

│ │ │ ├─02｜拒绝“HelloandBye”：Go语言的设计哲学是怎么一回事？

│ │ │ ├─03｜配好环境：选择一种最适合你的Go安装方法

│ │ │ ├─04｜初窥门径：一个Go程序的结构是怎样的？

│ │ │ ├─05｜标准先行：Go项目的布局标准是什么？

│ │ │ ├─06｜构建模式：Go是怎么解决包依赖管理问题的？

│ │ │ ├─07｜构建模式：GoModule的6类常规操作

│ │ │ ├─08｜入口函数与包初始化：搞清Go程序的执行次序

│ │ │ ├─09｜即学即练：构建一个Web服务就是这么简单

│ │ │ ├─10｜变量声明：静态语言有别于动态语言的重要特征

│ │ │ ├─11｜代码块与作用域：如何保证变量不会被遮蔽？

│ │ │ ├─12｜基本数据类型：Go原生支持的数值类型有哪些？

│ │ │ ├─13｜基本数据类型：为什么Go要原生支持字符串类型？

│ │ │ ├─14｜常量：Go在“常量”设计上的创新有哪些？

│ │ │ ├─15｜同构复合类型：从定长数组到变长切片

│ │ │ ├─169TonyBai·Go语言第一课

│ │ │ ├─16｜复合数据类型：原生map类型的实现机制是怎样的？

│ │ │ ├─17｜复合数据类型：用结构体建立对真实世界的抽象

│ │ │ ├─18｜控制结构：if的“快乐路径”原则

│ │ │ ├─19｜控制结构：Go的for循环，仅此一种

│ │ │ ├─20｜控制结构：Go中的switch语句有哪些变化？

│ │ │ ├─21｜函数：请叫我“一等公民”

│ │ │ ├─22｜函数：怎么结合多返回值进行错误处理？

│ │ │ ├─23｜函数：怎么让函数更简洁健壮？

│ │ │ ├─24｜方法：理解“方法”的本质

│ │ │ ├─25｜方法：方法集合与如何选择receiver类型？

│ │ │ ├─26｜方法：如何用类型嵌入模拟实现“继承”？

│ │ │ ├─27｜即学即练：跟踪函数调用链，理解代码更直观

│ │ │ ├─28｜接口：接口即契约

│ │ │ ├─29｜接口：为什么nil接口不等于nil？

│ │ │ ├─30｜接口：Go中最强大的魔法

│ │ │ ├─31｜并发：Go的并发方案实现方案是怎样的？

│ │ │ ├─32｜并发：聊聊Goroutine调度器的原理

│ │ │ ├─33｜并发：小channel中蕴含大智慧

│ │ │ ├─34｜并发：如何使用共享变量？

│ │ │ ├─35｜即学即练：如何实现一个轻量级线程池？

│ │ │ ├─36｜打稳根基：怎么实现一个TCP服务器？（上）

│ │ │ ├─37｜代码操练：怎么实现一个TCP服务器？（中）

│ │ │ ├─38｜成果优化：怎么实现一个TCP服务器？（下）

│ │ │ ├─39-驯服泛型：了解类型参数

│ │ │ ├─40｜驯服泛型：定义泛型约束

│ │ │ ├─41-驯服泛型：明确使用时机

│ │ │ ├─元旦快乐｜这是一份暂时停更的声明

│ │ │ ├─加餐｜作为GoModule的作者，你应该知道的几件事

│ │ │ ├─加餐｜如何拉取私有的GoModule？

│ │ │ ├─加餐｜我“私藏”的那些优质且权威的Go语言学习资料

│ │ │ ├─加餐｜聊聊Go1

│ │ │ ├─加餐｜聊聊Go语言的指针

│ │ │ ├─加餐｜聊聊最近大热的Go泛型

│ │ │ ├─大咖助阵｜叶剑峰：Go语言中常用的那些代码优化点

│ │ │ ├─大咖助阵｜大明：Go泛型，泛了，但没有完全泛

│ │ │ ├─大咖助阵｜孔令飞：从小白到“老鸟”，我的Go语言进阶之路

│ │ │ ├─大咖助阵｜徐祥曦：从销售到分布式存储工程师，我与Go的故事

│ │ │ ├─大咖助阵｜曹春晖：聊聊Go语言的GC实现

│ │ │ ├─大咖助阵｜海纳：聊聊语言中的类型系统与泛型

│ │ │ ├─开篇词｜这样入门Go，才能少走弯路

│ │ │ ├─期中测试｜一起检验下你的学习成果吧

│ │ │ ├─用户故事｜罗杰：我的Go语言学习之路

│ │ │ ├─结束语｜和你一起迎接Go的黄金十年

│ │ │ ├─结课测试｜快来检验下你的学习成果吧！

│ │ │ └─结课测试｜快来检验下你的学习成果吧！

│ │ ├─170玩转Vue3全家桶

│ │ │ ├─01-宏观视角：从前端框架发展史聊聊为什么要学Vue3？

│ │ │ ├─02-上手：一个清单应用帮你入门Vue

│ │ │ ├─03-新特性：初探Vue3新特性

│ │ │ ├─04-升级：Vue2项目如何升级到Vue3？

│ │ │ ├─05-项目启动：搭建Vue3工程化项目第一步

│ │ │ ├─06-新的代码组织方式：CompositionAPI+-scriptsetup-到底好在哪里？

│ │ │ ├─07-巧妙的响应式：深入理解Vue3的响应式机制

│ │ │ ├─08-组件化：如何像搭积木一样开发网页？

│ │ │ ├─09-动画：Vue中如何实现动画效果？

│ │ │ ├─10-数据流：如何使用Vuex设计你的数据流

│ │ │ ├─11-路由：新一代vue-router带来什么变化

│ │ │ ├─12-调试：提高开发效率必备的VueDevtools

│ │ │ ├─13-JSX：如何利用JSX应对更灵活的开发场景？

│ │ │ ├─14-TypeScript：Vue3中如何使用TypeScript？

│ │ │ ├─15-实战痛点1：复杂Vue项目的规范和基础库封装

│ │ │ ├─16-实战痛点2：项目开发中的权限系统

│ │ │ ├─17-实战痛点3：Vue3中如何集成第三方框架

│ │ │ ├─170玩转Vue3全家桶

│ │ │ ├─18-实战痛点4：Vue3项目中的性能优化

│ │ │ ├─19-实战痛点5：如何打包发布你的Vue3应用？

│ │ │ ├─20｜组件库：如何设计你自己的通用组件库？

│ │ │ ├─21-单元测试：如何使用TDD开发一个组件？

│ │ │ ├─22｜表单：如何设计一个表单组件？

│ │ │ ├─23-弹窗：如何设计一个弹窗组件？

│ │ │ ├─24｜树：如何设计一个树形组件？

│ │ │ ├─25｜表格：如何设计一个表格组件？

│ │ │ ├─26｜文档：如何给你的组件库设计一个可交互式文档？

│ │ │ ├─27｜自定义渲染器：如何实现Vue的跨端渲染？

│ │ │ ├─28｜响应式：万能的面试题，怎么手写响应式系统

│ │ │ ├─29｜运行时：Vue在浏览器里是怎么跑起来的？

│ │ │ ├─30｜虚拟DOM（上）：如何通过虚拟DOM更新页面？

│ │ │ ├─31｜虚拟DOM（下）：想看懂虚拟DOM算法，先刷个算法题

│ │ │ ├─32｜编译原理（上）：手写一个迷你Vue3Compiler的入门原理

│ │ │ ├─33-编译原理（中）：VueCompiler模块全解析

│ │ │ ├─34-编译原理（下）：编译原理给我们带来了什么？

│ │ │ ├─35｜Vite原理：写一个迷你的Vite

│ │ │ ├─36｜数据流原理：Vuex&Pinia源码剖析

│ │ │ ├─37｜前端路由原理：vue-router源码剖析

│ │ │ ├─38｜服务端渲染原理：Vue3中的SSR是如何实现的？

│ │ │ ├─加餐01｜什么是好的项目？

│ │ │ ├─加餐02｜深入TypeScript

│ │ │ ├─开篇词-如何借助Vue3建构你的前端知识体系？

│ │ │ ├─用户故事｜有了手感，才能真正把知识学透

│ │ │ ├─结束语｜Vue3生态源码到底给我们带来了什么？

│ │ │ └─结束语｜Vue3生态源码到底给我们带来了什么？

│ │ ├─171全链路压测实战30讲

│ │ │ ├─01-全链路压测：为什么很多测试人员迷信它？

│ │ │ ├─02-RESAR全链路流程：如何搞定所有容量场景？

│ │ │ ├─03-压测方案：你是否忽略了一个重量级文档？

│ │ │ ├─04-核心链路：如何梳理符合真实业务场景的核心链路？

│ │ │ ├─05-铺底数据：真实的压测数据应该做成什么样子？

│ │ │ ├─06-流量构建：流量平台如何选型？

│ │ │ ├─07-全栈监控：如何设计全栈监控策略？

│ │ │ ├─08-基础设施：全链路压测的环境有什么特点？

│ │ │ ├─09-压测模型：如何建立一套完整的全链路压测模型？

│ │ │ ├─10-场景执行：压测执行过程中的关键步骤是什么？

│ │ │ ├─11-链路追踪：如何选择一款适合自己项目的工具？

│ │ │ ├─12-链路追踪：如何对一个具体的项目进行追踪改造？

│ │ │ ├─13-标记透传：微服务系统如何做标记透传方案选型？

│ │ │ ├─14-标记透传：如何基于微服务技术进行标记透传？

│ │ │ ├─15-流量隔离：MySQL数据库隔离是怎么做的？

│ │ │ ├─16-流量隔离：Redis缓存隔离是怎么做的？

│ │ │ ├─17-流量隔离：MongoDB数据库隔离是怎么做的？

│ │ │ ├─171全链路压测实战30讲

│ │ │ ├─18-流量隔离：RabbitMQ消息隔离是怎么做的？

│ │ │ ├─19｜日志隔离：如何落地日志隔离？

│ │ │ ├─20-Mock：如何屏蔽第三方接口的影响？

│ │ │ ├─21-压测平台：高效搭建GoReplay压测平台

│ │ │ ├─22-压测平台：如何解决GoReplay动态数据关联？

│ │ │ ├─23-压测平台：如何改造对象存储和性能监控？

│ │ │ ├─24-压测平台：如何改造分布式调度平台？

│ │ │ ├─25-环境搭建：我们的系统是怎么搭建起来的？

│ │ │ ├─26-全局监控（上）：如何快速落地全局监控？

│ │ │ ├─27-全局监控（下）：如何快速落地全局监控？

│ │ │ ├─28-定向监控：怎样快速发现业务异常？

│ │ │ ├─29-基准场景：一个案例，带你搞懂基准场景的关键要点

│ │ │ ├─30-预压测：如何基于小流量快速验证容量压测效果？

│ │ │ ├─31-容量场景：决定线上容量场景的关键因素是什么？

│ │ │ ├─32-稳定性场景：怎样搞定线上稳定性场景？

│ │ │ ├─33-异常场景：如何模拟线上不同组件的异常场景？

│ │ │ ├─34-容量规划：如何精准地对生产系统做容量预估？

│ │ │ ├─35-压测报告：怎样写出一份让老板满意的报告？

│ │ │ ├─开篇词-打破认知神话，做接地气的全链路压测

│ │ │ ├─期末考试-《全链路压测实战30讲》满分试卷，等你来挑战！

│ │ │ ├─结束语-做能落地的全链路压测项目

│ │ │ └─结束语-做能落地的全链路压测项目

│ │ ├─172编程高手必学的内存知识

│ │ │ ├─01｜虚拟内存：为什么可用内存会远超物理内存？

│ │ │ ├─02｜聊聊x86体系架构中的实模式和保护模式

│ │ │ ├─03-内存布局：应用程序是如何安排数据的？

│ │ │ ├─04-深入理解栈：从CPU和函数的视角看栈的管理

│ │ │ ├─05-栈的魔法：从栈切换的角度理解进程和协程

│ │ │ ├─06-静态链接：变量与内存地址是如何映射的？

│ │ │ ├─07-动态链接（上）：地址无关代码是如何生成的？

│ │ │ ├─08-动态链接（下）：延迟绑定与动态链接器是什么？

│ │ │ ├─09-深入理解堆：malloc和内存池是怎么回事？

│ │ │ ├─10-页中断：fork、mmap背后的保护神

│ │ │ ├─11-即时编译：高性能JVM的核心秘密

│ │ │ ├─12-内存虚拟化：云原生时代的奠基者

│ │ │ ├─13-存储电路：计算机存储芯片的电路结构是怎样的？

│ │ │ ├─14-CPUCache：访存速度是如何大幅提升的？

│ │ │ ├─15-MESI协议：多核CPU是如何同步高速缓存的？

│ │ │ ├─16-内存模型：有了MESI为什么还需要内存屏障？

│ │ │ ├─17-NUMA：非均匀访存带来了哪些提升与挑战？

│ │ │ ├─172编程高手必学的内存知识

│ │ │ ├─18-Java内存模型：Java中的volatile有什么用？

│ │ │ ├─19-垃圾回收：如何避免内存泄露？

│ │ │ ├─20-Scavenge：基于copy的垃圾回收算法

│ │ │ ├─21-分代算法：基于生命周期的内存管理

│ │ │ ├─22-G1GC：分区回收算法说的是什么？

│ │ │ ├─23-PauselessGC：挑战无暂停的垃圾回收

│ │ │ ├─24-GC实例：Python和Go的内存管理机制是怎样的？

│ │ │ ├─不定期福利第一期-海纳：我是如何学习计算机知识的？

│ │ │ ├─不定期福利第二期-软件篇答疑

│ │ │ ├─导学（一）-拆解CPU的基本结构和运行原理

│ │ │ ├─导学（三）-一个CPU是怎么寻址的？

│ │ │ ├─导学（二）-汇编语言是怎么一回事？

│ │ │ ├─开篇词｜为什么你要系统学习计算机的内存知识？

│ │ │ ├─期末测试-来赴一场满分之约吧！

│ │ │ ├─直播加餐｜链接器和加载器是如何为你工作的？（合集）

│ │ │ ├─结束语-自主基础软件开发的那片星辰大海

│ │ │ └─结束语-自主基础软件开发的那片星辰大海

│ │ ├─173超级访谈：对话张雪峰

│ │ │ ├─01-收购百度外卖：“土八路”收购“正规军”

│ │ │ ├─02-饿了么上海本土团队和百度外卖北京团队的冲突

│ │ │ ├─03-不够果敢带来的内耗

│ │ │ ├─04-“戏剧性”的裁员，反思组织融合之难“难于上青天”

│ │ │ ├─05-职业成长：从校园到职场的蜕变

│ │ │ ├─06-拆解CTO：CTO的岗位职责

│ │ │ ├─07-对程序员来说，自由价更高

│ │ │ ├─08-50X增长：管理35到1800人团队的难题

│ │ │ ├─09-如何用人？

│ │ │ ├─10-管理的不足：不团建，管理不到毛细血管

│ │ │ ├─11-CTO要给自己找backup

│ │ │ ├─12-CTO的艰难时刻：差点引咎辞职

│ │ │ ├─13-大的决策与难做的决策

│ │ │ ├─14-不够坚定：异地多活没有一步到位的遗憾

│ │ │ ├─15-兴趣与个人认知

│ │ │ ├─173超级访谈：对话张雪峰

│ │ │ ├─有奖征集！你填写毕业问卷了吗？

│ │ │ ├─篇首语-张雪峰：我参与的饿了么成长轨迹中，这些事需要反思

│ │ │ └─篇首语-张雪峰：我参与的饿了么成长轨迹中，这些事需要反思

│ │ ├─174深入剖析Java新特性

│ │ │ ├─01-JShell：怎么快速验证简单的小问题？

│ │ │ ├─02-文字块：怎么编写所见即所得的字符串？

│ │ │ ├─03-档案类：怎么精简地表达不可变数据？

│ │ │ ├─04-封闭类：怎么刹住失控的扩展性？

│ │ │ ├─05-类型匹配：怎么切除臃肿的强制转换？

│ │ │ ├─06-switch表达式：怎么简化多情景操作？

│ │ │ ├─07-switch匹配：能不能适配不同的类型？

│ │ │ ├─08-抛出异常，是不是错误处理的第一选择？

│ │ │ ├─09-异常恢复，付出的代价能不能少一点？

│ │ │ ├─10-Flow，是异步编程的终极选择吗？

│ │ │ ├─11-矢量运算：Java的机器学习要来了吗？

│ │ │ ├─12-外部内存接口：零拷贝的障碍还有多少？

│ │ │ ├─13-外部函数接口，能不能取代Java本地接口？

│ │ │ ├─14-禁止空指针，该怎么避免崩溃的空指针？

│ │ │ ├─15-现代密码：你用的加密算法过时了吗？

│ │ │ ├─16-改进的废弃，怎么避免使用废弃的特性？

│ │ │ ├─17-模块系统：为什么Java需要模块化？

│ │ │ ├─174深入剖析Java新特性

│ │ │ ├─18-模块系统：怎么模块化你的应用程序？

│ │ │ ├─开篇词-拥抱Java新特性，像设计者一样工作和思考

│ │ │ ├─用户故事-与新特性开发者对话

│ │ │ ├─用户故事-保持好奇心，积极拥抱变化

│ │ │ ├─结束语-Java的未来，依然是星辰大海

│ │ │ └─结束语-Java的未来，依然是星辰大海

│ │ ├─175攻克视频技术

│ │ │ ├─01｜基本概念：从参数的角度看视频图像

│ │ │ ├─02｜YUV&RGB：原来图像是这么丰富多彩的

│ │ │ ├─03｜缩放算法：如何高质量地缩放图像？

│ │ │ ├─04｜编码原理：视频究竟是怎么编码压缩的？

│ │ │ ├─05｜码流结构：原来你是这样的H264

│ │ │ ├─06｜帧内预测：如何减少空间冗余？

│ │ │ ├─07｜帧间预测：如何减少时间冗余？

│ │ │ ├─08｜变换量化：如何减少视觉冗余？

│ │ │ ├─09｜RTP&RTCP：如何正确地将视频装进RTP中？

│ │ │ ├─10｜带宽预测：3大算法准确预估网络带宽

│ │ │ ├─11｜码控算法：如何控制视频的编码码率？

│ │ │ ├─12｜JitterBuffer：拿什么拯救你，花屏卡顿问题

│ │ │ ├─13｜SVC：如何实现视频编码可伸缩？

│ │ │ ├─14｜MP4&FLV：不要再说AVI了

│ │ │ ├─15｜音画同步：如何让声音和画面手拉手前进？

│ │ │ ├─175攻克视频技术

│ │ │ ├─加餐｜基于纯浏览器的视频会议方案探究

│ │ │ ├─开篇词｜为什么说视频开发是程序员的一片蓝海？

│ │ │ ├─结束语｜信心比黄金更重要

│ │ │ └─结束语｜信心比黄金更重要

│ │ ├─176搞定音频技术

│ │ │ ├─01｜声音是如何保存成数字信号的？

│ │ │ ├─02｜如何量化分析语音信号？

│ │ │ ├─03｜如何分析与处理音乐信号？

│ │ │ ├─04｜如何评价音频质量的好与坏？

│ │ │ ├─05｜音频降噪如何对症下药？

│ │ │ ├─06｜如何将AI技术运用到降噪中？

│ │ │ ├─07｜如何通过算法自动快速地消除回声？

│ │ │ ├─08｜回声消除算法实践指南

│ │ │ ├─09｜音频编解码器是如何工作的？

│ │ │ ├─10｜如何选择一个适合你的编解码器？

│ │ │ ├─11｜网络差怎么办？音频网络传输与抗弱网策略

│ │ │ ├─12｜空间音频入门：如何实现“声临其境”？

│ │ │ ├─13｜如何利用HRTF实现听音辨位？

│ │ │ ├─14｜音效三剑客：变调、均衡器、混响

│ │ │ ├─15｜AI变声：音频AI技术的集大成者

│ │ │ ├─176搞定音频技术

│ │ │ ├─加餐｜音频技术漫谈之好声音是怎么炼成的？

│ │ │ ├─开篇词｜实时互动强势发展，如何快速入门音频技术？

│ │ │ ├─结束语｜选择比努力更重要

│ │ │ └─结束语｜选择比努力更重要

│ │ ├─177郭东白的架构课

│ │ │ ├─01｜模块导学：是什么在影响架构活动的成败？

│ │ │ ├─02｜法则一：为什么有些架构活动会没有正确的目标？

│ │ │ ├─03｜法则一：如何找到唯一且正确的架构目标？

│ │ │ ├─04｜法则二：架构师为什么要学习马斯洛的需求理论？

│ │ │ ├─05｜法则二：研发人员的人性需求是如何影响架构活动成败的？

│ │ │ ├─06｜法则二：拼多多是如何通过洞察用户人性脱颖而出的？

│ │ │ ├─07｜法则三：架构师如何找到自己的商业模式？

│ │ │ ├─08｜法则三：架构师如何在一定时间内最大化自己的增量价值？

│ │ │ ├─09｜法则四：为什么要顺应技术的生命周期？

│ │ │ ├─10｜法则四：架构设计中怎么判断和利用技术趋势？

│ │ │ ├─11｜法则五：架构师为什么要关注技术体系的外部适应性？

│ │ │ ├─12｜法则五：如何提升一个架构设计的外部适应性？

│ │ │ ├─13｜法则六：如何鉴别文化环境是否有利于架构师的生存？

│ │ │ ├─14｜模块小结：这些生存法则的逻辑是什么？

│ │ │ ├─15｜模块导读：互联网时代架构师都面临哪些新挑战？

│ │ │ ├─16｜通用技能（上）：如何帮助团队达成共识与控制风险？

│ │ │ ├─177郭东白的架构课

│ │ │ ├─17｜通用技能（下）：架构师如何保障交付与沉淀知识？

│ │ │ ├─18｜节点一：架构活动中为什么要做环境搭建？

│ │ │ ├─19｜节点二：架构活动的目标为什么常常被忽略？

│ │ │ ├─20｜节点二：架构师如何为企业找到一个正确的目标？

│ │ │ ├─21｜节点三：如何通过可行性探索来帮助架构活动避免重大失误？

│ │ │ ├─22｜节点三：什么样的风险才算是重大风险？

│ │ │ ├─23｜节点四：架构规划之统一语义

│ │ │ ├─24｜节点四：如何减少语义上的分歧？

│ │ │ ├─25｜节点四：架构规划之需求确认

│ │ │ ├─26｜节点四：任务边界划分应该遵循哪些信条？

│ │ │ ├─27｜节点四：架构规划之划分任务边界

│ │ │ ├─28｜节点四：架构规划之确认规划完整性

│ │ │ ├─29｜节点五：项目启动仅仅是一个仪式吗？

│ │ │ ├─30｜节点六：如何保障高质量的阶段性交付？

│ │ │ ├─31｜节点六-如何组织阶段性的价值交付？

│ │ │ ├─32｜节点七：什么是有价值的复盘？

│ │ │ ├─33｜节点七：怎么样做好一个有长期收获的复盘？

│ │ │ ├─34｜模块小结：架构师如何在架构活动中持续创造价值？

│ │ │ ├─35｜模块导读：回过头来看，你觉得架构师到底是做什么的？

│ │ │ ├─36｜能力维度一：如何提升结构化设计的能力？

│ │ │ ├─37｜能力维度二：如何提升解决横向问题的能力？

│ │ │ ├─38｜能力维度三：如何提升解决跨领域冲突的能力？

│ │ │ ├─39｜能力维度四：如何从做技术到为企业创造生存优势？

│ │ │ ├─40｜职业成长（上）：架构师成长的必要条件是什么？

│ │ │ ├─41｜职业成长（下）：架构师成长的充分条件是什么？

│ │ │ ├─42｜职业选择：我应该去哪种类型的公司工作？

│ │ │ ├─43｜模块小结：什么是架构师成长的关键能力？

│ │ │ ├─44｜模块导读：假如我只能向上帝要一个技能

│ │ │ ├─45｜思维定势（上）：价值思维和实证思维

│ │ │ ├─46｜思维定势（下）：去中心化思维和成长思维

│ │ │ ├─47｜架构活动中的思维模式（上）：协同式的全方位思维和批判思维

│ │ │ ├─48｜架构活动中的思维模式（下）：实用主义和反思思维

│ │ │ ├─49｜往来无白丁：如何判断一个人的思考质量？

│ │ │ ├─50｜思考实例（上）：探险家Amundson是凭什么胜出的？

│ │ │ ├─51｜思考实例（下）：南极探险的第一性要素是什么？

│ │ │ ├─52｜思考实例（上）：中台既不是银弹，也不是哑弹

│ │ │ ├─53｜思考实例（下）：到底是什么因素左右了中台的成败？

│ │ │ ├─54｜模块小结：如何进一步提升自己的思考力？

│ │ │ ├─对话于冰（上）｜怎样成为那个有准备的人？

│ │ │ ├─对话于冰（下）｜架构师如何为企业创造商业价值？

│ │ │ ├─对话于冰（中）｜一个具有更高职业天花板的技术人，是怎样的？

│ │ │ ├─对话陈华良（上）｜跳槽时的决策逻辑是什么？

│ │ │ ├─对话陈华良（下）｜成长快的那些人，都有什么特性？

│ │ │ ├─开篇词｜没有战略意图，就成不了一个顶尖的架构师

│ │ │ ├─春节快乐｜一篇暂停更新的说明

│ │ │ ├─期末测试｜赴一场100分之约！

│ │ │ ├─直播加餐01｜技术战略到底是什么？

│ │ │ ├─直播加餐02｜阿里速卖通是如何在竞争变化中做技术战略的？

│ │ │ ├─结束语｜在小行星撞击地球之前为恐龙装上翅膀

│ │ │ ├─编辑加餐｜六张图，带你回顾架构师的六条生存法则

│ │ │ ├─编辑加餐｜十张图，带你回顾架构活动的完整过程

│ │ │ └─编辑加餐｜十张图，带你回顾架构活动的完整过程

│ │ ├─178深入C语言和程序运行原理

│ │ │ ├─01｜快速回顾：一个C程序的完整生命周期

│ │ │ ├─02｜程序基石：数据与量值是如何被组织的？

│ │ │ ├─03｜计算单元：运算符是如何工作的？

│ │ │ ├─04｜控制逻辑：表达式和语句是如何协调程序运行的？

│ │ │ ├─05｜代码封装（上）：函数是如何被调用的？

│ │ │ ├─06｜代码封装（下）：函数是如何被调用的？

│ │ │ ├─07｜整合数据：枚举、结构与联合是如何实现的？

│ │ │ ├─08｜操控资源：指针是如何灵活使用内存的？

│ │ │ ├─09｜编译准备：预处理器是怎样处理程序代码的？

│ │ │ ├─10｜标准库：字符、字符串处理与数学计算

│ │ │ ├─11｜标准库：深入理解标准IO

│ │ │ ├─12｜标准库：非本地跳转与可变参数是怎样实现的？

│ │ │ ├─13｜标准库：你需要了解的C并发编程基础知识有哪些？

│ │ │ ├─14｜标准库：如何使用互斥量等技术协调线程运行？

│ │ │ ├─15｜标准库：信号与操作系统软中断有什么关系？

│ │ │ ├─16｜标准库：日期、时间与实用函数

│ │ │ ├─178深入C语言和程序运行原理

│ │ │ ├─17｜标准库：断言、错误处理与对齐

│ │ │ ├─18｜极致优化（上）：如何实现高性能的C程序？

│ │ │ ├─19｜极致优化（下）：如何实现高性能的C程序？

│ │ │ ├─20｜生产加速：C项目需要考虑的编码规范有哪些？

│ │ │ ├─21｜生产加速：如何使用自动化测试确保C项目质量？

│ │ │ ├─22｜生产加速：如何使用结构化编译加速C项目构建？

│ │ │ ├─23｜实战项目（上）：一个简单的高性能HTTPServer

│ │ │ ├─24｜实战项目（下）：一个简单的高性能HTTPServer

│ │ │ ├─25｜可执行二进制文件里有什么？

│ │ │ ├─26｜进程是如何使用操作系统内存的？

│ │ │ ├─27｜编译器在链接程序时发生了什么？

│ │ │ ├─28｜程序可以在运行时进行链接吗？

│ │ │ ├─29｜C程序的入口真的是main函数吗？

│ │ │ ├─30｜ABI与API究竟有什么区别？

│ │ │ ├─31｜程序如何与操作系统交互？

│ │ │ ├─加餐-和C语言相比，C++有哪些不同的语言特性？

│ │ │ ├─大咖助阵｜LMOS：为什么说C语言是一把瑞士军刀？

│ │ │ ├─大咖助阵｜LMOS：用面向对象的思想开发C语言程序

│ │ │ ├─大咖助阵｜TonyBai：Go程序员拥抱C语言简明指南

│ │ │ ├─大咖助阵｜海纳：C语言是如何编译执行的？（一）

│ │ │ ├─大咖助阵｜海纳：C语言是如何编译执行的？（三）

│ │ │ ├─大咖助阵｜海纳：C语言是如何编译执行的？（二）

│ │ │ ├─大咖助阵｜罗剑锋：为什么NGINX是C编程的经典范本？

│ │ │ ├─开篇词｜时至今日，如何更好地拥抱现代C语言？

│ │ │ ├─春节策划一-构建自己的知识体系，让学习的“飞轮”持续转动

│ │ │ ├─春节策划三-JITCompilation：一种特殊的程序执行方式

│ │ │ ├─春节策划二-关于C语言，我有这些书籍想推荐给你

│ │ │ ├─期中测试｜来检验下你的学习成果吧！

│ │ │ ├─期末考试｜来赴一场满分之约吧！

│ │ │ ├─结束语｜工业4

│ │ │ ├─课前热身｜学习这门课前，你需要了解哪些知识？

│ │ │ ├─课堂答疑（一）｜前置篇、C核心语法实现篇问题集锦

│ │ │ ├─课堂答疑（二）｜C工程实战篇问题集锦

│ │ │ └─课堂答疑（二）｜C工程实战篇问题集锦

│ │ ├─179业务开发算法50讲

│ │ │ ├─01｜动态数组：按需分配的vector为什么要二倍扩容？

│ │ │ ├─02｜双向链表：list如何实现高效地插入与删除？

│ │ │ ├─03｜双端队列：并行计算中的工作窃取算法如何实现？

│ │ │ ├─04｜栈：函数调用的秘密究竟是什么？

│ │ │ ├─05｜HashMap：一个优秀的散列表是怎么来的？

│ │ │ ├─06｜TreeMap：红黑树真的有那么难吗？

│ │ │ ├─07｜堆：如何实现一个高效的优先队列？

│ │ │ ├─08｜外部排序：如何为TB级数据排序？

│ │ │ ├─09｜二分：如何高效查询Kafka中的消息？

│ │ │ ├─10｜搜索算法：一起来写一个简单的爬虫？

│ │ │ ├─11｜字符串匹配：如何实现最快的grep工具

│ │ │ ├─12｜拓扑排序：Webpack是如何确定构建顺序的？

│ │ │ ├─13｜哈夫曼树：HTTP2

│ │ │ ├─14｜调度算法：操作系统中的进程是如何调度的？

│ │ │ ├─15｜LRU：在虚拟内存中页面是如何置换的？

│ │ │ ├─16｜日志型文件系统：写入文件的时候断电了会发生什么？

│ │ │ ├─179业务开发算法50讲

│ │ │ ├─17｜选路算法：Dijkstra是如何解决最短路问题的？

│ │ │ ├─18｜选路算法：链路状态算法是如何分发全局信息的

│ │ │ ├─19｜选路算法：距离矢量算法为什么会产生无穷计算问题？

│ │ │ ├─20｜滑动窗口：TCP是如何进行流量控制和拥塞控制的？

│ │ │ ├─21｜分而治之：MapReduce如何解决大规模分布式计算问题

│ │ │ ├─22｜PageRank：谷歌是如何计算网页排名的

│ │ │ ├─23｜Raft：分布式系统间如何达成共识？

│ │ │ ├─24｜UUID：如何高效生成全局的唯一ID？

│ │ │ ├─25｜一致性哈希：如何在集群上合理分配流量？

│ │ │ ├─26｜B+Tree：PostgreSQL的索引是如何建立的？

│ │ │ ├─27｜LSMTree：LevelDB的索引是如何建立的？

│ │ │ ├─28｜MVCC：如何突破数据库并发读写性能瓶颈？

│ │ │ ├─29｜位图：如何用更少空间对大量数据进行去重和排序？

│ │ │ ├─30｜布隆过滤器：如何解决Redis缓存穿透问题？

│ │ │ ├─31｜跳表：Redis是如何存储有序集合的？

│ │ │ ├─32｜时间轮：Kafka是如何实现定时任务的？

│ │ │ ├─33｜限流算法：如何防止系统过载？

│ │ │ ├─34｜前缀树：Web框架中如何实现路由匹配？

│ │ │ ├─35｜洗牌算法：随机的哲学，如何用程序来洗一副牌？

│ │ │ ├─36｜分布式事务：如何理解两阶段提交？

│ │ │ ├─37｜Thrift编码方法：为什么RPC往往不采用JSON作为网络传输格式？

│ │ │ ├─38｜倒排索引：搜索引擎是如何做全文检索的？

│ │ │ ├─39｜Geohash：点外卖时我们是如何查找到附近餐厅的？

│ │ │ ├─40｜垃圾回收：现代语言是如何自动管理回收内存的？

│ │ │ ├─先导篇｜诶，这个gitdiff好像不是很直观？

│ │ │ ├─即学即练｜分布式篇：复习卡一键直达

│ │ │ ├─即学即练｜基础数据结构篇：复习卡&算法题特训

│ │ │ ├─即学即练｜基础算法思想篇：复习卡&算法题特训

│ │ │ ├─即学即练｜工程实战篇：复习卡一键直达

│ │ │ ├─即学即练｜操作系统篇：复习卡&算法题特训

│ │ │ ├─即学即练｜计算机网络篇：复习卡&算法题特训

│ │ │ ├─开篇词｜真实世界的算法，和你想的不一样

│ │ │ ├─特别策划｜面试：BAT面试三关准备方法大揭秘

│ │ │ ├─结束语｜在技术的世界里享受思维的乐趣

│ │ │ └─结束语｜在技术的世界里享受思维的乐趣

│ │ ├─180SpringCloud微服务项目实战

│ │ │ ├─01-是什么推动了单体应用到微服务架构的演进？

│ │ │ ├─02-微服务全家桶：走进SpringCloud的世界

│ │ │ ├─03-初窥门径：我们要搭建一个怎样的微服务实战项目？

│ │ │ ├─04-十八般兵器：如何搭建项目所需的开发环境？

│ │ │ ├─05-牛刀小试：如何搭建优惠券模板服务？

│ │ │ ├─06-牛刀小试：如何搭建优惠券计算服务和用户服务？

│ │ │ ├─07-Nacos体系架构：什么是服务治理？

│ │ │ ├─08-服务治理：Nacos集群环境搭建

│ │ │ ├─09-集成Nacos：如何将服务提供者注册到Nacos服务器？

│ │ │ ├─10-集成Nacos：如何通过服务发现机制向服务提供者发起调用？

│ │ │ ├─11-Loadbalancer实战：通过自定义负载均衡策略实现金丝雀测试

│ │ │ ├─12-OpenFeign：服务间调用组件OpenFeign是怎么“隔空取物”的？

│ │ │ ├─13-OpenFeign实战：如何实现服务间调用功能？

│ │ │ ├─14-OpenFeign实战：OpenFeign组件有哪些高级玩法？

│ │ │ ├─15-配置中心在微服务中发挥着怎样的作用？

│ │ │ ├─16-如何集成NacosConfig实现配置项动态刷新？

│ │ │ ├─17-Sentinel体系结构：什么是服务容错（降级熔断、流量整形）

│ │ │ ├─18-Sentinel实战：如何实施流量整形与限流策略？

│ │ │ ├─180SpringCloud微服务项目实战

│ │ │ ├─19-Sentinel实战：如何为项目添加异常降级方案？

│ │ │ ├─20-Sentinel实战：如何接入Nacos实现规则持久化？

│ │ │ ├─21-Sleuth体系架构：为什么微服务架构需要链路追踪？

│ │ │ ├─22-调用链追踪：集成Sleuth和Zipkin，实现链路打标

│ │ │ ├─23-调用链追踪：如何通过ELK实现日志检索？

│ │ │ ├─24-为什么微服务架构少不了微服务网关？

│ │ │ ├─25-微服务网关：Gateway中的路由和谓词有何应用？

│ │ │ ├─26-微服务网关：如何设置请求转发、跨域和限流规则？

│ │ │ ├─27-微服务网关：如何借助Nacos实现动态路由规则？

│ │ │ ├─28-消息驱动：谁说消息队列只能削峰填谷？

│ │ │ ├─29-消息驱动：如何集成Stream实现消息驱动？

│ │ │ ├─30-消息驱动：如何高效处理Stream中的异常？

│ │ │ ├─31-消息驱动：如何通过RabbitMQ插件实现延迟消息？

│ │ │ ├─32-AlibabaSeata框架：什么是分布式事务？

│ │ │ ├─33-分布式事务：搭建Seata服务器

│ │ │ ├─34-分布式事务：使用Nacos+Seata实现AT模式

│ │ │ ├─35-分布式事务：使用Nacos+Seata实现TCC补偿模式

│ │ │ ├─加餐：说透微服务-什么是主链路规划？

│ │ │ ├─开篇词-跟着学，你也能成为微服务高手

│ │ │ ├─结束语-站在聚光灯下

│ │ │ └─结束语-站在聚光灯下

│ │ ├─181Web漏洞挖掘实战

│ │ │ ├─01｜失效的访问控制：攻击者如何获取其他用户信息？

│ │ │ ├─02｜路径穿越：你的Web应用系统成了攻击者的资源管理器？

│ │ │ ├─03-敏感数据泄露：攻击者如何获取用户账户？

│ │ │ ├─04｜权限不合理：攻击者进来就是root权限？

│ │ │ ├─05｜CSRF：为什么用户的操作他自己不承认？

│ │ │ ├─06｜加密失败：使用了加密算法也会被破解吗？

│ │ │ ├─07｜弱编码：程序之间的沟通语言安全吗？

│ │ │ ├─08｜数字证书：攻击者可以伪造证书吗？

│ │ │ ├─09｜密码算法问题：数学知识如何提高代码可靠性？

│ │ │ ├─10｜弱随机数生成器：攻击者如何预测随机数？

│ │ │ ├─11｜忘记加“盐”：加密结果强度不够吗？

│ │ │ ├─12｜注入（上）：SQL注入起手式

│ │ │ ├─13｜注入（下）：SQL注入技战法及相关安全实践

│ │ │ ├─14｜自动化注入神器（一）：sqlmap的设计思路解析

│ │ │ ├─15｜自动化注入神器（二）：sqlmap的设计架构解析

│ │ │ ├─16｜自动化注入神器（三）：sqlmap的核心实现拆解

│ │ │ ├─17｜自动化注入神器（四）：sqlmap的核心功能解析

│ │ │ ├─18-命令注入：开发的Web应用为什么成为了攻击者的bash？

│ │ │ ├─181Web漏洞挖掘实战

│ │ │ ├─19-失效的输入检测（上）：攻击者有哪些绕过方案？

│ │ │ ├─20-失效的输入检测（下）：攻击者有哪些绕过方案？

│ │ │ ├─21｜XSS（上）：前端攻防的主战场

│ │ │ ├─22｜XSS（中）：跨站脚本攻击的危害性

│ │ │ ├─23｜XSS（下）：检测与防御方案解析

│ │ │ ├─24｜资源注入：攻击方式为什么会升级？

│ │ │ ├─25｜业务逻辑漏洞：好的开始是成功的一半

│ │ │ ├─26｜包含敏感信息的报错：将安全开发标准应用到项目中

│ │ │ ├─27｜用户账户安全：账户安全体系设计方案与实践

│ │ │ ├─28｜安全配置错误：安全问题不只是代码安全

│ │ │ ├─29｜Session与Cookie：账户体系的安全设计原理

│ │ │ ├─30｜HTTPHeader安全标志：协议级别的安全支持

│ │ │ ├─31｜易受攻击和过时的组件：DevSecOps与依赖项安全检查

│ │ │ ├─32｜软件和数据完整性故障：SolarWinds事件的幕后??

│ │ │ ├─33｜SSRF：穿越边界防护的利刃

│ │ │ ├─34｜CrawlerVSFuzzing：DAST与机器学习

│ │ │ ├─35｜自动化攻防：低代码驱动的渗透工具积累

│ │ │ ├─36｜智能攻防：构建个性化攻防平台

│ │ │ ├─大咖助场｜数字证书，困境与未来

│ │ │ ├─导读｜解读OWASPTop102021

│ │ │ ├─开篇词｜从黑客的视角找漏洞，从安全的角度优雅coding

│ │ │ ├─春节策划（一）｜视频课内容精选：Web渗透测试工具教学

│ │ │ ├─春节策划（三）-一套测试题，看看对课程内容的掌握情况

│ │ │ ├─春节策划（二）｜给你推荐4本Web安全图书

│ │ │ ├─结束语｜无畏前行

│ │ │ └─结束语｜无畏前行

│ │ ├─182去无方向的信

│ │ │ ├─182去无方向的信

│ │ │ ├─回信｜编辑手记

│ │ │ ├─布步佐的年终小记（2021

│ │ │ ├─杳无音信-停更

│ │ │ ├─第一封信-去无方向的信

│ │ │ ├─第七封信-闹饥荒的时候，总有人是要挨饿的

│ │ │ ├─第三十一封信-什么相机是最好的相机？（卡片机&手机相机）

│ │ │ ├─第三十七封信｜应该看的和最好别碰的

│ │ │ ├─第三十三封信-NOMO

│ │ │ ├─第三十九封信-看完照片儿以后我们要干什么？

│ │ │ ├─第三十二封信-其实，手机相机就挺好用的

│ │ │ ├─第三十五封信-颜色对是错的

│ │ │ ├─第三十八封信-看照片儿的时候我们要看什么？

│ │ │ ├─第三十六封信-那什么颜色才是对的？

│ │ │ ├─第三十四封信-我为什么喜欢NOMO？

│ │ │ ├─第三十封信-什么相机是最好的相机？（全宇宙最好用的相机）

│ │ │ ├─第三封信-我们坚决拥护大而少

│ │ │ ├─第九封信-阳光之下没什么新鲜事儿（上）

│ │ │ ├─第二十一封信-“要么横着涂，要么竖着涂”（下）

│ │ │ ├─第二十七封信-什么相机是最好的相机？（引子）

│ │ │ ├─第二十三封信-还是不对焦比较快（上）

│ │ │ ├─第二十九封信-什么相机是最好的相机？（成像质量）

│ │ │ ├─第二十二封信-还是不对焦比较快（引子）

│ │ │ ├─第二十五封信-还是不对焦比较快（下）

│ │ │ ├─第二十八封信-什么相机是最好的相机？（等效焦距）

│ │ │ ├─第二十六封信-还是不对焦比较快（附录）

│ │ │ ├─第二十四封信-还是不对焦比较快（中）

│ │ │ ├─第二十封信-“要么横着涂，要么竖着涂”（中）

│ │ │ ├─第二封信-能拍清楚就已经很好了

│ │ │ ├─第五十一封信-那我们应该从哪儿开始？（逼近-溜缝）

│ │ │ ├─第五十七封信-距离，关键是距离！

│ │ │ ├─第五十三封信-那我们应该从哪儿开始？（三角）

│ │ │ ├─第五十九封信-这些照片儿是不是出事儿了？

│ │ │ ├─第五十二封信-那我们应该从哪儿开始？（天空）

│ │ │ ├─第五十五封信-那我们应该从哪儿开始？（知其所以然）

│ │ │ ├─第五十八封信-你拍得不够好，是因为你离得不够远

│ │ │ ├─第五十六封信-什么照片儿是烂照片儿？

│ │ │ ├─第五十四封信-那我们应该从哪儿开始？（五彩斑斓的黑）

│ │ │ ├─第五十封信-那我们应该从哪儿开始？（横竖-边角-空区）

│ │ │ ├─第五封信-基本上一个有用的都没有

│ │ │ ├─第八封信-没有感情的拍照机器

│ │ │ ├─第六十一封信-谁认识你是谁啊

│ │ │ ├─第六十七封信-一切都是为了不拍

│ │ │ ├─第六十三封信-看不懂就看不懂

│ │ │ ├─第六十九封信｜周五三

│ │ │ ├─第六十二封信-万能的画册

│ │ │ ├─第六十五封信-心理障碍和道德困境

│ │ │ ├─第六十八封信-AllThatIsSolidMeltsintoAir

│ │ │ ├─第六十六封信-怪地球没有吸引力

│ │ │ ├─第六十四封信-遗憾的是，如果你真能拍清楚了，你可能就很难拍不清楚了

│ │ │ ├─第六十封信-是什么让我们有底气连脸都不要了？

│ │ │ ├─第六封信-副作用比药效更值得让人留心

│ │ │ ├─第十一封信-阳光之下没什么新鲜事儿（下）

│ │ │ ├─第十七封信-拧来拧去地你就完蛋了

│ │ │ ├─第十三封信-35mm的进退两难

│ │ │ ├─第十九封信-“要么横着涂，要么竖着涂”（上）

│ │ │ ├─第十二封信-我们坚决拥护我们坚决拥护的

│ │ │ ├─第十五封信-28mm是全宇宙最好用的镜头！

│ │ │ ├─第十八封信-“要么横着涂，要么竖着涂”（引子）

│ │ │ ├─第十六封信-28mm是全宇宙最好用的镜头？

│ │ │ ├─第十四封信-“必须拥有一支50mm镜头的十大理由”

│ │ │ ├─第十封信-阳光之下没什么新鲜事儿（中）

│ │ │ ├─第四十一封信-有意为之的偶然（引子）

│ │ │ ├─第四十七封信-什么照片儿是好照片儿？（引子）

│ │ │ ├─第四十三封信-有意为之的偶然（ImagesàlaSauvette）

│ │ │ ├─第四十九封信-什么照片儿是好照片儿？（难拍）

│ │ │ ├─第四十二封信-有意为之的偶然（创造画面）

│ │ │ ├─第四十五封信-意欲难平的执念

│ │ │ ├─第四十八封信-什么照片儿是好照片儿？（好看）

│ │ │ ├─第四十六封信-贪嗔痴慢疑

│ │ │ ├─第四十四封信-有意为之的偶然（生活的假象）

│ │ │ ├─第四十封信-拍照片儿如果只是拍照片儿该多好

│ │ │ ├─第四封信-0+0+0=0

│ │ │ └─第四封信-0+0+0=0

│ │ ├─183朱涛·Kotlin编程第一课

│ │ │ ├─01-Kotlin基础语法：正式开启学习之旅

│ │ │ ├─02-面向对象：理解Kotlin设计者的良苦用心

│ │ │ ├─03-Kotlin原理：编译器在幕后干了哪些“好事”？

│ │ │ ├─04-实战：构建一个Kotlin版本的四则运算计算器

│ │ │ ├─05-object关键字：你到底有多少种用法？

│ │ │ ├─06-扩展：你的能力边界到底在哪里？

│ │ │ ├─07-高阶函数：为什么说函数是Kotlin的“一等公民”？

│ │ │ ├─08-实战：用Kotlin写一个英语词频统计程序

│ │ │ ├─09-委托：你为何总是被低估？

│ │ │ ├─10-泛型：逆变or协变，傻傻分不清？

│ │ │ ├─11-注解与反射：进阶必备技能

│ │ │ ├─12-实战：用Kotlin实现一个网络请求框架KtHttp

│ │ │ ├─13-什么是“协程思维模型”？

│ │ │ ├─14-如何启动协程？

│ │ │ ├─15-挂起函数：Kotlin协程的核心

│ │ │ ├─16-Job：协程也有生命周期吗？

│ │ │ ├─17-Context：万物皆为Context？

│ │ │ ├─18-实战：让KtHttp支持挂起函数

│ │ │ ├─183朱涛·Kotlin编程第一课

│ │ │ ├─19-Channel：为什么说Channel是“热”的？

│ │ │ ├─20-Flow：为什么说Flow是“冷”的？

│ │ │ ├─21-select：到底是在选择什么？

│ │ │ ├─22-并发：协程不需要处理同步吗？

│ │ │ ├─23-异常：try-catch居然会不起作用？坑！

│ │ │ ├─24-实战：让KtHttp支持Flow

│ │ │ ├─25-集合操作符：你也会“看完就忘”吗？

│ │ │ ├─26-协程源码的地图：如何读源码才不会迷失？

│ │ │ ├─27-图解挂起函数：原来你就是个状态机？

│ │ │ ├─28-launch的背后到底发生了什么？

│ │ │ ├─29-Dispatchers是如何工作的？

│ │ │ ├─30-CoroutineScope是如何管理协程的？

│ │ │ ├─31-图解Channel：如何理解它的CSP通信模型？

│ │ │ ├─32-图解Flow：原来你是只纸老虎？

│ │ │ ├─33-JavaAndroid开发者还会有未来吗？

│ │ │ ├─34-Kotlin与Jetpack简直是天生一对！

│ │ │ ├─35-用Kotlin写一个GitHubTrendingApp

│ │ │ ├─加餐一-初识Kotlin函数式编程

│ │ │ ├─加餐三-什么是“不变性思维”？

│ │ │ ├─加餐二-什么是“表达式思维”？

│ │ │ ├─加餐五-深入理解协程基础元素

│ │ │ ├─加餐四-什么是“空安全思维”？

│ │ │ ├─开篇词-入门Kotlin有多容易，精通Kotlin就有多难

│ │ │ ├─春节刷题计划（一）-当Kotlin遇上LeetCode

│ │ │ ├─春节刷题计划（三）-一题双解，搞定求解方程

│ │ │ ├─春节刷题计划（二）-一题三解，搞定版本号判断

│ │ │ ├─春节刷题计划（四）-一题三解，搞定分式加减法

│ │ │ ├─期中考试-用Kotlin实现图片处理程序

│ │ │ ├─答疑（一）-Java和Kotlin到底谁好谁坏？

│ │ │ ├─结束语-不忘初心

│ │ │ ├─结课测试-“Kotlin编程第一课”100分试卷等你来挑战！

│ │ │ ├─题目解答-期中考试版本参考实现

│ │ │ └─题目解答-期中考试版本参考实现

│ │ ├─184网络排查案例课

│ │ │ ├─01-网络模型和工具：网络为什么要分层？

│ │ │ ├─02-抓包分析技术初探：你会用tcpdump和Wireshark吗？

│ │ │ ├─03-握手：TCP连接都是用TCP协议沟通的吗？

│ │ │ ├─04-挥手：Nginx日志报connectionresetbypeer是怎么回事？

│ │ │ ├─05-定位防火墙（一）：传输层的对比分析

│ │ │ ├─06-定位防火墙（二）：网络层的精确打击

│ │ │ ├─07-保活机制：心跳包异常导致应用重启？

│ │ │ ├─08-分段：MTU引发的血案

│ │ │ ├─09-长肥管道：为何文件传输速度这么慢？

│ │ │ ├─10-窗口：TCPWindowFull会影响传输效率吗？

│ │ │ ├─11-拥塞：TCP是如何探测到拥塞的？

│ │ │ ├─12-重传的认识：重传到底是怎么回事？

│ │ │ ├─13-重传的再认识：没有任何丢包却也一直重传？

│ │ │ ├─14-安全：用Wireshark把DDoS攻击照出原形

│ │ │ ├─15-Nginx的499状态码是怎么回事？

│ │ │ ├─16-服务器为什么回复HTTP400？

│ │ │ ├─17-为什么前端页面里多选一个城市就报错？

│ │ │ ├─18-偶发性问题如何排查？

│ │ │ ├─184网络排查案例课

│ │ │ ├─19-TLS的各种特性：TLS握手为什么会失败？

│ │ │ ├─20-TLS加解密：如何解密HTTPS流量？

│ │ │ ├─21-为什么用了负载均衡更加不均衡？

│ │ │ ├─22-为什么压力测试TPS总是上不去？

│ │ │ ├─23-路径排查：没有网络设备权限要如何做排查？

│ │ │ ├─24-丢包：如何确定丢包的存在及其程度？

│ │ │ ├─25-抓包分析的回顾、拾遗，和提高

│ │ │ ├─不定期加餐（一）-八仙过海，各显神通：透传真实源IP的各种方法

│ │ │ ├─开篇词-网络排查是工程师的必备能力

│ │ │ ├─春节特别放送（一）-书单推荐

│ │ │ ├─春节特别放送（三）-我的学习资料和工具

│ │ │ ├─春节特别放送（二）-聊聊能力陷阱和终身学习

│ │ │ ├─春节特别放送（四）-测一测你的网络排查能力

│ │ │ ├─用户故事-小S：学习是人生路上生生不息的活泉

│ │ │ ├─用户故事-王未：网络排查能力是一名合格运维工程师的必备技能

│ │ │ ├─答疑（一）-第1~5讲思考题答案

│ │ │ ├─答疑（三）-第11~15讲思考题答案

│ │ │ ├─答疑（二）-第6~10讲思考题答案

│ │ │ ├─答疑（四）-第16~20讲思考题答案

│ │ │ ├─结束语-珍惜握手，难说再见

│ │ │ └─结课测试-“网络排查案例课”100分试卷等你来挑战！

│ │ ├─185反爬虫兵法演绎20讲

│ │ │ ├─01-爬虫需求的诞生：我们是正经的软件工程师

│ │ │ ├─02-爬虫的内卷和黑化：我们变得不正经啦

│ │ │ ├─03-反爬虫的发展以及展望：我们也不是什么正经工程师

│ │ │ ├─04-爬虫的首轮攻势：如何低调地拿到自己想要的数据？

│ │ │ ├─05-反爬虫的应对之策：通用且基本的检测规则是什么？

│ │ │ ├─06｜爬虫攻势升级：分布式的意义在哪里？

│ │ │ ├─07-反爬虫升级：如何判定你是个真人？

│ │ │ ├─08-博弈的均衡：如何对抗道德的沦丧和人性的扭曲？

│ │ │ ├─09-反爬虫概述（一）：高收益的后端能做哪些基本的事情？

│ │ │ ├─10-反爬虫概述（二）：无收益的前端是怎么进行key处理的呢？

│ │ │ ├─11｜反爬虫概述（三）：前端反爬虫是怎么做信息收集的？

│ │ │ ├─12-反爬虫概述（四）：前后端都不合适的时候如何进行处理？

│ │ │ ├─13-反爬虫基础理论：这是唯一一节严肃的纯理论课

│ │ │ ├─14-低耦合：如何快速下线反爬虫系统？

│ │ │ ├─15-规则引擎：如何快速响应突发的爬虫需求？

│ │ │ ├─16-验证爬虫：我到底要不要百分百投入？

│ │ │ ├─17-招聘篇：如何写一个合适的JD？

│ │ │ ├─18-如何搞定老板（上）：如何编造虚无缥缈的OKR？

│ │ │ ├─185反爬虫兵法演绎20讲

│ │ │ ├─19-如何搞定老板（中）：如何组建团队

│ │ │ ├─20-如何搞定老板（下）：团队考核怎么做？

│ │ │ ├─加餐｜反爬虫的专家级鉴别力：用户习惯检测

│ │ │ ├─开篇词-如何突破“爬虫反爬虫”内卷之怪现状？

│ │ │ ├─春节加餐01-破解还是不破解，这是一个问题

│ │ │ ├─春节加餐02-真实世界里，小心屠龙勇士变恶龙

│ │ │ ├─春节加餐03-低调驶得万年船

│ │ │ ├─答疑课堂｜爬虫反爬虫调试对抗技巧以及虚拟机详解

│ │ │ ├─结束语｜达到理想不太易

│ │ │ ├─结课测试｜反爬虫的“反人类”测试题，你能答对多少？

│ │ │ └─结课测试｜反爬虫的“反人类”测试题，你能答对多少？

│ │ ├─186eBPF核心技术与实战

│ │ │ ├─01｜技术概览：eBPF的发展历程及工作原理

│ │ │ ├─02-先利其器：如何高效学习eBPF？

│ │ │ ├─03-初窥门径：开发并运行你的第一个eBPF程序

│ │ │ ├─04-运行原理：eBPF是一个新的虚拟机吗？

│ │ │ ├─05-编程接口：eBPF程序是怎么跟内核进行交互的？

│ │ │ ├─06-事件触发：各类eBPF程序的触发机制及其应用场景

│ │ │ ├─07-内核跟踪（上）：如何查询内核中的跟踪点？

│ │ │ ├─08｜内核跟踪（下）：开发内核跟踪程序的进阶方法

│ │ │ ├─09-用户态跟踪：如何使用eBPF排查应用程序？

│ │ │ ├─10-网络跟踪：如何使用eBPF排查网络问题？

│ │ │ ├─11-容器安全：如何使用eBPF增强容器安全？

│ │ │ ├─12｜高性能网络实战（上）：如何开发一个负载均衡器？

│ │ │ ├─13｜高性能网络实战（下）：如何完善负载均衡器？

│ │ │ ├─186eBPF核心技术与实战

│ │ │ ├─加餐｜李程远：谈谈eBPF在云原生中的纵与横

│ │ │ ├─开篇词-想要洞悉系统底层的黑盒？先掌握eBPF！

│ │ │ ├─未来可期｜邀你与eBPF共赴一场技术革新之约

│ │ │ ├─用户故事｜eBPF从入门到放弃？在实践中找到突破口

│ │ │ ├─阶段总结｜实用eBPF工具及最新开源项目总结

│ │ │ ├─难点解析｜eBPF多内核版本兼容详解

│ │ │ ├─难点解析｜eBPF开发环境搭建及内核编译详解

│ │ │ └─难点解析｜eBPF开发环境搭建及内核编译详解

│ │ ├─187深入浅出分布式技术原理

│ │ │ ├─01｜导读：以前因后果为脉络，串起网状知识体系

│ │ │ ├─02｜新的挑战：分布式系统是银弹吗？我看未必！

│ │ │ ├─03｜CAP理论：分布式场景下我们真的只能三选二吗？

│ │ │ ├─04｜注册发现：AP系统和CP系统哪个更合适？

│ │ │ ├─05｜负载均衡：从状态的角度重新思考负载均衡

│ │ │ ├─06｜配置中心：如何确保配置的强一致性呢？

│ │ │ ├─07｜分布式锁：所有的分布式锁都是错误的？

│ │ │ ├─08｜重试幂等：让程序Exactly-once很难吗？

│ │ │ ├─09-雪崩（一）：熔断，让故障自适应地恢复

│ │ │ ├─10-雪崩（二）：限流，抛弃超过设计容量的请求

│ │ │ ├─11｜雪崩（三）：降级，无奈的丢车保帅之举

│ │ │ ├─12｜雪崩（四）：扩容，没有用钱解决不了的问题

│ │ │ ├─13｜可观测性（一）：如何监控一个复杂的分布式系统？

│ │ │ ├─14｜可观测性（二）：如何设计一个高效的告警系统？

│ │ │ ├─15｜故障（一）：预案管理竟然能让被动故障自动恢复？

│ │ │ ├─16｜故障（二）：变更管理，解决主动故障的高效思维方式

│ │ │ ├─17｜分片（一）：如何选择最适合的水平分片方式？

│ │ │ ├─187深入浅出分布式技术原理

│ │ │ ├─18｜分片（二）：垂直分片和混合分片的trade-off

│ │ │ ├─19｜复制（一）：主从复制从副本的数据可以读吗？

│ │ │ ├─20｜复制（二）：多主复制的多主副本同时修改了怎么办？

│ │ │ ├─21｜复制（三）：最早的数据复制方式竟然是无主复制？

│ │ │ ├─22｜事务（一）：一致性，事务的集大成者

│ │ │ ├─23｜事务（二）：原子性，对应用层提供的完美抽象

│ │ │ ├─24｜事务（三）：隔离性，正确与性能之间权衡的艺术

│ │ │ ├─25｜事务（四）：持久性，吃一碗粉就付一碗粉的钱

│ │ │ ├─26｜一致性与共识（一）：数据一致性都有哪些级别？

│ │ │ ├─27｜一致性与共识（二）：它们是鸡生蛋还是蛋生鸡？

│ │ │ ├─28｜一致性与共识（三）：共识与事务之间道不明的关系

│ │ │ ├─29｜分布式计算技术的发展史：从单进程服务到ServiceMesh

│ │ │ ├─30｜分布式存储技术的发展史：从ACID到NewSQL

│ │ │ ├─开篇词｜掌握好学习路径，分布式系统原来如此简单

│ │ │ ├─春节加餐｜技术债如房贷，是否借贷怎样取舍？

│ │ │ ├─春节加餐｜深入聊一聊计算机系统的时间

│ │ │ ├─春节加餐｜系统性思维，高效学习和工作的利器

│ │ │ ├─期中测试答案｜这些问题你都答对了吗？

│ │ │ ├─期中测试｜IM系统设计实战

│ │ │ ├─结束语｜在分布式技术的大潮流中自由冲浪吧！

│ │ │ └─课后彩蛋｜完整版思考题答案

│ │ ├─188李智慧·高并发架构实战课

│ │ │ ├─01-软件建模与文档：架构师怎样绘制系统架构蓝图？

│ │ │ ├─02-高并发架构设计方法：面对高并发，怎么对症下药？

│ │ │ ├─03-短URL生成器设计：百亿短URL怎样做到无冲突？

│ │ │ ├─04-网页爬虫设计：如何下载千亿级网页？

│ │ │ ├─05-网盘系统设计：万亿GB网盘如何实现秒传与限速？

│ │ │ ├─06-短视频系统设计：如何支持三千万用户同时在线看视频？

│ │ │ ├─07-海量数据处理技术回顾：为什么分布式会遇到CAP难题？

│ │ │ ├─08-秒杀系统设计：你的系统可以应对万人抢购盛况吗？

│ │ │ ├─09-交友系统设计：哪种地理空间邻近算法更快？

│ │ │ ├─10-搜索引擎设计：信息搜索怎么避免大海捞针？

│ │ │ ├─11-反应式编程框架设计：如何使方法调用无阻塞等待？

│ │ │ ├─12-高性能架构的三板斧：分析系统性能问题从哪里入手？

│ │ │ ├─13-微博系统设计：怎么应对热点事件的突发访问压力？

│ │ │ ├─14-百科应用系统设计：机房被火烧了系统还能访问吗？

│ │ │ ├─15-限流器设计：如何避免超预期的高并发压力压垮系统？

│ │ │ ├─16-高可用架构的十种武器：怎么度量系统的可用性？

│ │ │ ├─17-Web应用防火墙：怎样拦截恶意用户的非法请求？

│ │ │ ├─18-加解密服务平台：如何让敏感数据存储与传输更安全？

│ │ │ ├─188李智慧·高并发架构实战课

│ │ │ ├─19-许可型区块链重构：无中心的区块链怎么做到可信任？

│ │ │ ├─20-网约车系统设计：怎样设计一个日赚5亿的网约车系统？

│ │ │ ├─21-网约车系统重构：如何用DDD重构网约车系统设计？

│ │ │ ├─22-大数据平台设计：如何用数据为用户创造价值？

│ │ │ ├─开篇词-“附身”大厂架构师，身临其境设计高并发系统

│ │ │ ├─期中测试-动手写一篇你自己的设计文档吧！

│ │ │ ├─期中测试获奖用户名单及参考答案：通达系统架构设计

│ │ │ ├─结束语-一个架构师的一天

│ │ │ └─结束语-一个架构师的一天

│ │ ├─189大厂广告产品心法

│ │ │ ├─01｜业务逻辑：广告产品的前世今生和商业模式是怎样的？

│ │ │ ├─02｜业务链条：广告主、媒体、第三方等分别如何看待广告产品？

│ │ │ ├─03｜头部玩家：从BAT到跳动的字节，广告产品有哪些变化与发展趋势？

│ │ │ ├─04｜产品体系：互联网大厂的广告产品存在哪些共性和区别？

│ │ │ ├─05｜变现模式：什么样的产品适合采用广告模式变现？

│ │ │ ├─06｜产品路线：大厂和小厂的广告产品发展路线有什么区别？

│ │ │ ├─07｜计价与效果（上）：如何制定合理的计价方式？

│ │ │ ├─08｜计价与效果（下）：如何制定合理的效果评估指标？

│ │ │ ├─09｜效果优化：如何一步步从提升曝光量深入到提升销量？

│ │ │ ├─10｜流量优化：如何兼顾广告收入和用户体验？

│ │ │ ├─11｜物料生产：如何满足广告主的创意需求？

│ │ │ ├─12｜精准定向：如何建立一个成熟的用户标签体系？

│ │ │ ├─13｜转化优化：互联网大厂如何利用算法优化广告效果？

│ │ │ ├─14｜程序化交易：程序化交易是否可以提升广告效果？

│ │ │ ├─15｜需求调研：广告产品潜在需求的调研流程是怎样的？

│ │ │ ├─16｜平台建设：如何从0到1建立一个完整的广告产品平台？

│ │ │ ├─17｜职业发展：新人入行，如何判断自己是否适合做广告产品？

│ │ │ ├─189大厂广告产品心法

│ │ │ ├─18｜团队建设：如何搭建一个高效的广告产品团队？

│ │ │ ├─19｜跨团队合作：产研团队和销售端、媒体端、市场端如何合作？

│ │ │ ├─20｜产品运营：不同发展阶段如何制定业务目标和运营策略？

│ │ │ ├─21｜广告产品彩蛋：课程答疑与推荐书目

│ │ │ ├─开篇词｜作为一名互联网人，你为什么必须了解广告产品？

│ │ │ ├─结束语｜你想要成为什么样的互联网广告产品人？

│ │ │ ├─结课测试｜展现你真正的实力吧！

│ │ │ └─结课测试｜展现你真正的实力吧！

│ │ ├─190说透低代码

│ │ │ ├─01｜低代码平台到底是什么样的？

│ │ │ ├─02｜低代码到底是银弹，还是行业毒瘤？

│ │ │ ├─03｜低代码的天花板：一个完备的低代码平台应该具备哪些条件？

│ │ │ ├─04｜演进策略：先发展通用能力还是先满足业务需求？

│ │ │ ├─05｜基础设施：启动低代码平台研发之前，你需要有什么家底？

│ │ │ ├─06｜踏出新手村便遭遇大Boss：如何架构低代码的引擎？

│ │ │ ├─07｜结构化代码生成法：代码如何生成代码？

│ │ │ ├─08｜布局编辑器：如何做到鱼和熊掌兼得？

│ │ │ ├─09｜属性编辑器：如何解除Web组件属性与编辑器的耦合？

│ │ │ ├─10-可视化编程：如何有效降低App前后端逻辑开发的技能门槛？

│ │ │ ├─11｜亦敌亦友：LowCode与ProCode混合使用怎样实现？

│ │ │ ├─12-业务数据：再好的App，没有数据也是白搭

│ │ │ ├─13｜多人协同编辑：野百合的春天为啥来得这么晚？

│ │ │ ├─14｜编辑历史：是对Git做改造，还是另辟蹊径？

│ │ │ ├─15｜低代码平台应该优先覆盖应用研发生命周期中的哪些功能？

│ │ │ ├─16｜扩展与定制：如何实现插件系统并形成生态圈？

│ │ │ ├─17｜兼容性问题：如何有效发现兼容性问题？

│ │ │ ├─18｜兼容性问题：如何有效解决兼容性问题？

│ │ │ ├─190说透低代码

│ │ │ ├─开篇词｜抛开争论，先来看看真正的低代码

│ │ │ ├─总结与展望｜低代码之路，我们才刚刚开始

│ │ │ ├─阶段测试｜这些低代码的知识，你都掌握了吗？

│ │ │ └─阶段测试｜这些低代码的知识，你都掌握了吗？

│ │ ├─191自动化测试高手课

│ │ │ ├─01｜ROI价值内核：自动化测试的价值可以量化么？

│ │ │ ├─02｜3KU法则：如何找出最优自动化实施截面？

│ │ │ ├─03｜工具选择：什么工具框架值得用？

│ │ │ ├─04｜脚本复用：什么样的代码才值得写？

│ │ │ ├─05｜AutoGenAuto：所有测试工作即代码

│ │ │ ├─06｜左移&右移：测试如何在Dev和Ops领域大展身手？

│ │ │ ├─07｜需求提炼（一）：单体应用要测什么？

│ │ │ ├─08｜需求提炼（二）：微服务集群要测什么？

│ │ │ ├─09｜3KU法则：为一个订餐系统设计全栈测试方案

│ │ │ ├─10｜单元测试（一）：原来测试可以这么高效

│ │ │ ├─11｜单元测试（二）：四象限法让你的单测火力全开

│ │ │ ├─12｜集成测试（一）：一条HappyPath扫天下

│ │ │ ├─13｜集成测试（二）：携手开发，集测省力又省心

│ │ │ ├─14｜集成测试（三）：护航微服务集群迭代升级

│ │ │ ├─15｜UI测试：如何让UI测试更轻快便捷？

│ │ │ ├─16｜概念重识：如何用3KU为端到端&验收测试赋能？

│ │ │ ├─17｜元数据模型（一）：小Job模型构建大蓝图

│ │ │ ├─18｜元数据模型（二）：小Job模型构建大蓝图

│ │ │ ├─191自动化测试高手课

│ │ │ ├─19｜排兵布阵：自动化测试的编排、扩展与重构

│ │ │ ├─20｜链接工具：要驱动工具，不要被工具驱动

│ │ │ ├─21｜设计实战（一）：一个金融交易业务的自动化测试设计

│ │ │ ├─22｜设计实战（二）-一个全周期自动化测试Pipeline的设计

│ │ │ ├─23｜设计实战（三）-一个分布式多端视频会议自动化测试设计

│ │ │ ├─24｜启动运行：基于Job模型的框架实现和运行

│ │ │ ├─25｜找准方向：如何建立有效的测试度量体系？

│ │ │ ├─26｜见微知著：单元测试度量避坑

│ │ │ ├─27｜眼见为实：如何用数据描述你的自动化测试ROI？

│ │ │ ├─28｜解决问题：如何保证自动化测试的可信性？

│ │ │ ├─29｜落地实践：搭建可持续度量的技术平台

│ │ │ ├─开篇词-做性价比最高的自动化测试

│ │ │ ├─用户故事｜我的自动化学习之路

│ │ │ ├─结束语｜测试有终点，成长无边界

│ │ │ └─结束语｜测试有终点，成长无边界

│ │ ├─192徐昊·TDD项目实战70讲

│ │ │ ├─01｜TDD演示（1）：任务分解法与整体工作流程

│ │ │ ├─02｜TDD演示（2）：识别坏味道与代码重构

│ │ │ ├─03｜TDD演示（3）：按测试策略重组测试

│ │ │ ├─04｜TDD演示（4）：实现对于列表参数的支持

│ │ │ ├─05｜TDD中的测试（1）：状态验证为什么是主要的使用方式？

│ │ │ ├─06｜TDD中的测试（2）：行为验证为什么应该尽量避免使用？

│ │ │ ├─07｜TDD中的测试（3）：集成测试还是单元测试？

│ │ │ ├─08｜TDD中的驱动（1）：驱动的极限是什么？

│ │ │ ├─09｜TDD中的驱动（2）：重构发挥了什么作用？

│ │ │ ├─10｜TDD中的驱动（3）：何为经典学派？何为伦敦学派？

│ │ │ ├─11｜作为工程化方法的TDD：更低的成本与更高的效能

│ │ │ ├─12｜实战中的TDD：RESTfulAPI的开发框架

│ │ │ ├─13｜DIContainer（1）：如何实现基本的DI容器结构？

│ │ │ ├─14｜DIContainer（2）：如何通过SadPath为容器增加功能？

│ │ │ ├─15｜DIContainer（3）：如何重构已有的代码？

│ │ │ ├─16｜DIContainer（4）：如何实现对循环依赖的处理？

│ │ │ ├─17｜DIContainer（5）：API接口该怎么设计？

│ │ │ ├─18｜DIContainer（6）：如何实现循环依赖的检查？

│ │ │ ├─192徐昊·TDD项目实战70讲

│ │ │ ├─19｜DIContainer（7）：如何实现FieldInjection部分的功能？

│ │ │ ├─20｜DIContainer（8）：如何实现MethodInjection部分的功能？

│ │ │ ├─21｜DIContainer（9）：怎样重构测试代码？

│ │ │ ├─22｜DIContainer（10）：怎样将大粒度的测试重构为等效的小粒度测试代码？

│ │ │ ├─23｜DIContainer（11）：如何对ContainerTest进行文档化改造？

│ │ │ ├─24｜DIContainer（12）：如何增补功能？

│ │ │ ├─25｜DIContainer（13）：任务上的遗漏该怎么处理？

│ │ │ ├─26｜DIContainer（14）：如何重构对Type类型判断的逻辑？

│ │ │ ├─27｜DIContainer（15）：如何封装类型判断逻辑？

│ │ │ ├─28｜DIContainer（16）：行为封装会对测试产生什么影响？

│ │ │ ├─29｜DIContainer（17）：如何重构ContextConfig内部的实现？

│ │ │ ├─30｜DIContainer（18）：如何增补依赖缺失和循环依赖的测试？

│ │ │ ├─31｜DIContainer（19）：Qualifier部分的功能要如何完成？

│ │ │ ├─32｜DIContainer（20）：如何对代码和测试进行重构？

│ │ │ ├─33｜DIContainer（21）：如何处理Singleton生命周期部分的功能？

│ │ │ ├─34｜DIContainer（22）：如何对Bind的逻辑进行重构？

│ │ │ ├─35｜DIContainer（23）：项目回顾与总结

│ │ │ ├─36｜实战中的TDD：RESTfulWebServices

│ │ │ ├─37｜RESTfulWebServices（1）：明确架构愿景与架构组件间的交互

│ │ │ ├─38｜RESTfulWebServices（2）：根据Spike的结果，要如何调整架构愿景？

│ │ │ ├─39｜RESTfulWebServices（3）：明确架构愿景与调用栈顺序

│ │ │ ├─40｜RESTfulWebServices（4）：在当前架构愿景下，要如何分解任务？

│ │ │ ├─41｜RESTfulWebServices（5）：如何通过对数据测试的管理来凸显意图？

│ │ │ ├─42｜RESTfulWebServices（6）：如何处理JAX-RS定义的异常类？

│ │ │ ├─43｜RESTfulWebServices（7）：剩下两个SadPath场景该如何处理？

│ │ │ ├─44｜RESTfulWebServices（8）：如何在现有代码的基础上构造测试？

│ │ │ ├─45｜RESTfulWebServices（9）：通过伦敦学派得到的测试风格是什么样的？

│ │ │ ├─46｜RESTfulWebServices（10）：伦敦学派与经典学派的测试节奏有何不同？

│ │ │ ├─47｜RESTfulWebServices（11）：如何通过Spike来验证架构愿景？

│ │ │ ├─48｜RESTfulWebServices（12）：如何调整接口和架构愿景？

│ │ │ ├─49｜RESTfulWebService（13）：如何SpikeSub-ResourceLocator？

│ │ │ ├─50｜RESTfulWebServices（14）：分解任务与Setup测试

│ │ │ ├─51｜RESTfulWebServices（15）：为什么选择在第一个测试之后就开始重构？

│ │ │ ├─52｜RESTfulWebServices（16）：重构手法之设计方法名的名称

│ │ │ ├─53｜RESTfulWebServices（17）：如何进行Spike的架构愿景细化？

│ │ │ ├─54｜RESTfulWebServices（18）：如何实现UriTemplate的主要功能？

│ │ │ ├─55｜RESTfulWebServices（19）：如何更有效地构造测试数据？

│ │ │ ├─56｜RESTfulWebServices（20）：为什么要通过测试的方法来驱动出代码结构？

│ │ │ ├─57｜RESTfulWebServices（21）：按照三角法，该如何增加新的测试案例？

│ │ │ ├─58｜RESTfulWebServices（22）：重构还是继续完成功能？

│ │ │ ├─59｜RESTfulWebServices（23）：如何构造测试数据？

│ │ │ ├─60｜RESTfulWebServices（24）：RootResource的测试要如何改造？

│ │ │ ├─61｜RESTfulWebServices（25）：如何重构DefaultResourceRouter中的Result结构？

│ │ │ ├─62｜RESTfulWebServices（26）：如何继续划分ResourceLocator的任务？

│ │ │ ├─63｜RESTfulWebServices（27）：如何通过重构修改接口？

│ │ │ ├─64｜RESTfulWebServices（28）：如何重构Resource、SubResource等接口与实现？

│ │ │ ├─65｜RESTfulWebServices（29）：后续任务将要如何划分与实现？

│ │ │ ├─66｜RESTfulWebServices（30）：什么情况下应该使用行为验证？

│ │ │ ├─67｜RESTfulWebServices（31）：对于option的测试策略应该是怎样的？

│ │ │ ├─68｜RESTfulWebServices（32）：目前代码中的一个重大Bug是什么？

│ │ │ ├─69｜RESTfulWebServices（33）：如何拆分对于injection部分的需求？

│ │ │ ├─70｜RESTfulWebServices（34）：在当前代码结构下，要如何进行重构？

│ │ │ ├─71｜RESTfulWebServices（35）：如何将测试改为动态测试？

│ │ │ ├─72｜RESTfulWebServices（36）：在现有结构下，如何支持转换构造函数？

│ │ │ ├─73｜RESTfulWebServices（37）：再增加converter方法时，步骤有什么不同？

│ │ │ ├─74｜RESTfulWebServices（38）：如何提取方法调用部分？

│ │ │ ├─75｜RESTfulWebServices（39）：如何使用继承的方式来复用测试？

│ │ │ ├─76｜RESTfulWebServices（40）：如何开展有效的集成测试？

│ │ │ ├─77｜RESTfulWebServices（41）：对于资源的访问，我们需要补充哪些相关功能？

│ │ │ ├─78｜RESTfulWebServices（42）：项目总结与回顾

│ │ │ ├─79｜线段编辑器：架构思路与任务拆分

│ │ │ ├─80｜LineEditor（2）：如何重构生成与更新锚点控制点的逻辑？

│ │ │ ├─81｜结束语：掌握TDD的那天，我才成为了可靠高效的职业程序员

│ │ │ ├─代码评点01｜不同语言TDD的节奏有何不同？

│ │ │ ├─代码评点02｜什么是合适TDD的语言和IDE？

│ │ │ ├─开篇词｜为什么TDD是当前最具工程效能的研发流程？

│ │ │ ├─用户故事01｜aoe：如果把《重构》这本书拍成电视剧

│ │ │ ├─课前必读01｜20年前的“老古董”技术，为什么还值得开个课？

│ │ │ ├─课前必读02｜程序员究竟是搞技术的，还是做工程的？

│ │ │ └─课前必读02｜程序员究竟是搞技术的，还是做工程的？

│ │ ├─193超级访谈：对话汤峥嵘

│ │ │ ├─01-看似理性的程序员为什么可能是最不讲理的？

│ │ │ ├─02-个人性格影响“企业性格”，企业文化离不开人

│ │ │ ├─03-闲话家常（一）：半工半读的留学生活

│ │ │ ├─04-闲话家常（二）：匹兹堡6年与硅谷4年工作经历

│ │ │ ├─05-从排斥到拥护，我眼中的阿里文化

│ │ │ ├─06-怎样才能遇到自己的“贵人”？

│ │ │ ├─07-选行业秘诀：技术是否能发挥重要作用？

│ │ │ ├─08-途牛野蛮生长，也促使CTO“野蛮生长”

│ │ │ ├─09-闲话家常（三）：纽约打工故事续集

│ │ │ ├─10-管理的本质：如何把硬性政策柔性执行？

│ │ │ ├─11-为什么建议技术团队的组织架构按系统划分？

│ │ │ ├─12-技术、产品、业务三方关系？谁水平高听谁的

│ │ │ ├─13-CTO直接下属有60个总监，怎么管理？

│ │ │ ├─14-无边界访谈：创业思考与高手视角

│ │ │ ├─193超级访谈：对话汤峥嵘

│ │ │ ├─有奖征集-邀请你填写问卷反馈

│ │ │ ├─篇首语-认识汤峥嵘

│ │ │ ├─结束语-给技术人的一封信

│ │ │ └─结束语-给技术人的一封信

│ │ ├─194ReactNative新架构实战课

│ │ │ ├─01｜学习ReactNative，你需要掌握哪些知识？

│ │ │ ├─02｜Component：搭建静态页面的正确思路是什么？

│ │ │ ├─03｜Style：关于样式你需要知道的三件事

│ │ │ ├─04｜State：如何让页面“动”起来？

│ │ │ ├─05｜Image：选择适合你的图片加载方式

│ │ │ ├─06｜Pressable：如何实现一个体验好的点按组件？

│ │ │ ├─07｜TextInput：如何实现一个体验好的输入框？

│ │ │ ├─08｜List：如何实现高性能的无限列表？

│ │ │ ├─09｜FastRefresh：提高UI调试效率神器

│ │ │ ├─10｜Debug：解决BUG思路有哪些？

│ │ │ ├─11｜组件实战：如何实现瀑布流？

│ │ │ ├─12｜页面实战：如何搭建一个电商首页？

│ │ │ ├─13｜生态：ReactNativeAwesome

│ │ │ ├─14｜Reanimated：如何让动画变得更流畅？

│ │ │ ├─15｜Gesture（上）：如何实现一个拖拽动效？

│ │ │ ├─16｜Gesture（中）：如何解决单视图多手势的冲突问题？

│ │ │ ├─17｜Gesture（下）：如何解决多视图多手势的冲突问题？

│ │ │ ├─18｜Navigation：页面之间怎么跳转？

│ │ │ ├─194ReactNative新架构实战课

│ │ │ ├─19｜Redux：大型应用应该如何管理状态？

│ │ │ ├─20｜Sentry：线上错误与性能监控怎么处理？

│ │ │ ├─21｜混合应用：如何从零开始集成ReactNative？

│ │ │ ├─22｜自定义组件：如何满足业务的个性化需求？

│ │ │ ├─23｜热更新：如何搭建一个热更新平台？

│ │ │ ├─24｜拆包：Metro拆包的工作原理是什么？

│ │ │ ├─25｜性能优化：如何设计一个合适的性能优化方案？

│ │ │ ├─26｜客户端优化：如何把性能提升到极致？

│ │ │ ├─27｜跨端的机遇：小程序、Flutter和ReactNative原理对比

│ │ │ ├─28｜追本溯源：从第一版ReactNative开始学会读懂源码

│ │ │ ├─29｜弄清现状：新架构预览版究竟长什么样？

│ │ │ ├─30｜JavaScript引擎：双向通讯底层原理是什么？

│ │ │ ├─开篇词｜为什么要选择ReactNative做你的跨端方案？

│ │ │ ├─总结与展望｜新架构探索之旅，马上开始

│ │ │ ├─直播加餐｜七年，我的跨端实践和探索

│ │ │ ├─阶段测试｜ReactNative的这些核心知识，你都掌握了吗？

│ │ │ └─阶段测试｜ReactNative的这些核心知识，你都掌握了吗？

│ │ ├─195遗留系统现代化实战

│ │ │ ├─01｜遗留系统之殇：为什么要对遗留系统进行现代化？

│ │ │ ├─02-遗留系统现代化：遗留系统的四化建设

│ │ │ ├─03｜以降低认知负载为前提：为什么遗留系统这么难搞？

│ │ │ ├─04-如何降低认知负载：活的文档能救命

│ │ │ ├─05-以假设驱动为指引：如何评价遗留系统的现代化成果？

│ │ │ ├─06-以增量演进为手段：为什么历时一年的改造到头来是一场空？

│ │ │ ├─07-遗留系统现代化的五种策略：重构还是重写？这是一个问题

│ │ │ ├─08-代码现代化：你的代码可测吗？

│ │ │ ├─09-代码现代化：如何将一个300行的方法重构为3行？

│ │ │ ├─10-代码现代化：代码的分层重构

│ │ │ ├─11-架构现代化：在气泡上下文中打造你的新城区

│ │ │ ├─12-架构现代化：微服务，你准备好了吗？

│ │ │ ├─13-架构现代化：如何改造老城区前端？

│ │ │ ├─14-架构现代化：如何改造老城区后端？

│ │ │ ├─15-架构现代化：如何拆分数据？

│ │ │ ├─16｜DevOps现代化：从持续构建到持续集成

│ │ │ ├─17-DevOps现代化：从持续集成到持续部署

│ │ │ ├─18-团队结构现代化：从组件团队到Spotify模型

│ │ │ ├─19-团队结构现代化：团队拓扑学

│ │ │ ├─195遗留系统现代化实战

│ │ │ ├─20｜启动：如何开启一个遗留系统现代化项目？

│ │ │ ├─21｜微服务拆分（一）：迈出遗留系统现代化第一步

│ │ │ ├─22｜微服务拆分（二）：三招搞定数据库表解耦

│ │ │ ├─23｜微服务拆分（三）：如何拆分存储过程？

│ │ │ ├─24｜微服务拆分（四）：其他话题

│ │ │ ├─25｜成果验证：如何评价遗留系统现代化项目的成败？

│ │ │ ├─大咖助阵｜存储过程的拆分锦囊

│ │ │ ├─开篇词｜你现在所写的每一行代码，都是未来的遗留系统

│ │ │ ├─结束语｜技术终将老去，但好在你还年轻

│ │ │ └─结束语｜技术终将老去，但好在你还年轻

│ │ ├─196林外·专利写作第一课

│ │ │ ├─01-为什么我推荐互联网人要积极写专利？

│ │ │ ├─02-奖金是专利写作中最不值得一提的事儿

│ │ │ ├─03-找到KeyPerson利益点，提升专利通过率

│ │ │ ├─04-像写PRD一样，撰写专利交底书（一）

│ │ │ ├─05-像写PRD一样，撰写专利交底书（二）

│ │ │ ├─06-如何把常见的生活问题变成专利？

│ │ │ ├─07-专利创新的步伐不必迈得特别大

│ │ │ ├─08-那些异想天开的专利是怎么诞生的？

│ │ │ ├─196林外·专利写作第一课

│ │ │ ├─开篇词-写专利，将是知识工作者的核心产出

│ │ │ ├─答疑-专利申请十大常见问题

│ │ │ ├─结束语-用出世的心态，来入世工作

│ │ │ └─结束语-用出世的心态，来入世工作

│ │ ├─197说透元宇宙

│ │ │ ├─01-互联网科技巨头与资本追逐元宇宙，他们在追逐什么？

│ │ │ ├─02-元宇宙简史：能看到多远的过去，就能看到多远的未来

│ │ │ ├─03-元宇宙=立体互联网：当我们的手和眼摆脱屏幕的束缚

│ │ │ ├─04-元宇宙=价值互联网：当我们在数字空间能拥有物品

│ │ │ ├─05-扫描实体世界：将真实的世界数字化

│ │ │ ├─06-渲染数字世界：“欺骗”你的眼睛与大脑

│ │ │ ├─07-操控数字世界：用手与身体取代键盘

│ │ │ ├─08-数字财产确权：用区块链建立数字所有权管理系统

│ │ │ ├─09-数字交易协议：在数字空间“复制”社会经济活动

│ │ │ ├─10-数字治理协议：数字世界中的人如何组织与大规模协作

│ │ │ ├─11-走向元宇宙：元宇宙的四大应用象限

│ │ │ ├─12-走向元宇宙：数字化工作与生活

│ │ │ ├─197说透元宇宙

│ │ │ ├─开篇词-为什么我们应关注元宇宙？

│ │ │ ├─期末测试-来赴一场满分之约！

│ │ │ ├─结束语-迎接下一代互联网的无限可能

│ │ │ └─结束语-迎接下一代互联网的无限可能

│ │ ├─198人人都用得上的数字化思维课

│ │ │ ├─01-全局视角：如何看待数字化是一种必然趋势？

│ │ │ ├─02-数字化与信息化，为啥一定要去刻意区分呢？

│ │ │ ├─03-数据：用数据思考问题，到底是什么意思？

│ │ │ ├─04-软件：数据定义和数据工具，才是用好数据的关键

│ │ │ ├─05-网络：重视协作，构建属于自己的生态

│ │ │ ├─06-看时代：重新定义数字人才

│ │ │ ├─07-如何避免陷入学乱了、学杂了的窘境？

│ │ │ ├─08-如何从架构的视角去解读数字化相关政策？

│ │ │ ├─09-数字经济：数字化会带来哪些变化？

│ │ │ ├─10-未来15年，数字化会给我们带来哪些变化？

│ │ │ ├─198人人都用得上的数字化思维课

│ │ │ ├─开篇词-揭开数字化的神秘面纱，这次咱这么学

│ │ │ ├─结束语-你的变化，就是数字时代的一个缩影

│ │ │ └─结束语-你的变化，就是数字时代的一个缩影

│ │ ├─199中间件核心技术与实战

│ │ │ ├─01｜中间件生态（上）：有哪些类型的中间件？

│ │ │ ├─02｜中间件生态（下）：同类型的中间件如何进行选型？

│ │ │ ├─03-数组与链表：存储设计的基石有哪些？

│ │ │ ├─04-红黑树：图解红黑树的构造过程与应用场景

│ │ │ ├─05-多线程：多线程编程有哪些常见的设计模式？

│ │ │ ├─06-锁：如何理解锁的同步阻塞队列与条件队列？

│ │ │ ├─07-NIO：手撸一个简易的主从多Reactor线程模型

│ │ │ ├─08-Netty：如何优雅地处理网络读写，制定网络通信协议？(1)

│ │ │ ├─08-Netty：如何优雅地处理网络读写，制定网络通信协议？

│ │ │ ├─09｜技术选型：如何选择微服务框架和注册中心？

│ │ │ ├─10｜设计原理：Dubbo核心设计原理剖析

│ │ │ ├─11｜案例：如何基于Dubbo进行网关设计？

│ │ │ ├─12｜案例：如何实现蓝绿发布？

│ │ │ ├─13-技术选型：如何根据应用场景选择合适的消息中间件？

│ │ │ ├─14｜性能之道：RocketMQ与Kafka高性能设计对比

│ │ │ ├─15｜案例：消息中间件如何实现蓝绿？

│ │ │ ├─16｜案例：如何提升RocketMQ顺序消费性能？

│ │ │ ├─17｜运维：如何运维日均亿级的消息集群？

│ │ │ ├─18｜案例：如何排查RocketMQ消息发送超时故障？

│ │ │ ├─199中间件核心技术与实战

│ │ │ ├─19｜案例：如何排查RocketMQ消息消费积压问题？

│ │ │ ├─20｜技术选型：分布式定时调度框架的功能和未来

│ │ │ ├─21｜设计理念：如何基于ZooKeeper设计准实时架构？

│ │ │ ├─22｜案例：使用分布式调度框架该考虑哪些问题？

│ │ │ ├─23｜案例：如何在生产环境进行全链路压测？

│ │ │ ├─加餐-中间件底层的通用设计理念

│ │ │ ├─大咖助阵-高楼：我们应该如何学习中间件？

│ │ │ ├─开篇词｜为什么中间件对分布式架构体系来说这么重要？

│ │ │ ├─期中测试-来检验一下你的学习成果吧！

│ │ │ ├─期中测试答案-这些问题，你都答对了吗？

│ │ │ ├─用户故事-学而时习之，不亦乐乎

│ │ │ ├─用户故事-愿做技术的追梦人

│ │ │ ├─用户故事-浪费时间也是为了珍惜时间

│ │ │ ├─结束语｜坚持不懈，越努力越幸运

│ │ │ └─结束语｜坚持不懈，越努力越幸运

│ │ ├─200Kubernetes入门实战课

│ │ │ ├─01｜初识容器：万事开头难

│ │ │ ├─02｜被隔离的进程：一起来看看容器的本质

│ │ │ ├─03｜容器化的应用：会了这些你就是Docker高手

│ │ │ ├─04｜创建容器镜像：如何编写正确、高效的Dockerfile

│ │ │ ├─05｜镜像仓库：该怎样用好DockerHub这个宝藏

│ │ │ ├─06｜打破次元壁：容器该如何与外界互联互通

│ │ │ ├─07｜实战演练：玩转Docker

│ │ │ ├─08｜视频：入门篇实操总结

│ │ │ ├─09｜走近云原生：如何在本机搭建小巧完备的Kubernetes环境

│ │ │ ├─10｜自动化的运维管理：探究Kubernetes工作机制的奥秘

│ │ │ ├─11｜YAML：Kubernetes世界里的通用语

│ │ │ ├─12｜Pod：如何理解这个Kubernetes里最核心的概念？

│ │ │ ├─13｜Job-CronJob：为什么不直接用Pod来处理业务？

│ │ │ ├─14｜ConfigMap-Secret：怎样配置、定制我的应用

│ │ │ ├─15｜实战演练：玩转Kubernetes（1）

│ │ │ ├─16｜视频：初级篇实操总结

│ │ │ ├─17｜更真实的云原生：实际搭建多节点的Kubernetes集群

│ │ │ ├─18｜Deployment：让应用永不宕机

│ │ │ ├─19｜Daemonset：忠实可靠的看门狗

│ │ │ ├─200Kubernetes入门实战课

│ │ │ ├─20｜Service：微服务架构的应对之道

│ │ │ ├─21｜Ingress：集群进出流量的总管

│ │ │ ├─22｜实战演练：玩转Kubernetes（2）

│ │ │ ├─23｜视频：中级篇实操总结

│ │ │ ├─24｜PersistentVolume：怎么解决数据持久化的难题？

│ │ │ ├─25｜PersistentVolume+NFS：怎么使用网络共享存储？

│ │ │ ├─26｜StatefulSet：怎么管理有状态的应用？

│ │ │ ├─27｜滚动更新：如何做到平滑的应用升级降级？

│ │ │ ├─28｜应用保障：如何让Pod运行得更健康？

│ │ │ ├─29｜集群管理：如何用名字空间分隔系统资源？

│ │ │ ├─30｜系统监控：如何使用MetricsServer和Prometheus？

│ │ │ ├─31｜网络通信：CNI是怎么回事？又是怎么工作的？

│ │ │ ├─32｜实战演练：玩转Kubernetes（3）

│ │ │ ├─33｜视频：高级篇实操总结

│ │ │ ├─加餐｜docker-compose：单机环境下的容器编排工具

│ │ │ ├─加餐｜Kubernetes“弃用Docker”是怎么回事？

│ │ │ ├─开篇词｜迎难而上，做云原生时代的弄潮儿

│ │ │ ├─结束语｜是终点，更是起点

│ │ │ ├─课前准备｜动手实践才是最好的学习方式

│ │ │ └─课前准备｜动手实践才是最好的学习方式

│ │ ├─201大厂设计进阶实战课

│ │ │ ├─01｜业务周期：0-1-10-100-N的发展策略

│ │ │ ├─02｜商战模式：如何在商业竞争下突出重围？

│ │ │ ├─03｜市场洞察：如何找寻差异化撬动支点？

│ │ │ ├─04｜用户洞察：不懂用研的设计师不是好职场人

│ │ │ ├─05｜用户画像：是形式主义还是真的有效？

│ │ │ ├─06｜用户旅程：挖掘不同用户的核心机会点

│ │ │ ├─07｜职场晋升：看懂晋升的“游戏规则”

│ │ │ ├─08｜设计价值升级：五层进阶突破成长

│ │ │ ├─09基础价值｜核心三原力：如何将需求转化为设计稿？

│ │ │ ├─10基础价值｜第一性原理：从问题本质解决问题

│ │ │ ├─11基础价值｜设计复盘：只是量化设计结果吗？

│ │ │ ├─12二级价值｜负向网兜：如何全面发现负向问题？

│ │ │ ├─13二级价值｜设计自驱：如何做好项目Owner？

│ │ │ ├─14二级价值｜自驱合作：如何反内卷处理合作关系？

│ │ │ ├─15三级价值｜增长误区：思维惯性陷阱和虚荣数据

│ │ │ ├─16三级价值｜用户增长历程：AARRR是万能的吗？

│ │ │ ├─17三级价值｜产品增长：如何做好产品创新？

│ │ │ ├─18三级价值｜运营增长：如何自驱营销活动和投放？

│ │ │ ├─19三级价值｜品牌增长-抢占心智，赢得人心红利

│ │ │ ├─201大厂设计进阶实战课

│ │ │ ├─20三级价值｜增长实操：如何“步步为营”推动落地？

│ │ │ ├─21四级价值｜L型赋能：让T型人才发挥更大价值

│ │ │ ├─22四级价值｜“网状对比”解决共性痛点

│ │ │ ├─23五级价值｜商业画布：设计师可以担任业务方吗？

│ │ │ ├─24五级价值｜共创洞察：如何做好一次完善的workshop？

│ │ │ ├─25五级价值｜领导力觉醒：写给新晋管理者

│ │ │ ├─26｜工作选择（上）：2Bor2C设计师？如何规划领域？

│ │ │ ├─27｜工作选择（下）：大厂or小厂？如何选择赛道？

│ │ │ ├─28｜人才地图：认知自我，成为高潜力人才

│ │ │ ├─29｜成长历程：如何从设计小白成长为团队负责人？

│ │ │ ├─30｜冰山模型：如何成为让面试官欣赏的“面霸”？

│ │ │ ├─31｜作品集指导：什么是面试官喜欢的作品集？

│ │ │ ├─开篇词｜升维思考，是设计师有效成长的第一步

│ │ │ ├─用户故事｜什么是职场设计师进阶的正确姿势？

│ │ │ ├─结束语｜突破自我，成人达己

│ │ │ └─结束语｜突破自我，成人达己

│ │ ├─202快手·音视频技术入门课

│ │ │ ├─01｜如何从色彩格式、帧率等参数角度看视频图像？

│ │ │ ├─02｜音频从采集到输出涉及哪些关键参数？

│ │ │ ├─03｜如何做音视频的封装与转码？

│ │ │ ├─04｜直播行业的发展概况与技术迭代

│ │ │ ├─05｜如何使用FFmpeg与OBS进行直播推流？

│ │ │ ├─06｜如何使用ffprobe分析音视频参数与内容？

│ │ │ ├─07-如何高效查找并使用FFmpeg常用参数？

│ │ │ ├─08｜FFmpeg和它的朋友们是怎么处理MP4的？

│ │ │ ├─09｜如何使用FFmpeg与Handbrake做转码？

│ │ │ ├─10-FFmpeg基础模块（一）：容器相关的API操作

│ │ │ ├─11-FFmpeg基础模块（二）：AVIO、AVDictionary与AVOption

│ │ │ ├─12-FFmpeg基础模块（三）：AVCodec

│ │ │ ├─13-FFmpeg有哪些常见的应用场景？

│ │ │ ├─14｜如何在FFmpeg中定制一个自己专属的模块？

│ │ │ ├─15｜如何参与到FFmpeg社区交流中？

│ │ │ ├─202快手·音视频技术入门课

│ │ │ ├─开篇词｜想快速入门音视频技术，你得这么学

│ │ │ ├─结束语｜音视频技术更宠爱脚踏实地的人

│ │ │ └─结束语｜音视频技术更宠爱脚踏实地的人

│ │ ├─203快手·移动端音视频开发实战

│ │ │ ├─01｜iOS平台音频渲染（一）：使用AudioQueue渲染音频

│ │ │ ├─02｜iOS平台音频渲染（二）：使用AudioUnit渲染音频

│ │ │ ├─03｜Android平台音频渲染与技术选型

│ │ │ ├─04｜移动平台的视频渲染（一）：OpenGLES基础

│ │ │ ├─05｜移动平台的视频渲染（二）：OpenGLES上下文环境搭建

│ │ │ ├─06｜移动平台的视频渲染（三）：OpenGLES实操

│ │ │ ├─07｜播放器项目实战（一）：场景分析与架构设计

│ │ │ ├─08｜播放器项目实战（二）：底层核心模块的实现

│ │ │ ├─09｜播放器项目实践（三）：让你的播放器跑起来

│ │ │ ├─10｜iOS平台音频采集：如何使用AudioQueue和AudioUnit采集音频？

│ │ │ ├─11｜Android平台音频采集：如何使用AudioRecord和Oboe采集音频？

│ │ │ ├─12｜如何编码出一个AAC文件？

│ │ │ ├─13｜如何使用硬件编码器来编码AAC？

│ │ │ ├─14｜iOS平台如何采集视频画面？

│ │ │ ├─15｜Android平台是如何采集视频画面的？

│ │ │ ├─16｜视频编码的工作原理与H

│ │ │ ├─17｜如何用软件编码器来编码H264？

│ │ │ ├─18｜如何使用移动平台的硬件编码器？

│ │ │ ├─19｜视频录制项目实战：场景分析与架构设计

│ │ │ ├─203快手·移动端音视频开发实战

│ │ │ ├─20｜如何实现视频录制器的底层模块？（上）

│ │ │ ├─21｜如何实现视频录制器的底层模块？（下）

│ │ │ ├─22｜视频录制项目实战：让你的录制器运行起来

│ │ │ ├─开篇词｜系统学习移动端音视频开发技术，为业务赋能

│ │ │ ├─结束语｜跳出舒适区，拥抱变化

│ │ │ └─结束语｜跳出舒适区，拥抱变化

│ │ ├─204商业思维案例笔记

│ │ │ ├─01-导读：我们说商业思维时，到底在说什么？

│ │ │ ├─02-成本：马斯克的猎鹰火箭为什么可以这么便宜？

│ │ │ ├─03-效率：为什么Facebook的客户以中小为主？

│ │ │ ├─04-收益（上）：阳光养猪场等网赚游戏为什么在19年后突然火了？

│ │ │ ├─05-收益（下）：阳光养猪场等网赚游戏为什么在19年后突然火了？

│ │ │ ├─06-体验：链家为什么可以从线下起家反超所有互联网房企？

│ │ │ ├─07-练习课：如何判断自己的业务是否靠谱？

│ │ │ ├─08-二维解构：社区团购为什么成为20年巨头必争的赛道？

│ │ │ ├─09-二八法则：为什么Flipboard等免费精品阅读领域做不大呢？

│ │ │ ├─10-盐铁官营：手机厂商为什么可以在移动互联网时代闷声发大财？

│ │ │ ├─11-分层运营：外卖市场上为什么美团可以后发制人？

│ │ │ ├─12-时间刻度（上）：为什么优酷土豆会从行业第一下滑到行业第三？

│ │ │ ├─13-时间刻度（下）：为什么优酷土豆会从行业第一下滑到行业第三？

│ │ │ ├─14-练习课（上）：如何用结构性思考去理解20多年中国互联网发展的变化？

│ │ │ ├─15-练习课（下）：如何用结构性思考去理解20多年中国互联网发展的变化？

│ │ │ ├─16｜权限：为什么360在移动端没有延续PC端的辉煌？

│ │ │ ├─17｜环境：为什么百度在移动时代坐视字节的崛起？

│ │ │ ├─18｜规则：豌豆荚做不起来应用内搜索？

│ │ │ ├─19｜资本（上）：为什么杨浩涌二次创业一定要融大钱？

│ │ │ ├─204商业思维案例笔记

│ │ │ ├─20｜资本（下）：为什么杨浩涌二次创业一定要融大钱？

│ │ │ ├─21｜角色（上）：失败的来往和成功的钉钉后面为什么都是陈航（无招）？

│ │ │ ├─22｜角色（下）：失败的来往和成功的钉钉后面为什么都是陈航（无招）？

│ │ │ ├─23｜练习课：如何在实际工作中规避方法论的过度影响？

│ │ │ ├─24｜错位：拼多多缘何在电商市场的红海中再杀出一片天？

│ │ │ ├─25｜玩法：大逃杀电影出了那么多年，为什么才诞生绝地求生？

│ │ │ ├─26｜边界（上）：没有任何硬件基础的小米，为什么可以成为国内第一手机厂商？

│ │ │ ├─27｜边界（下）：没有任何硬件基础的小米，为什么可以成为国内第一手机厂商？

│ │ │ ├─28｜练习课：如何用开放的心态来挖掘非共识机会？

│ │ │ ├─29｜平台：91手机助手卖掉为什么是明智的选择？

│ │ │ ├─30｜盈利：哈啰单车为什么可以在一地鸡毛的共享单车中逆势杀出？

│ │ │ ├─31｜基础：WiFi万能钥匙为什么崛起又为什么落寞？

│ │ │ ├─32｜需求：为什么大部分O2O项目都是漫天烟花？

│ │ │ ├─33｜竞争：为什么共享充电宝不是一个好生意？

│ │ │ ├─34｜练习课：终局思维还可以运用在日常生活哪些方面？

│ │ │ ├─35｜行业：如何在一周内快速了解一个行业？

│ │ │ ├─36｜呈现：对上汇报方案什么样的结构最有效？

│ │ │ ├─37｜目标：如果目标是让猪上树，最好的方式是什么？

│ │ │ ├─中秋加餐｜《商业思维案例笔记》推荐书单

│ │ │ ├─中秋加餐｜直播回顾：B站的商业化之路到底难在哪？

│ │ │ ├─双周行业热点评论｜字节去肥增瘦，抖音爱奇艺联姻，每日优鲜破产

│ │ │ ├─双周行业热点追踪｜字节去肥增瘦，抖音爱奇艺联姻，每日优鲜破产

│ │ │ ├─复习加餐｜3组图探寻非共识机会！

│ │ │ ├─复习加餐｜4组图看懂价值创造！

│ │ │ ├─复习加餐｜5组图摸透非规律世界！

│ │ │ ├─复习加餐｜5组图收获终局思维！

│ │ │ ├─复习加餐｜5组图读懂商业洞察！

│ │ │ ├─大咖助阵｜演进：YY诞生17年，微信诞生11年，为什么语音类产品依旧层出不穷？

│ │ │ ├─开篇词｜商业思维是每个互联网人都应具备的升维能力

│ │ │ ├─热点速递｜《羊了个羊》原来根本没想让我过关！

│ │ │ ├─结束语｜橘子不是唯一的水果

│ │ │ └─结束语｜橘子不是唯一的水果

│ │ ├─205计算机基础实战课

│ │ │ ├─01｜CISC&RISC：从何而来，何至于此

│ │ │ ├─02｜RISC特性与发展：RISC-V凭什么成为“半导体行业的Linux”？

│ │ │ ├─03｜硬件语言筑基（一）：从硬件语言开启手写CPU之旅

│ │ │ ├─04｜硬件语言筑基（二）-代码是怎么生成具体电路的？

│ │ │ ├─05｜指令架构：RISC-V在CPU设计上到底有哪些优势？

│ │ │ ├─06｜手写CPU（一）：迷你CPU架构设计与取指令实现

│ │ │ ├─07｜手写CPU（二）：如何实现指令译码模块？

│ │ │ ├─08｜手写CPU（三）：如何实现指令执行模块？

│ │ │ ├─09｜手写CPU（四）：如何实现CPU流水线的访存阶段？

│ │ │ ├─10｜手写CPU（五）：CPU流水线的写回模块如何实现？

│ │ │ ├─11｜手写CPU（六）：如何让我们的CPU跑起来？

│ │ │ ├─12｜QEMU：支持RISC-V的QEMU如何构建？

│ │ │ ├─13｜小试牛刀：跑通RISC-V平台的HelloWorld程序

│ │ │ ├─14｜走进C语言：高级语言怎样抽象执行逻辑？

│ │ │ ├─15｜C与汇编：揭秘C语言编译器的“搬砖”日常

│ │ │ ├─16｜RISC-V指令精讲（一）：算术指令实现与调试

│ │ │ ├─17｜RISC-V指令精讲（二）：算术指令实现与调试

│ │ │ ├─18｜RISC-V指令精讲（三）：跳转指令实现与调试

│ │ │ ├─19｜RISC-V指令精讲（四）：跳转指令实现与调试

│ │ │ ├─205计算机基础实战课

│ │ │ ├─20｜RISC-V指令精讲（五）：原子指令实现与调试

│ │ │ ├─21｜RISC-V指令精讲（六）：加载指令实现与调试

│ │ │ ├─22｜RISC-V指令精讲（七）：访存指令实现与调试

│ │ │ ├─23｜内存地址空间：程序中地址的三种产生方式

│ │ │ ├─24｜虚实结合：虚拟内存和物理内存

│ │ │ ├─25｜堆&栈：堆与栈的区别和应用

│ │ │ ├─26｜延迟分配：提高内存利用率的三种机制

│ │ │ ├─27｜应用内存管理：Linux的应用与内存管理

│ │ │ ├─28｜进程调度：应用为什么能并行执行？

│ │ │ ├─29｜应用间通信（一）：详解Linux进程IPC

│ │ │ ├─30｜应用间通信（二）：详解Linux进程IPC

│ │ │ ├─31｜外设通信：IOCache与IO调度

│ │ │ ├─32｜IO管理：Linux如何管理多个外设？

│ │ │ ├─33｜lotop与lostat命令：聊聊命令背后的故事与工作原理

│ │ │ ├─34｜文件仓库：初识文件与文件系统

│ │ │ ├─35｜Linux文件系统（一）：Linux如何存放文件？

│ │ │ ├─36｜Linux文件系统（二）：Linux如何存放文件？

│ │ │ ├─37｜浏览器原理（一）：浏览器为什么要用多进程模型？

│ │ │ ├─38｜浏览器原理（二）：浏览器进程通信与网络渲染详解

│ │ │ ├─39｜源码解读：V8执行JS代码的全过程

│ │ │ ├─40｜内功心法（一）：内核和后端通用的设计思想有哪些？

│ │ │ ├─41｜内功心法（二）：内核和后端通用的设计思想有哪些？

│ │ │ ├─42｜性能调优：性能调优工具eBPF和调优方法

│ │ │ ├─先睹为快：迷你CPU项目效果演示

│ │ │ ├─国庆策划01｜知识挑战赛：检验一下学习成果吧！

│ │ │ ├─国庆策划02｜来自课代表的学习锦囊

│ │ │ ├─国庆策划03｜揭秘代码优化操作和栈保护机制

│ │ │ ├─开篇词｜练好基本功，优秀工程师成长第一步

│ │ │ ├─用户故事｜我是怎样学习Verilog的？

│ │ │ ├─结束语｜心若有所向往，何惧道阻且长

│ │ │ └─结束语｜心若有所向往，何惧道阻且长

│ │ ├─206Web3

│ │ │ ├─01-我们为什么需要Web3

│ │ │ ├─02-公链：从计算分层开始

│ │ │ ├─03-继续分层：身份和激励

│ │ │ ├─04-NFT（一）：数据确权及其文化和商业价值的发现

│ │ │ ├─05-NFT（二）：数据确权及其文化和商业价值的发现

│ │ │ ├─06-边玩边赚能给游戏和电商带来新的商业模式吗？

│ │ │ ├─07-Web3

│ │ │ ├─08-区块链：从底层重构金融

│ │ │ ├─09-DeFi：“三无模式”开辟金融新蓝海

│ │ │ ├─10-关于DAO的七个真相和两个趋势（一）

│ │ │ ├─11-关于DAO的七个真相和两个趋势（二）

│ │ │ ├─12-DeFi的空中楼阁能盖多高？

│ │ │ ├─13-代码和法律，哪个更强？

│ │ │ ├─14-Web3

│ │ │ ├─206Web3

│ │ │ ├─开篇词-Web3

│ │ │ ├─特别放送-YugaLabs：Web3

│ │ │ ├─结束语-Web3

│ │ │ └─结束语-Web3

│ │ ├─207现代ReactWeb开发实战

│ │ │ ├─01｜身为Web前端工程师，我都在开发什么？

│ │ │ ├─02｜开发前端有哪些要点？React框架是如何应对的？

│ │ │ ├─03｜看板应用：从零开始快速搭建一个React项目

│ │ │ ├─04｜JSX：如何理解这种声明式语法糖？

│ │ │ ├─05｜前端组件化：如何将完整应用拆分成React组件？

│ │ │ ├─06｜虚拟DOM：为什么要关心React组件的渲染机制？

│ │ │ ├─07｜组件样式：聊聊CSS-in-JS的特点和典型使用场景

│ │ │ ├─08｜组件生命周期：React新老版本中生命周期的演化

│ │ │ ├─09｜ReactHooks（上）：为什么说在React中函数组件和Hooks是绝配？

│ │ │ ├─10｜ReactHooks（下）：用Hooks处理函数组件的副作用

│ │ │ ├─11｜事件处理：React合成事件是什么？为什么不用原生DOM事件？

│ │ │ ├─12｜组件表与里（上）：数据是如何在React组件之间流转的？

│ │ │ ├─13｜组件表与里（下）：用接口的思路设计开发React组件

│ │ │ ├─14｜现代化React：现代工程化技术下的React项目

│ │ │ ├─15｜不可变数据：为什么对React这么重要？

│ │ │ ├─16｜应用状态管理（上）：应用状态管理框架Redux

│ │ │ ├─17｜应用状态管理（下）：该用React组件状态还是Redux？

│ │ │ ├─18｜数据类型：活用TypeScript做类型检查

│ │ │ ├─19｜代码复用：如何设计开发自定义Hooks和高阶组件？

│ │ │ ├─207现代ReactWeb开发实战

│ │ │ ├─20｜大型项目：源码越来越多，项目该如何扩展？

│ │ │ ├─21｜性能优化：保证优秀的用户体验

│ │ │ ├─22｜质量保证（上）：每次上线都出Bug？你需要E2E测试

│ │ │ ├─23｜质量保证（下）：测试金字塔与React单元测试

│ │ │ ├─24｜工程化与团队协作：让我们合作开发一个大型React项目

│ │ │ ├─加餐01｜留言区心愿单：真·子组件以及jsx-runtime

│ │ │ ├─加餐02｜留言区心愿单：Fiber协调引擎

│ │ │ ├─开篇词｜ReactWeb开发这样学，才能独当一面！

│ │ │ ├─直播加餐01｜前端开发为什么要工程化？

│ │ │ ├─直播加餐02｜Freewheel前端工程化的演进和最佳实践

│ │ │ ├─结束语｜对React和前端技术未来的展望

│ │ │ └─结束语｜对React和前端技术未来的展望

│ │ ├─208Serverless进阶实战课

│ │ │ ├─01-生命周期：函数计算的基本流程是如何执行的？

│ │ │ ├─02｜触发器：如何构建事件源与函数计算的纽带？

│ │ │ ├─03-高级属性：应对生产级别的应用，你需要掌握哪些技能？

│ │ │ ├─04｜冷启动：如何加快函数的第一次调用过程？

│ │ │ ├─05｜扩缩容：如何应对流量的波峰波谷？

│ │ │ ├─06-流量转发：函数在不同情形下是如何执行的？

│ │ │ ├─07-运行时（上）：不同语言形态下的函数在容器中是如何执行的？

│ │ │ ├─08-运行时（下）：不同语言形态下的函数在容器中是如何执行的？

│ │ │ ├─09-小试牛刀（一）：如何利用函数之间的调用解决业务问题？

│ │ │ ├─10｜小试牛刀（二）：如何突破VPC网络的速度限制？

│ │ │ ├─11-WebIDE：如何让函数远离繁琐的本地开发模式？

│ │ │ ├─12｜编排：如何协调多任务的运行？

│ │ │ ├─13-可观测（上）：如何构建多维度视角下的Serverless监测体系？

│ │ │ ├─14-可观测（下）：如何构建多维度视角下的Serverless监测体系？

│ │ │ ├─15-选型：不同阶段的数据应如何存储？

│ │ │ ├─16-动手体验（一）：如何实现业务高效率地开发上线？

│ │ │ ├─17-动手体验（二）：如何在云函数场景下实现一个有状态的服务？

│ │ │ ├─18｜实战指南：Serverless沙场老兵的一线使用经验

│ │ │ ├─19-实战进阶（一）：Serverless“连接器”的能力到底有多大？

│ │ │ ├─208Serverless进阶实战课

│ │ │ ├─20｜实战进阶（二）：如何基于智能音箱开发一个BOT技能？

│ │ │ ├─21｜实战进阶（三）：传统的服务如何迁移到Serverless平台？

│ │ │ ├─22｜私有云：赛马时代的Serverless核心引擎谁能胜出？

│ │ │ ├─23｜实战进阶（四）：如何从0到1进阶一个开源引擎？

│ │ │ ├─24-实战进阶（五）：如何从Serverless引擎蜕变成一个Serverless平台？

│ │ │ ├─开篇词｜Serverless是降本增效浪潮下的必然选择

│ │ │ ├─思维构建｜如何在新赛道下进阶Serverless能力？

│ │ │ ├─结束语｜在实战中把握事物本质，不断革新

│ │ │ └─结束语｜在实战中把握事物本质，不断革新

│ │ ├─209技术领导力实战笔记2022【更新中】

│ │ │ ├─01｜研发团队绩效考核：Leader如何做到赏罚分明？

│ │ │ ├─02｜如何打造一个“无需激励”自运转的技术团队？

│ │ │ ├─03｜技术型创业公司如何把握发展与管理的节奏感？

│ │ │ ├─04｜能力构建（上）：如何从做技术转变到做技术决策？

│ │ │ ├─05｜能力构建（下）：从管事到管人，需要迈过的坎

│ │ │ ├─06｜技术领导者如何“修炼”管理的艺术？

│ │ │ ├─07｜从员工批量离职中，认识管理的价值

│ │ │ ├─08｜技术分担产品之忧（上）：挑选有业务专家潜力的人

│ │ │ ├─09｜技术分担产品之忧（下）：产研如何融合？

│ │ │ ├─10｜技术管理者如何获得下属的认同？

│ │ │ ├─11｜用规则来搭建团队：写周报不一定是坏事

│ │ │ ├─12｜从任务分配角度来看管理

│ │ │ ├─209技术领导力实战笔记2022【更新中】

│ │ │ ├─开篇词｜他山之石：带你直面技术管理者的真实困局

│ │ │ └─开篇词｜他山之石：带你直面技术管理者的真实困局

│ │ ├─210深入浅出可观测性

│ │ │ ├─01-以史鉴今：监控是如何一步步发展而来的？

│ │ │ ├─02-基本概念：指标+日志+链路追踪=可观测性？

│ │ │ ├─03-相互对比：可观测性和传统监控有什么区别？

│ │ │ ├─04-OpenTelemetry：如何利用OpenTelemetry采集可观测数据？

│ │ │ ├─05-构建可观测平台：应该购买商业产品还是自己搭建？

│ │ │ ├─06-团队合作：不同团队如何高效共建可观测性？

│ │ │ ├─07-软件开发：如何利用可观测性进行驱动？

│ │ │ ├─08-建立SLO：如何为系统可靠性的量化提供依据？

│ │ │ ├─09-跟踪SLO：如何基于错误预算采取行动？

│ │ │ ├─10-实战1：从0到1建立系统应用的可观测性

│ │ │ ├─11-实战2：基于可观测性数据进行问题分析和根因定位

│ │ │ ├─12-实战3：构建基于Kubernetes的系统可观测性

│ │ │ ├─13-实战4：建立软件持续集成和发布的可观测性

│ │ │ ├─14-文化建设：如何构建可观测性的文化和框架

│ │ │ ├─15-展望未来：可观测性在未来的发展趋势是什么？

│ │ │ ├─210深入浅出可观测性

│ │ │ ├─开篇词-可观测性，让开发和维护系统的你每晚都能睡个好觉！

│ │ │ ├─期末考试-来赴一场满分之约吧～

│ │ │ ├─结束语-在实践中，用科学的方法分析和解决问题

│ │ │ └─结束语-在实践中，用科学的方法分析和解决问题

│ │ ├─211JavaScript进阶实战课【更新中】

│ │ │ ├─01-函数式vs

│ │ │ ├─02-如何通过闭包对象管理程序中状态的变化？

│ │ │ ├─03-如何通过部分应用和柯里化让函数具象化？

│ │ │ ├─04-如何通过组合、管道和reducer让函数抽象化？

│ │ │ ├─05｜map、reduce和monad如何围绕值进行操作？

│ │ │ ├─06-如何通过模块化、异步和观察做到动态加载？

│ │ │ ├─07-深入理解对象的私有和静态属性

│ │ │ ├─08｜深入理解继承、Delegation和组合

│ │ │ ├─09｜面向对象：通过词法作用域和调用点理解this绑定

│ │ │ ├─10｜JS有哪8种数据类型，你需要注意什么？

│ │ │ ├─11｜通过JS引擎的堆栈了解闭包原理

│ │ │ ├─12｜JS语义分析该用迭代还是递归？

│ │ │ ├─13-JS引擎如何实现数组的稳定排序？

│ │ │ ├─14-通过SparkPlug深入了解调用栈

│ │ │ ├─15-如何通过哈希查找JS对象内存地址？

│ │ │ ├─16-为什么环形队列适合做Node数据流缓存？

│ │ │ ├─17-如何通过链表做LRU-LFU缓存？

│ │ │ ├─18-TurboFan如何用图做JS编译优化？

│ │ │ ├─19-通过树和图看如何在无序中找到路径和秩序

│ │ │ ├─20-算法思想：JS中分治、贪心、回溯和动态规划

│ │ │ ├─21-创建型：为什么说Redux可以替代单例状态管理

│ │ │ ├─211JavaScript进阶实战课【更新中】

│ │ │ ├─22｜结构型：Vue

│ │ │ ├─23-结构型：通过jQuery看结构型模式

│ │ │ ├─24-行为型：通过观察者、迭代器模式看JS异步回调

│ │ │ ├─25-行为型：模版、策略和状态模式有什么区别？

│ │ │ ├─26｜特殊型：前端有哪些处理加载和渲染的特殊“模式”？

│ │ │ ├─27｜性能：如何理解JavaScript中的并行、并发？（上）

│ │ │ ├─28｜性能：如何理解JavaScript中的并行、并发？（下）

│ │ │ ├─29｜性能：通过Orinoco、JankBusters看垃圾回收

│ │ │ ├─30｜网络：从HTTP-1到HTTP-3，你都需要了解什么？

│ │ │ ├─31｜安全：JS代码和程序都需要注意哪些安全问题？

│ │ │ ├─开篇词-JavaScript的进阶之路

│ │ │ └─开篇词-JavaScript的进阶之路

│ │ ├─212Go进阶·分布式爬虫实战【更新中】

│ │ │ ├─01｜知识回顾：Go基础知识你真的掌握了吗？

│ │ │ ├─02｜内有乾坤：Go语言六大基础知识体系

│ │ │ ├─03｜进阶路线：如何深入学习Go语言？

│ │ │ ├─04｜敏捷之道：大型Go项目的开发流程是怎样的？

│ │ │ ├─05｜全局视野：洞悉项目开发流程与规范

│ │ │ ├─06｜免费的宝库-什么是网络爬虫？

│ │ │ ├─07｜冰川之下：深入Go高并发网络模型

│ │ │ ├─08｜高性能设计：自顶向下的高性能Go程序设计与优化

│ │ │ ├─09｜破解性能谜题：性能优化的五层境界

│ │ │ ├─10｜微服务设计：微服务架构与演进

│ │ │ ├─11｜微服务挑战：微服务治理体系与实践

│ │ │ ├─12｜分布式系统设计：数据一致性与故障容错的纠葛

│ │ │ ├─13｜智慧之火：详解分布式容错共识算法

│ │ │ ├─14｜谋定而动：爬虫项目需求分析与架构设计

│ │ │ ├─15｜众人拾柴：高效团队的Go编码规范

│ │ │ ├─16｜网络爬虫：一次HTTP请求的魔幻旅途

│ │ │ ├─17｜巨人的肩膀：HTTP协议与Go标准库原理

│ │ │ ├─18｜依赖管理：GoModule用法与原理

│ │ │ ├─19｜从正则表达式到CSS选择器：4种网页文本处理手段

│ │ │ ├─20｜面向组合：接口的使用场景与底层原理

│ │ │ ├─212Go进阶·分布式爬虫实战【更新中】

│ │ │ ├─21｜采集引擎：实战接口抽象与模拟浏览器访问

│ │ │ ├─22｜优雅的离场-Context超时控制与原理

│ │ │ ├─开篇词｜聚沙成塔，构建高性能、分布式爬虫项目

│ │ │ └─开篇词｜聚沙成塔，构建高性能、分布式爬虫项目

│ │ ├─213超级访谈：对话毕玄

│ │ │ ├─00｜番外：一位险些没上得了大学的青年，如何开启计算机征程

│ │ │ ├─01｜小厂项目：做程序员不难，难的是做职业程序员

│ │ │ ├─02｜小厂创业：做出一个产品，卖给所有人

│ │ │ ├─03｜淘宝HSF：能让淘宝出重大故障的就那批人

│ │ │ ├─04｜淘宝消防队：真正最优秀的程序员不应该是英雄

│ │ │ ├─05｜HBase-T4：Leader最重要的，说白了是要赌未来

│ │ │ ├─06｜异地多活：技术圈子的人，见过猪跑很重要

│ │ │ ├─07｜运维团队：我能干，只是我不想干而已

│ │ │ ├─08｜基础团队：研发效能部门，解决不了研发效能问题

│ │ │ ├─09｜统一调度：只是问题非常多而已，摔出来就行了

│ │ │ ├─10｜出走大厂：离职？还是不离职？这是一个问题

│ │ │ ├─11｜CEO心得：大厂出来创业，最大问题是对钱没概念

│ │ │ ├─213超级访谈：对话毕玄

│ │ │ ├─团队：在人身上，你到底愿意花多大精力？

│ │ │ ├─开篇词｜这一次，我们来采访毕玄

│ │ │ ├─成事：技术人最大的问题就是情怀化

│ │ │ ├─文化：你所在的团队，有多少人敢讲真话？

│ │ │ ├─方向：技术演进，到底该怎么思考未来？

│ │ │ ├─架构：架构师只是个角色，不是个岗位

│ │ │ └─架构：架构师只是个角色，不是个岗位

│ │ ├─214超级访谈：对话玉伯

│ │ │ ├─01-从页面仔到工程师，前端到底在发挥什么价值

│ │ │ ├─02-何为体验：把简单留给用户，也把简单留给自己

│ │ │ ├─03-终端技术：浅谈小程序与客户端的发展

│ │ │ ├─04-开源三大收获：异步协同、文档优先与快乐工作

│ │ │ ├─05-蚂蚁内部开源：迈出第一步，但还有很长路要走

│ │ │ ├─06-从淘宝到支付宝：几次项目失利，但创新产品之心未死

│ │ │ ├─07-产品故事：语雀两度生死局

│ │ │ ├─08-产品经理能力进阶：用户洞察、抽象设计到看到远方

│ │ │ ├─09-个人成长关键词一：全情投入

│ │ │ ├─10-个人成长关键词二：守正出奇

│ │ │ ├─11-个人成长关键词三：愿等花开

│ │ │ ├─12-作为创新产品聚集地，体验技术部成长土壤从何来

│ │ │ ├─13-行业内口碑第一的前端团队，如何打造文化

│ │ │ ├─14-管理能力提升：曾经影响过的书籍和启发过我的人

│ │ │ ├─15-从浆手、掌舵人到兜底人，管理者进阶的三阶段

│ │ │ ├─214超级访谈：对话玉伯

│ │ │ ├─开篇词-蚂蚁集团玉伯：人生不设限

│ │ │ ├─结束语-我想聊的一些与技术无关的话

│ │ │ └─结束语-我想聊的一些与技术无关的话

│ │ ├─215高并发系统实战课

│ │ │ ├─01｜结构梳理：大并发下，你的数据库表可能成为性能隐患

│ │ │ ├─02｜缓存一致：读多写少时，如何解决数据更新缓存不同步？

│ │ │ ├─03｜Token：如何降低用户身份鉴权的流量压力？

│ │ │ ├─04｜同城双活：如何实现机房之间的数据同步？

│ │ │ ├─05｜共识Raft：如何保证多机房数据的一致性？

│ │ │ ├─06｜领域拆分：如何合理地拆分系统？

│ │ │ ├─07｜强一致锁：如何解决高并发下的库存争抢问题？

│ │ │ ├─08｜系统隔离：如何应对高并发流量冲击？

│ │ │ ├─09｜分布式事务：多服务的2PC、TCC都是怎么实现的？

│ │ │ ├─10｜稀疏索引：为什么高并发写不推荐关系数据库？

│ │ │ ├─11｜链路追踪：如何定制一个分布式链路跟踪系统？

│ │ │ ├─12｜引擎分片：Elasticsearch如何实现大数据检索？

│ │ │ ├─13-实时统计：链路跟踪实时计算中的实用算法

│ │ │ ├─14｜跳数索引：后起新秀ClickHouse

│ │ │ ├─15｜实践方案：如何用C++自实现链路跟踪？

│ │ │ ├─16｜本地缓存：用本地缓存做服务会遇到哪些坑？

│ │ │ ├─17｜业务脚本：为什么说可编程订阅式缓存服务更有用？

│ │ │ ├─215高并发系统实战课

│ │ │ ├─开篇词｜高并发系统，技术实力的试金石

│ │ │ └─开篇词｜高并发系统，技术实力的试金石

│ │ ├─216Vue3企业级项目实战课【更新中】

│ │ │ ├─01｜编译和非编译模式：离开Vue工具，你还知道怎么用Vue3吗？

│ │ │ ├─02｜Webpack编译搭建：如何用Webpack初构建Vue3项目？

│ │ │ ├─03｜从Rollup到Vite：如何用Vite构建你的Vue3项目？

│ │ │ ├─04｜模版语法和JSX语法：你知道Vue可以用JSX写吗？

│ │ │ ├─05｜响应式开发操作：如何理解和使用Vue3的响应式数据？

│ │ │ ├─216Vue3企业级项目实战课【更新中】

│ │ │ ├─开篇词｜为何掌握了技术API，依然在项目中处处掣肘？

│ │ │ └─开篇词｜为何掌握了技术API，依然在项目中处处掣肘？

│ │ └─217-手把手教你落地DDD【更新中】

│ │ ├─01｜DDD小传：领域驱动设计为什么这么火？

│ │ ├─02｜迭代一概述：怎样开启一个麻雀虽小五脏俱全的项目？

│ │ ├─217-手把手教你落地DDD【更新中】

│ │ ├─开篇词｜带你吃透DDD

│ │ └─开篇词｜带你吃透DDD

│ └─2、视频

│ ├─1-微服务架构核心20讲

│ │ ├─01-什么是微服务架构？

│ │ ├─02-架构师如何权衡微服务的利弊？

│ │ ├─03-康威法则和微服务给架构师怎样的启示？

│ │ ├─04-企业应该在什么时候开始考虑引入微服务？

│ │ ├─05-什么样的组织架构更适合微服务？

│ │ ├─06-如何理解阿里巴巴提出的微服务中台战略？

│ │ ├─07-如何给出一个清晰简洁的服务分层方式？

│ │ ├─08-微服务总体技术架构体系是怎样设计的？

│ │ ├─09-微服务最经典的三种服务发现机制

│ │ ├─10-微服务API服务网关（一）原理

│ │ ├─11-微服务API服务网关（二）开源网关Zuul

│ │ ├─12-跟Netflix学习微服务路由发现体系

│ │ ├─13-集中式配置中心的作用和原理是什么？

│ │ ├─14-微服务通讯方式RPCvsREST

│ │ ├─15-微服务框架需要考虑哪些治理环节？

│ │ ├─16-微服务监控系统分层和监控架构

│ │ ├─17-微服务的调用链监控该如何选型？

│ │ ├─18-微服务的容错限流是如何工作的？

│ │ ├─19-Docker容器部署技术&持续交付流水线

│ │ └─20-容器集群调度和基于容器的发布体系&结课测试

│ ├─10-玩转Spring全家桶

│ │ ├─01-Spring课程介绍

│ │ ├─02-一起认识Spring家族的主要成员

│ │ ├─03-跟着Spring了解技术趋势

│ │ ├─04-编写你的第一个Spring程序

│ │ ├─05-如何配置单数据源

│ │ ├─06-如何配置多数据源

│ │ ├─07-那些好用的连接池们：HikariCP

│ │ ├─08-那些好用的连接池们：AlibabaDruid

│ │ ├─09-如何通过SpringJDBC访问数据库

│ │ ├─10-什么是Spring的事务抽象（上）

│ │ ├─100-使用Hystrix实现服务熔断（上）

│ │ ├─101-使用Hystrix实现服务熔断（下）

│ │ ├─102-如何观察服务熔断

│ │ ├─103-使用Resilience4j实现服务熔断

│ │ ├─104-使用Resilience4j实现服务限流（上）

│ │ ├─105-使用Resilience4j实现服务限流（下）

│ │ ├─106-SpringBucks实战项目进度小结

│ │ ├─107-基于Git的配置中心（上）

│ │ ├─108-基于Git的配置中心（下）

│ │ ├─109-基于Zookeeper的配置中心

│ │ ├─11-什么是Spring的事务抽象（下）

│ │ ├─110-深入理解SpringCloud的配置抽象

│ │ ├─111-基于Consul的配置中心

│ │ ├─112-基于Nacos的配置中心

│ │ ├─113-SpringBucks实战项目进度小结

│ │ ├─114-认识SpringCloudStream

│ │ ├─115-通过SpringCloudStream访问RabbitMQ

│ │ ├─116-通过SpringCloudStream访问Kafka

│ │ ├─117-SpringBucks实战项目进度小结

│ │ ├─118-通过Dapper理解链路治理

│ │ ├─119-使用SpringCloudSleuth实现链路追踪

│ │ ├─12-了解Spring的JDBC异常抽象

│ │ ├─120-如何追踪消息链路

│ │ ├─121-除了链路还要治理什么

│ │ ├─122-SpringBucks实战项目进度小结

│ │ ├─123-结课测试&结束语

│ │ ├─13-课程答疑（上）

│ │ ├─14-课程答疑（下）

│ │ ├─15-认识SpringDataJPA

│ │ ├─16-定义JPA的实体对象

│ │ ├─17-开始我们的线上咖啡馆实战项目：SpringBucks

│ │ ├─18-通过SpringDataJPA操作数据库

│ │ ├─19-SpringDataJPA的Repository是怎么从接口变成Bean的

│ │ ├─20-通过MyBatis操作数据库

│ │ ├─21-让MyBatis更好用的那些工具：MyBatisGenerator

│ │ ├─22-让MyBatis更好用的那些工具：MyBatisPageHelper

│ │ ├─23-SpringBucks实战项目进度小结

│ │ ├─24-通过Docker辅助开发

│ │ ├─25-在Spring中访问MongoDB

│ │ ├─26-在Spring中访问Redis

│ │ ├─27-Redis的哨兵与集群模式

│ │ ├─28-了解Spring的缓存抽象

│ │ ├─29-Redis在Spring中的其他用法

│ │ ├─30-SpringBucks实战项目进度小结

│ │ ├─31-ProjectReactor介绍（上）

│ │ ├─32-ProjectReactor介绍（下）

│ │ ├─33-通过Reactive的方式访问Redis

│ │ ├─34-通过Reactive的方式访问MongoDB

│ │ ├─35-通过Reactive的方式访问RDBMS

│ │ ├─36-通过AOP打印数据访问层的摘要（上）

│ │ ├─37-通过AOP打印数据访问层的摘要（下）

│ │ ├─38-SpringBucks实战项目进度小结

│ │ ├─39-编写第一个SpringMVCController

│ │ ├─40-理解Spring的应用上下文

│ │ ├─41-理解请求的处理机制

│ │ ├─42-如何定义处理方法（上）

│ │ ├─43-如何定义处理方法（下）

│ │ ├─44-SpringMVC中的视图解析机制（上）

│ │ ├─45-SpringMVC中的视图解析机制（下）

│ │ ├─46-SpringMVC中的常用视图（上）

│ │ ├─47-SpringMVC中的常用视图（下）

│ │ ├─48-静态资源与缓存

│ │ ├─49-SpringMVC中的异常处理机制

│ │ ├─50-了解SpringMVC的切入点

│ │ ├─51-SpringBucks实战项目进度小结

│ │ ├─52-课程答疑

│ │ ├─53-通过RestTemplate访问Web资源

│ │ ├─54-RestTemplate的高阶用法

│ │ ├─55-简单定制RestTemplate

│ │ ├─56-通过WebClient访问Web资源

│ │ ├─57-SpringBucks实战项目进度小结

│ │ ├─58-设计好的RESTfulWebService（上）

│ │ ├─59-设计好的RESTfulWebService（下）

│ │ ├─60-什么是HATEOAS

│ │ ├─61-使用SpringDataREST实现简单的超媒体服务（上）

│ │ ├─62-使用SpringDataREST实现简单的超媒体服务(下)

│ │ ├─63-分布式环境中如何解决Session的问题

│ │ ├─64-使用WebFlux代替SpringMVC（上）

│ │ ├─65-使用WebFlux代替SpringMVC（下）

│ │ ├─66-SpringBucks实战项目进度小结(1)

│ │ ├─66-SpringBucks实战项目进度小结

│ │ ├─67-认识SpringBoot的组成部分(1)

│ │ ├─67-认识SpringBoot的组成部分

│ │ ├─68-了解自动配置的实现原理(1)

│ │ ├─68-了解自动配置的实现原理

│ │ ├─69-动手实现自己的自动配置

│ │ ├─70-如何在低版本Spring中快速实现类似自动配置的功能

│ │ ├─71-了解起步依赖及其实现原理

│ │ ├─72-定制自己的起步依赖

│ │ ├─73-深挖SpringBoot的配置加载机制

│ │ ├─74-理解配置背后的PropertySource抽象

│ │ ├─75-认识SpringBoot的各类ActuatorEndpoint

│ │ ├─76-动手定制自己的HealthIndicator

│ │ ├─77-通过Micrometer获取运行数据

│ │ ├─78-通过SpringBootAdmin了解程序的运行状态

│ │ ├─79-如何定制Web容器的运行参数

│ │ ├─80-如何配置容器支持HTTP-2（上）

│ │ ├─81-如何配置容器支持HTTP-2（下）

│ │ ├─82-如何编写命令行运行的程序

│ │ ├─83-了解可执行Jar背后的秘密

│ │ ├─84-如何将SpringBoot应用打包成Docker镜像文件

│ │ ├─85-SpringBucks实战项目进度小结

│ │ ├─86-简单理解微服务

│ │ ├─87-如何理解云原生(CloudNative)

│ │ ├─88-12-FactorApp（上）

│ │ ├─89-12-FactorApp（下）

│ │ ├─90-认识SpringCloud的组成部分

│ │ ├─91-使用Eureka作为服务注册中心

│ │ ├─92-使用SpringCloudLoadbalancer访问服务

│ │ ├─93-使用Feign访问服务

│ │ ├─94-深入理解服务发现背后的DiscoveryClient

│ │ ├─95-使用Zookeeper作为服务注册中心

│ │ ├─96-使用Consul作为服务注册中心

│ │ ├─97-使用Nacos作为服务注册中心

│ │ ├─98-如何定制自己的DiscoveryClient

│ │ └─99-SpringBucks实战项目进度小结

│ ├─11-Go语言从入门到实战

│ │ ├─01-Go语言课程介绍

│ │ ├─02-内容综述

│ │ ├─03-Go语言简介：历史背景、发展现状及语言特性

│ │ ├─04-编写第一个Go程序

│ │ ├─05-变量、常量以及与其他语言的差异

│ │ ├─06-数据类型

│ │ ├─07-运算符

│ │ ├─08-条件和循环

│ │ ├─09-数组和切片

│ │ ├─10-Map声明、元素访问及遍历

│ │ ├─11-Map与工厂模式，在Go语言中实现Set

│ │ ├─12-字符串

│ │ ├─13-Go语言的函数

│ │ ├─14-可变参数和defer

│ │ ├─15-行为的定义和实现

│ │ ├─16-Go语言的相关接口

│ │ ├─17-扩展与复用

│ │ ├─18-不一样的接口类型，一样的多态

│ │ ├─19-编写好的错误处理

│ │ ├─20-panic和recover

│ │ ├─21-构建可复用的模块（包）

│ │ ├─22-依赖管理

│ │ ├─23-协程机制

│ │ ├─24-共享内存并发机制

│ │ ├─25-CSP并发机制

│ │ ├─26-多路选择和超时

│ │ ├─27-channel的关闭和广播

│ │ ├─28-任务的取消

│ │ ├─29-Context与任务取消

│ │ ├─30-只运行一次

│ │ ├─31-仅需任意任务完成

│ │ ├─32-所有任务完成

│ │ ├─33-对象池

│ │ ├─34-sync

│ │ ├─35-单元测试

│ │ ├─36-Benchmark

│ │ ├─37-BDD

│ │ ├─38-反射编程

│ │ ├─39-万能程序

│ │ ├─40-不安全编程

│ │ ├─41-实现pipe-filterframework

│ │ ├─42-实现micro-kernelframework

│ │ ├─43-内置JSON解析

│ │ ├─44-easyjson

│ │ ├─45-HTTP服务

│ │ ├─46-构建RESTful服务

│ │ ├─47-性能分析工具

│ │ ├─48-性能调优示例

│ │ ├─49-别让性能被锁住

│ │ ├─50-GC友好的代码

│ │ ├─51-高效字符串连接

│ │ ├─52-面向错误的设计

│ │ ├─53-面向恢复的设计

│ │ ├─54-ChaosEngineering

│ │ └─55-结课测试&结束语

│ ├─12-Vue开发实战

│ │ ├─01-课程介绍

│ │ ├─02-Vue简介

│ │ ├─03-内容综述

│ │ ├─04-第一个Vue程序

│ │ ├─05-组件基础及组件注册

│ │ ├─06-Vue组件的核心概念：事件

│ │ ├─07-Vue组件的核心概：插槽

│ │ ├─08-理解单文件组件

│ │ ├─09-双向绑定和单向数据流不冲突

│ │ ├─10-理解虚拟DOM及key属性的作用

│ │ ├─11-如何触发组件的更新

│ │ ├─12-合理应用计算属性和侦听器

│ │ ├─13-生命周期的应用场景和函数式组件

│ │ ├─14-指令的本质是什么

│ │ ├─15-常用高级特性provide-inject

│ │ ├─16-如何优雅地获取跨层级组件实例（拒绝递归）

│ │ ├─17-template和JSX的对比以及它们的本质

│ │ ├─18-为什么需要Vuex

│ │ ├─19-如何在Vue中使用Vuex

│ │ ├─20-Vuex核心概念及底层原理

│ │ ├─21-Vuex最佳实践

│ │ ├─22-VueRouter的使用场景

│ │ ├─23-选择何种模式的路由及底层原理

│ │ ├─24-Nuxt解决了哪些问题？

│ │ ├─25-Nuxt核心原理是什么？

│ │ ├─26-UI组件库对比：ElementUI、AntDesignVue、iView

│ │ ├─27-提升开发效率和体验的常用工具：ESLint、Prettier、vue-devtools

│ │ ├─28-单元测试的重要性及其使用

│ │ ├─29-生态篇习题解答（上）

│ │ ├─30-生态篇习题解答（下）

│ │ ├─31-AntDesignPro介绍

│ │ ├─32-使用VueCLI3快速创建项目

│ │ ├─33-如何自定义Webpack和Babel配置

│ │ ├─34-如何设计一个高扩展性的路由

│ │ ├─35-实现一个可动态改变的页面布局

│ │ ├─36-如何将菜单和路由结合

│ │ ├─37-如何使用路由管理用户权限

│ │ ├─38-更加精细化的权限设计（权限组件、权限指令）

│ │ ├─39-如何在组件中使用ECharts、Antv等其他第三方库

│ │ ├─40-如何高效地使用Mock数据进行开发

│ │ ├─41-如何与服务端进行交互（Axios）

│ │ ├─42-创建一个普通表单

│ │ ├─43-初始数据、自动校验、动态赋值

│ │ ├─44-创建一个分步表单

│ │ ├─45-自己封装一个支持自动校验的表单项

│ │ ├─46-如何管理系统中使用的图标

│ │ ├─47-如何定制主题及动态切换主题

│ │ ├─48-如何做好国际化

│ │ ├─49-如何高效地构建打包发布

│ │ ├─50-如何构建可交互的组件文档

│ │ ├─51-如何做好组件的单元测试

│ │ ├─52-如何发布组件到npm

│ │ └─53-结课测试&GitHub相关生态应用（持续集成、单测覆盖率、文档发布、issue管理）

│ ├─13-从0开发一款iOSApp

│ │ ├─03-常见App类型及技术栈浅析

│ │ ├─04-使用Xcode创建第一个工程

│ │ ├─05-MVC模式：iOS中的架构基石

│ │ ├─06-iOS中的视图UIView

│ │ ├─07-了解UIView的生命周期

│ │ ├─08-视图的控制器UIViewController

│ │ ├─09-结合视图和控制器构建Tabbar样式页面

│ │ ├─10-使用Navigation构建App的基础交互

│ │ ├─100-使用UITextView实现输入框

│ │ ├─101-复杂列表页实现方案及IGListKit浅析

│ │ ├─102-复杂内容页展示逻辑及实现方案浅析

│ │ ├─103-App的签名原理和证书申请

│ │ ├─104-常用iOS唯一标识符

│ │ ├─105-App的打包和上架流程

│ │ ├─106-结课测试&结束语

│ │ ├─11-iOS基本页面框架的构成和实现

│ │ ├─12-系统函数中常见模式Delegate

│ │ ├─13-UITableView简介

│ │ ├─14-UITableView中Delegate和Datasource的使用

│ │ ├─15-UITableViewCell的复用及原理

│ │ ├─16-结合子视图实现完整的列表界面

│ │ ├─17-UICollectionView的基本应用和实现

│ │ ├─18-UICollectionViewLayout的应用

│ │ ├─19-基本列表视图的选择和使用

│ │ ├─20-滚动视图的基类UIScrollView简介

│ │ ├─21-应用UIScrollViewDelegate实现复杂逻辑

│ │ ├─22-iOS中滚动视图对比及App内应用场景浅析

│ │ ├─23-iOS中文字的展示：UILabel的使用与布局

│ │ ├─24-iOS中图片的展示：UIImage与UIImageView的应用

│ │ ├─25-iOS中按钮的实现：UIButton的使用

│ │ ├─26-UIControl以及Target-Action模式

│ │ ├─27-使用UIGestureRecognizer实现自定义点击与手势

│ │ ├─28-通过UIAlertView了解UIKit系统函数的设计和使用

│ │ ├─29-Web基础知识及WKWebView介绍

│ │ ├─30-使用WKWebView及Delgate实现简单的页面加载

│ │ ├─31-认识观察者模式KVO并展示页面加载进度

│ │ ├─32-iOS开发中的Web应用浅析

│ │ ├─33-使用UIView动画完善界面的交互

│ │ ├─34-动画背后的CALayer基本应用

│ │ ├─35-CoreAnimation及开源动画框架介绍

│ │ ├─36-常用代码规范和重构方式

│ │ ├─37-结合UIKit分析常用App的页面结构

│ │ ├─38-网络基础及请求的封装

│ │ ├─39-NSURLSession基础原理、组织和使用

│ │ ├─40-使用系统网络架构NSURLSession加载网络数据

│ │ ├─41-常用框架集成方式Submodule、Carthage和CocoaPods对比和使用

│ │ ├─42-集成和使用开源网络框架

│ │ ├─43-iOS中的JSON解析

│ │ ├─44-使用结构化的数据进行解析和展示

│ │ ├─45-实现列表数据加载、解析和展示的完整流程

│ │ ├─46-iOS沙盒机制和文件结构

│ │ ├─47-使用NSFileManager操作和管理文件

│ │ ├─48-iOS中的序列化NSCoding

│ │ ├─49-开源存储方案对比与分析

│ │ ├─50-缓存新闻列表数据及已读状态

│ │ ├─51-iOS中线程的基础知识及NSThread

│ │ ├─52-GCD的常用方法分析和使用

│ │ ├─53-了解Operation、Runloop以及多线程开发总结

│ │ ├─54-如何管理App中的图片下载与存储

│ │ ├─55-开源图片框架接触的架构和使用

│ │ ├─56-了解iOS系统的音视频框架

│ │ ├─57-重构视频列表展示视频

│ │ ├─58-实现简单视频播放器AVPlayer

│ │ ├─59-iOS消息机制NSNotification简介

│ │ ├─60-使用Notification接收和处理播放状态通知

│ │ ├─61-使用KVO监听和处理播放资源的状态变化

│ │ ├─62-CMTime及播放缓冲进度的获取和使用

│ │ ├─63-使用单例模式重构播放器业务逻辑

│ │ ├─64-常用App视频业务及流程浅析

│ │ ├─65-AutoLayout简介

│ │ ├─66-使用AutoLayout实现通用ToolBar视图

│ │ ├─67-iOS常用布局方式选择

│ │ ├─68-逻辑分辨率适配

│ │ ├─69-物理分辨率适配

│ │ ├─70-使用ImageAsset管理图片资源

│ │ ├─71-iPhoneX适配

│ │ ├─72-iOS开发适配常用方法总结

│ │ ├─73-App启动过程及生命周期分析

│ │ ├─74-通过App生命周期回调实现启动页

│ │ ├─75-使用URLScheme进行App间的唤起和通信

│ │ ├─76-UniversalLink简介

│ │ ├─77-常用组件化Target-Action方案

│ │ ├─78-常用组件化URLScheme方案

│ │ ├─79-常用组件化Protocol-Class方案

│ │ ├─80-实现简单的第三方登录和分享功能

│ │ ├─81-iOS中静态库的制作和使用

│ │ ├─82-iOS当中Framework的制作和使用

│ │ ├─83-OAuth和OpenID原理和使用

│ │ ├─84-集成QQSDK实现登录和分享功能

│ │ ├─85-iOS中常用日志和上报系统浅析

│ │ ├─86-类CocoaLumberjack日志框架架构浅析

│ │ ├─87-Crash的类型介绍和常用收集方案

│ │ ├─88-常用上报技术方案对比和分析

│ │ ├─89-iOS中定位和定位权限

│ │ ├─90-定位功能实现和位置信息的获取

│ │ ├─91-iOS中推送和推送权限

│ │ ├─92-使用UserNotifications实现本地推送

│ │ ├─93-远程推送与APNs简介

│ │ ├─94-使用UserNotifications接收远程推送

│ │ ├─95-iOS图标管理和动态更新

│ │ ├─96-iOSAppExtension简介

│ │ ├─97-实现TodayExtension以及数据共享

│ │ ├─98-UITextField和UITextView

│ │ └─99-使用UITextField实现搜索条

│ ├─14-Web协议详解与抓包实战

│ │ ├─03-浏览器发起HTTP请求的典型场景

│ │ ├─04-基于ABNF语义定义的HTTP消息格式

│ │ ├─05-网络为什么要分层：OSI模型与TCP-IP模型

│ │ ├─06-HTTP解决了什么问题？

│ │ ├─07-评估Web架构的七大关键属性

│ │ ├─08-从五种架构风格推导出HTTP的REST架构

│ │ ├─09-如何用Chrome的Network面板分析HTTP报文

│ │ ├─10-URI的基本格式以及与URL的区别

│ │ ├─100-拥塞控制（3）：快速重传与快速恢复

│ │ ├─101-SACK与选择性重传算法

│ │ ├─102-从丢包到测量驱动的拥塞控制算法

│ │ ├─103-GoogleBBR拥塞控制算法原理

│ │ ├─104-关闭连接过程优化

│ │ ├─105-优化关闭连接时的TIME-WAIT状态

│ │ ├─106-keepalive、校验和及带外数据

│ │ ├─107-面向字节流的TCP连接如何多路复用

│ │ ├─108-四层负载均衡可以做什么

│ │ ├─109-网络层与链路层的功能

│ │ ├─11-为什么要对URI进行编码？

│ │ ├─110-IPv4分类地址

│ │ ├─111-CIDR无分类地址

│ │ ├─112-IP地址与链路地址的转换：ARP与RARP协议

│ │ ├─113-NAT地址转换与LVS负载均衡

│ │ ├─114-IP选路协议

│ │ ├─115-MTU与IP报文分片

│ │ ├─116-IP协议的助手：ICMP协议

│ │ ├─117-多播与IGMP协议

│ │ ├─118-支持万物互联的IPv6地址

│ │ ├─119-IPv6报文及分片

│ │ ├─12-详解HTTP的请求行

│ │ ├─120-从wireshark报文统计中找规律

│ │ ├─121-结课测试&结束语

│ │ ├─13-HTTP的正确响应码

│ │ ├─14-HTTP的错误响应码

│ │ ├─15-如何管理跨代理服务器的长短连接？

│ │ ├─16-HTTP消息在服务器端的路由

│ │ ├─17-代理服务器转发消息时的相关头部

│ │ ├─18-请求与响应的上下文

│ │ ├─19-内容协商与资源表述

│ │ ├─20-HTTP包体的传输方式（1）：定长包体

│ │ ├─21-HTTP包体的传输方式（2）：不定长包体

│ │ ├─22-HTMLform表单提交时的协议格式

│ │ ├─23-断点续传与多线程下载是如何做到的？

│ │ ├─24-Cookie的格式与约束

│ │ ├─25-Session及第三方Cookie的工作原理

│ │ ├─26-浏览器为什么要有同源策略？

│ │ ├─27-如何“合法”地跨域访问？

│ │ ├─28-条件请求的作用

│ │ ├─29-缓存的工作原理

│ │ ├─30-缓存新鲜度的四种计算方式

│ │ ├─31-复杂的Cache-Control头部

│ │ ├─32-什么样的响应才会被缓存

│ │ ├─33-多种重定向跳转方式的差异

│ │ ├─34-如何通过HTTP隧道访问被限制的网络

│ │ ├─35-网络爬虫的工作原理与应对方式

│ │ ├─36-HTTP协议的基本认证

│ │ ├─37-Wireshark的基本用法

│ │ ├─38-如何通过DNS协议解析域名？

│ │ ├─39-Wireshark的捕获过滤器

│ │ ├─40-Wireshark的显示过滤器

│ │ ├─41-Websocket解决什么问题

│ │ ├─42-Websocket的约束

│ │ ├─43-WebSocket协议格式

│ │ ├─44-如何从HTTP升级到WebSocket

│ │ ├─45-传递消息时的编码格式

│ │ ├─46-掩码及其所针对的代理污染攻击

│ │ ├─47-如何保持会话心跳

│ │ ├─48-如何关闭会话

│ │ ├─49-HTTP-1

│ │ ├─50-HTTP-2特性概述

│ │ ├─51-如何使用Wireshark解密TLS-SSL报文？

│ │ ├─52-h2c：在TCP上从HTTP-1升级到HTTP-2

│ │ ├─53-h2：在TLS上从HTTP-1升级到HTTP-2

│ │ ├─54-帧、消息、流的关系

│ │ ├─55-帧格式：Stream流ID的作用

│ │ ├─56-帧格式：帧类型及设置帧的子类型

│ │ ├─57-HPACK如何减少HTTP头部的大小？

│ │ ├─58-HPACK中如何使用Huffman树编码？

│ │ ├─59-HPACK中整型数字的编码

│ │ ├─60-HPACK中头部名称与值的编码格式

│ │ ├─61-服务器端的主动消息推送

│ │ ├─62-Stream的状态变迁

│ │ ├─63-RSTSTREAM帧及常见错误码

│ │ ├─64-我们需要Stream优先级

│ │ ├─65-不同于TCP的流量控制

│ │ ├─66-HTTP-2与gRPC框架

│ │ ├─67-HTTP-2的问题及HTTP-3的意义

│ │ ├─68-HTTP-3-QUIC协议格式

│ │ ├─69-七层负载均衡做了些什么？

│ │ ├─70-TLS协议的工作原理

│ │ ├─71-对称加密的工作原理（1）：XOR与填充

│ │ ├─72-对称加密的工作原理（2）：工作模式

│ │ ├─73-详解AES对称加密算法

│ │ ├─74-非对称密码与RSA算法

│ │ ├─75-基于openssl实战验证RSA

│ │ ├─76-非对称密码应用：PKI证书体系

│ │ ├─77-非对称密码应用：DH密钥交换协议

│ │ ├─78-ECC椭圆曲线的特性

│ │ ├─79-DH协议升级：基于椭圆曲线的ECDH协议

│ │ ├─80-TLS1

│ │ ├─81-握手的优化：session缓存、ticket票据及TLS1

│ │ ├─82-TLS与量子通讯的原理

│ │ ├─83-量子通讯BB84协议的执行流程

│ │ ├─84-TCP历史及其设计哲学

│ │ ├─85-TCP解决了哪些问题

│ │ ├─86-TCP报文格式

│ │ ├─87-如何使用tcpdump分析网络报文

│ │ ├─88-三次握手建立连接

│ │ ├─89-三次握手过程中的状态变迁

│ │ ├─90-三次握手中的性能优化与安全问题

│ │ ├─91-数据传输与MSS分段

│ │ ├─92-重传与确认

│ │ ├─93-RTO重传定时器的计算

│ │ ├─94-滑动窗口：发送窗口与接收窗口

│ │ ├─95-窗口的滑动与流量控制

│ │ ├─96-操作系统缓冲区与滑动窗口的关系

│ │ ├─97-如何减少小报文提高网络效率

│ │ ├─98-拥塞控制（1）：慢启动

│ │ └─99-拥塞控制（2）：拥塞避免

│ ├─15-零基础学Java

│ │ ├─03-开发环境搭建（macOS）

│ │ ├─04-HelloWorld程序编译和运行（macOS）

│ │ ├─05-开发环境搭建（Windows）

│ │ ├─06-HelloWorld程序编译和运行（Windows）

│ │ ├─07-详解HelloWorld程序

│ │ ├─08-IntelliJIDEA集成开发环境的安装和使用（macOS）

│ │ ├─09-IntelliJIDEA集成开发环境的安装和使用（Windows）

│ │ ├─10-从加减乘除到变量

│ │ ├─100-局部内部类

│ │ ├─101-匿名类

│ │ ├─102-特殊类的总结

│ │ ├─103-让我们的超市运转起来：设计篇

│ │ ├─104-让我们的超市运转起来：代码篇

│ │ ├─105-初识异常：trycatch

│ │ ├─106-Java中异常的分类

│ │ ├─107-抛出异常的语法

│ │ ├─108-Java异常的传递

│ │ ├─109-自定义异常

│ │ ├─11-再探计算加减乘除的程序

│ │ ├─110-异常传递不是凌波微步

│ │ ├─111-trycatchfinally语句

│ │ ├─112-自动回收资源的try语句

│ │ ├─113-Java中的常见异常

│ │ ├─114-Collection类族简介

│ │ ├─115-Collection中的List（上）

│ │ ├─116-Collection中的List（下）

│ │ ├─117-Collection中的Set

│ │ ├─118-泛型简析（上）

│ │ ├─119-泛型简析（下）

│ │ ├─12-Java中的基本数据类型

│ │ ├─120-再探泛型

│ │ ├─121-Iterator接口

│ │ ├─122-Map：key和value的映射

│ │ ├─123-定义自己的注解

│ │ ├─124-LambdaV

│ │ ├─125-LambdaV

│ │ ├─126-基本类型的自动装箱和拆箱

│ │ ├─127-Java中的File类

│ │ ├─128-JavaI-O简介

│ │ ├─129-写文件内容小程序

│ │ ├─13-Java中的运算符

│ │ ├─130-读文件内容小程序

│ │ ├─131-网络通讯名词简介

│ │ ├─132-简单的网络通讯小程序（上）

│ │ ├─133-简单的网络通讯小程序（下）

│ │ ├─134-简单的抓取网页内容的程序

│ │ ├─135-JDK和JRE

│ │ ├─136-初识线程

│ │ ├─137-创建自己的线程

│ │ ├─138-再探线程

│ │ ├─139-多线程：混乱开始了

│ │ ├─14-Java中的位运算符

│ │ ├─140-同步控制之synchronized

│ │ ├─141-同步控制之waitnotify

│ │ ├─142-多线程经典模型：生产者消费者

│ │ ├─143-线程同步之join

│ │ ├─144-死锁

│ │ ├─145-ThreadLocal线程专属的变量

│ │ ├─146-定时任务

│ │ ├─147-volatile关键字的作用

│ │ ├─148-concurrent包基本原理

│ │ ├─149-concurrent包中的Atomic类族

│ │ ├─15-基本数据类型的更多语法点

│ │ ├─150-concurrent包中的锁

│ │ ├─151-concurrent包中的数据结构

│ │ ├─152-concurrent包中的线程池

│ │ ├─153-聊天室开张喽(上)

│ │ ├─154-聊天室开张喽(下)

│ │ ├─155-什么是学习一门语言

│ │ ├─156-Java平台简介

│ │ ├─157-Maven概念简介

│ │ ├─158-Maven的安装和配置

│ │ ├─159-创建一个简单的Maven项目(1)

│ │ ├─159-创建一个简单的Maven项目

│ │ ├─16-字符集编码和字符串

│ │ ├─160-一个从pptx文件中抽取文字的小工具

│ │ ├─161-Maven常用命令和插件

│ │ ├─162-Intellij更多功能介绍

│ │ ├─163-值得学习的类库简介

│ │ ├─164-如何在StackOverflow上提问才不会被骂

│ │ ├─165-浅谈程序设计

│ │ ├─166-游戏小程序功能定义

│ │ ├─167-游戏小程序设计和模块划分

│ │ ├─168-游戏小程序代码分析

│ │ ├─169-使用Swagger创建一个SpringBoot的Web服务

│ │ ├─17-操作符和数据类型总结

│ │ ├─170-结课测试&结束语

│ │ ├─18-程序执行流程之if-else语句（上）

│ │ ├─19-程序执行流程之if-else语句（下）

│ │ ├─20-程序循环之for语句

│ │ ├─21-代码块和变量的作用域

│ │ ├─22-程序循环之while语句

│ │ ├─23-程序执行流程之switch语句

│ │ ├─24-循环和判断的总结（上）

│ │ ├─25-循环和判断的总结（下）

│ │ ├─26-用数组保存成绩

│ │ ├─27-认识变量和数组（上）

│ │ ├─28-认识变量和数组（下）

│ │ ├─29-多维数组

│ │ ├─30-用数组灵活处理程序

│ │ ├─31-类（class）

│ │ ├─32-初探类和对象

│ │ ├─33-认识引用类型（上）

│ │ ├─34-认识引用类型（下）

│ │ ├─35-类、对象和引用的关系

│ │ ├─36-认识数组类型

│ │ ├─37-引用的缺省值null

│ │ ├─38-像自定义类型一样使用类

│ │ ├─39-Java中的包和访问修饰符（上）

│ │ ├─40-Java中的包和访问修饰符（下）

│ │ ├─41-打造一个小超市

│ │ ├─42-IntelliJ调试程序初探

│ │ ├─43-方法：让Merchandise对象有行为

│ │ ├─44-返回值：让Merchandise计算毛利润

│ │ ├─45-参数：让Merchandise计算多件商品的总价

│ │ ├─46-参数和返回值是怎么传递的

│ │ ├─47-分清参数、局部变量和实例的地盘

│ │ ├─48-隐藏的this自引用

│ │ ├─49-理解方法：一种特殊的代码块

│ │ ├─50-理解方法的调用：代码的一种特殊跳转

│ │ ├─51-给类和方法加Java注释

│ │ ├─52-成熟的类的对象要自己做事情

│ │ ├─53-方法的签名和重载

│ │ ├─54-重载的参数匹配规则

│ │ ├─55-构造方法：构造实例的方法

│ │ ├─56-构造方法的重载和互相调用

│ │ ├─57-静态变量

│ │ ├─58-静态方法

│ │ ├─59-静态方法的重载

│ │ ├─60-static代码块和static变量初始化

│ │ ├─61-方法和属性的可见性修饰符

│ │ ├─62-重新认识老朋友：Math和Scanner（上）

│ │ ├─63-重新认识老朋友：Math和Scanner（下）

│ │ ├─64-最熟悉的陌生人：String(上)

│ │ ├─65-最熟悉的陌生人：String(下)

│ │ ├─66-重新认识老朋友：main方法和System类

│ │ ├─67-String类的好兄弟

│ │ ├─68-继承：方便让商品增加新的类别

│ │ ├─69-子类对象里藏着一个父类对象

│ │ ├─70-覆盖：子类想要一点不一样

│ │ ├─71-super：和父类对象沟通的桥梁

│ │ ├─72-super：调用父类的构造方法

│ │ ├─73-父类和子类的引用赋值关系

│ │ ├─74-多态：到底调用的哪个方法？（上）

│ │ ├─75-多态：到底调用的哪个方法？（下）

│ │ ├─76-多态里更多的语法点（上）

│ │ ├─77-多态里更多的语法点（下）

│ │ ├─78-instanceof操作符

│ │ ├─79-继承专属的访问控制：protected

│ │ ├─80-final修饰符（上）

│ │ ├─81-final修饰符（下）

│ │ ├─82-继承里的静态方法

│ │ ├─83-插曲：for循环的另一种写法

│ │ ├─84-万类之祖：Object类

│ │ ├─85-hashCode和equals方法（上）

│ │ ├─86-hashCode和equals方法（下）

│ │ ├─87-toString方法

│ │ ├─88-初探Class类

│ │ ├─89-初探反射（上）

│ │ ├─90-初探反射（下）

│ │ ├─91-面向对象三要素：封装、继承和多态

│ │ ├─92-枚举：定义商品的门类

│ │ ├─93-接口：让商品类型更丰富（上）

│ │ ├─94-接口：让商品类型更丰富（下）

│ │ ├─95-抽象类：接口和类的混合体

│ │ ├─96-有方法代码的接口

│ │ ├─97-接口内代码的更多内容

│ │ ├─98-静态内部类

│ │ └─99-成员内部类

│ ├─16-玩转webpack

│ │ ├─03-为什么需要构建工具

│ │ ├─04-前端构建演变之路

│ │ ├─05-为什么选择webpack

│ │ ├─06-初识webpack

│ │ ├─07-环境搭建：安装webpack

│ │ ├─08-webpack初体验：一个最简单的例子

│ │ ├─09-通过npmscript运行webpack

│ │ ├─10-webpack核心概念之entry

│ │ ├─11-webpack核心概念之output

│ │ ├─12-webpack核心概念之loaders

│ │ ├─13-webpack核心概念之plugins

│ │ ├─14-webpack核心概念之mode

│ │ ├─15-解析ECMASCript6和ReactJSX

│ │ ├─16-解析CSS、Less和Sass

│ │ ├─17-解析图片和字体

│ │ ├─18-webpack中的文件监听

│ │ ├─19-webpack中的热更新及原理分析

│ │ ├─20-文件指纹策略：chunkhash、contenthash和hash

│ │ ├─21-HTML、CSS和JavaScript代码压缩

│ │ ├─22-自动清理构建目录产物

│ │ ├─23-PostCSS插件autoprefixer自动补齐CSS3前缀

│ │ ├─24-移动端CSSpx自动转换成rem

│ │ ├─25-静态资源内联

│ │ ├─26-多页面应用打包通用方案

│ │ ├─27-使用sourcemap

│ │ ├─28-提取页面公共资源

│ │ ├─29-TreeShaking的使用和原理分析

│ │ ├─30-ScopeHoisting使用和原理分析

│ │ ├─31-代码分割和动态import

│ │ ├─32-在webpack中使用ESLint

│ │ ├─33-webpack打包组件和基础库

│ │ ├─34-webpack实现SSR打包（上）

│ │ ├─35-webpack实现SSR打包（下）

│ │ ├─36-优化构建时命令行的显示日志

│ │ ├─37-构建异常和中断处理

│ │ ├─38-构建配置包设计

│ │ ├─39-功能模块设计和目录结构

│ │ ├─40-使用ESLint规范构建脚本

│ │ ├─41-冒烟测试介绍和实际运用

│ │ ├─42-单元测试和测试覆盖率

│ │ ├─43-持续集成和TravisCI

│ │ ├─44-发布构建包到npm社区

│ │ ├─45-GitCommit规范和changelog生成

│ │ ├─46-语义化版本（SemanticVersioning）规范格式

│ │ ├─47-初级分析：使用webpack内置的stats

│ │ ├─48-速度分析：使用speed-measure-webpack-plugin

│ │ ├─49-体积分析：使用webpack-bundle-analyzer

│ │ ├─50-使用高版本的webpack和Node

│ │ ├─51-多进程-多实例构建

│ │ ├─52-多进程并行压缩代码

│ │ ├─53-进一步分包：预编译资源模块

│ │ ├─54-充分利用缓存提升二次构建速度

│ │ ├─55-缩小构建目标

│ │ ├─56-使用TreeShaking擦除无用的JavaScript和CSS

│ │ ├─57-使用webpack进行图片压缩

│ │ ├─58-使用动态Polyfill服务

│ │ ├─59-webpack启动过程分析

│ │ ├─60-webpack-cli源码阅读

│ │ ├─61-Tapable插件架构与Hooks设计

│ │ ├─62-Tapable是如何和webpack进行关联起来的？

│ │ ├─63-webpack流程篇：准备阶段

│ │ ├─64-webpack流程篇：模块构建和chunk生成阶段

│ │ ├─65-webpack流程篇：文件生成

│ │ ├─66-动手编写一个简易的webpack(上)

│ │ ├─67-动手编写一个简易的webpack(下)

│ │ ├─68-loader的链式调用与执行顺序

│ │ ├─69-使用loader-runner高效进行loader的调试

│ │ ├─70-更复杂的loader的开发场

│ │ ├─71-实战开发一个自动合成雪碧图的loader

│ │ ├─72-插件基本结构介绍

│ │ ├─73-更复杂的插件开发场景

│ │ ├─74-实战开发一个压缩构建资源为zip包的插件

│ │ ├─75-商城技术栈选型和整体架构

│ │ ├─76-商城界面UI设计与模块拆分

│ │ ├─77-React全家桶环境搭建

│ │ ├─78-数据库实体和表结构设计

│ │ ├─79-登录注册模块开发

│ │ ├─80-商品模块开发

│ │ ├─81-订单模块开发

│ │ ├─82-谈谈Web商城的性能优化策略

│ │ ├─83-功能开发总结

│ │ ├─84-玩转webpack&结课测试

│ │ ├─加餐：bundle和bundless的差异

│ │ ├─加餐：Vite的构建原理

│ │ └─加餐：webpack5新特性解析

│ ├─17-Linux实战技能100讲

│ │ ├─03-什么是Linux

│ │ ├─04-Linux的内核版本及常见发行版

│ │ ├─05-安装VirtualBox虚拟机

│ │ ├─06-在虚拟机中安装Linux系统

│ │ ├─07-第一次启动Linux

│ │ ├─08-万能的帮助命令：man、help、info

│ │ ├─09-初识pwd和ls命令

│ │ ├─10-详解ls命令

│ │ ├─100-awk函数

│ │ ├─101-防火墙概述

│ │ ├─102-iptables规则的基本使用演示

│ │ ├─103-iptables过滤规则的使用

│ │ ├─104-iptablesnat表的使用

│ │ ├─105-firewalld

│ │ ├─106-SSH介绍之Telnet明文漏洞

│ │ ├─107-SSH服务演示

│ │ ├─108-FTP服务器vsftpd介绍与软件包安装

│ │ ├─109-vsftpd配置文件介绍

│ │ ├─11-详解cd命令

│ │ ├─110-vsftp虚拟用户

│ │ ├─111-samba服务演示

│ │ ├─112-NFS服务

│ │ ├─113-Nginx基本配置文件

│ │ ├─114-使用Nginx配置域名虚拟主机

│ │ ├─115-LNMP环境搭建

│ │ ├─116-DNS服务的原理

│ │ ├─117-NAS演示

│ │ ├─118-结课测试&结束语

│ │ ├─12-创建和删除目录

│ │ ├─13-复制和移动目录

│ │ ├─14-如何在Linux下进行文本查看

│ │ ├─15-打包压缩和解压缩

│ │ ├─16-Vim的四种模式

│ │ ├─17-Vim的正常模式

│ │ ├─18-Vim的命令模式

│ │ ├─19-Vim的可视模式

│ │ ├─20-用户和用户组管理及密码管理

│ │ ├─21-su和sudo命令的区别和使用方法

│ │ ├─22-用户和用户组的配置文件介绍

│ │ ├─23-文件与目录权限的表示方法

│ │ ├─24-文件权限的修改方法和数字表示方法

│ │ ├─25-权限管理以及文件的特殊权限

│ │ ├─26-网络管理

│ │ ├─27-查看网络配置

│ │ ├─28-修改网络配置

│ │ ├─29-网络故障排除命令

│ │ ├─30-网络管理和配置文件

│ │ ├─31-软件包管理器的使用(1)

│ │ ├─31-软件包管理器的使用

│ │ ├─32-使用rpm命令安装软件包

│ │ ├─33-使用yum包管理器安装软件包

│ │ ├─34-通过源代码编译安装软件包(1)

│ │ ├─34-通过源代码编译安装软件包

│ │ ├─35-如何进行内核升级

│ │ ├─36-grub配置文件介绍

│ │ ├─37-使用ps和top命令查看进程

│ │ ├─38-进程的控制与进程之间的关系

│ │ ├─39-进程的通信方式与信号：kill命令

│ │ ├─40-守护进程

│ │ ├─41-screen命令和系统日志

│ │ ├─42-服务管理工具systemctl

│ │ ├─43-SELinux简介

│ │ ├─44-内存与磁盘管理

│ │ ├─45-内存查看命令

│ │ ├─46-磁盘分区和文件大小查看

│ │ ├─47-文件系统管理

│ │ ├─48-i节点和数据块操作

│ │ ├─49-分区和挂载

│ │ ├─50-分区和挂载磁盘配额

│ │ ├─51-交换分区swap的查看与创建

│ │ ├─52-软件RAID的使用

│ │ ├─53-逻辑卷LVM的用途与创建

│ │ ├─54-系统综合状态查看命令sar以及第三方命令

│ │ ├─55-什么是Shell

│ │ ├─56-Linux的启动过程

│ │ ├─57-Shell脚本的格式

│ │ ├─58-脚本不同执行方式的影响

│ │ ├─59-管道

│ │ ├─60-重定向

│ │ ├─61-变量赋值

│ │ ├─62-变量引用及作用范围

│ │ ├─63-环境变量、预定义变量与位置变量

│ │ ├─64-环境变量配置文件

│ │ ├─65-数组

│ │ ├─66-转义和引用

│ │ ├─67-运算符

│ │ ├─68-特殊字符大全

│ │ ├─69-test比较

│ │ ├─70-if判断的使用

│ │ ├─71-if-else判断的使用

│ │ ├─72-嵌套if的使用

│ │ ├─73-case分支

│ │ ├─74-for的基本使用

│ │ ├─75-C语言风格的for

│ │ ├─76-while循环和until循环

│ │ ├─77-循环的嵌套和break、continue语句

│ │ ├─78-使用循环处理位置参数

│ │ ├─79-自定义函数

│ │ ├─80-系统函数库介绍

│ │ ├─81-脚本资源控制

│ │ ├─82-信号

│ │ ├─83-一次性计划任务

│ │ ├─84-周期性计划任务

│ │ ├─85-为脚本加锁

│ │ ├─86-元字符介绍

│ │ ├─87-find演示

│ │ ├─88-sed和awk介绍

│ │ ├─89-sed替换命令讲解

│ │ ├─90-sed的替换指令加强版

│ │ ├─91-sed的其他常用命令

│ │ ├─92-sed多行模式空间

│ │ ├─93-什么是sed的保持空间

│ │ ├─94-认识awk

│ │ ├─95-awk的字段

│ │ ├─96-awk表达式

│ │ ├─97-awk判断和循环

│ │ ├─98-awk数组

│ │ └─99-awk数组功能的使用

│ ├─18-Elasticsearch核心技术与实战

│ │ ├─02-内容综述及学习建议

│ │ ├─03-Elasticsearch简介及其发展历史

│ │ ├─04-ElasticStack家族成员及其应用场景

│ │ ├─05-Elasticsearch的安装与简单配置

│ │ ├─06-Kibana的安装与界面快速浏览

│ │ ├─07-在Docker容器中运行ElasticsearchKibana和Cerebro

│ │ ├─08-Logstash安装与导入数据

│ │ ├─09-基本概念：索引、文档和RESTAPI

│ │ ├─10-基本概念：节点、集群、分片及副本

│ │ ├─100-结课测试&结束语

│ │ ├─11-文档的基本CRUD与批量操作

│ │ ├─12-倒排索引介绍

│ │ ├─13-通过Analyzer进行分词

│ │ ├─14-SearchAPI概览

│ │ ├─15-URISearch详解

│ │ ├─16-RequestBody与QueryDSL简介

│ │ ├─17-QueryString&SimpleQueryString查询

│ │ ├─18-DynamicMapping和常见字段类型

│ │ ├─19-显式Mapping设置与常见参数介绍

│ │ ├─20-多字段特性及Mapping中配置自定义Analyzer

│ │ ├─21-IndexTemplate和DynamicTemplate

│ │ ├─22-Elasticsearch聚合分析简介

│ │ ├─23-第一部分总结

│ │ ├─24-基于词项和基于全文的搜索

│ │ ├─25-结构化搜索

│ │ ├─26-搜索的相关性算分

│ │ ├─27-Query&Filtering与多字符串多字段查询

│ │ ├─28-单字符串多字段查询：DisMaxQuery

│ │ ├─29-单字符串多字段查询：MultiMatch

│ │ ├─30-多语言及中文分词与检索

│ │ ├─31-SpaceJam，一次全文搜索的实例

│ │ ├─32-使用SearchTemplate和IndexAlias查询

│ │ ├─33-综合排序：FunctionScoreQuery优化算分

│ │ ├─34-Term&PhraseSuggester

│ │ ├─35-自动补全与基于上下文的提示

│ │ ├─36-配置跨集群搜索

│ │ ├─37-集群分布式模型及选主与脑裂问题

│ │ ├─38-分片与集群的故障转移

│ │ ├─39-文档分布式存储

│ │ ├─40-分片及其生命周期

│ │ ├─41-剖析分布式查询及相关性算分

│ │ ├─42-排序及DocValues&Fielddata

│ │ ├─43-分页与遍历：From,Size,SearchAfter&ScrollAPI

│ │ ├─44-处理并发读写操作

│ │ ├─45-Bucket&Metric聚合分析及嵌套聚合

│ │ ├─46-Pipeline聚合分析

│ │ ├─47-作用范围与排序

│ │ ├─48-聚合分析的原理及精准度问题

│ │ ├─49-对象及Nested对象

│ │ ├─50-文档的父子关系

│ │ ├─51-UpdateByQuery&ReindexAPI

│ │ ├─52-IngestPipeline&PainlessScript

│ │ ├─53-Elasticsearch数据建模实例

│ │ ├─54-Elasticsearch数据建模最佳实践

│ │ ├─55-第二部分总结回顾

│ │ ├─56-集群身份认证与用户鉴权

│ │ ├─57-集群内部安全通信

│ │ ├─58-集群与外部间的安全通信

│ │ ├─59-常见的集群部署方式

│ │ ├─60-Hot&Warm架构与ShardFiltering

│ │ ├─61-分片设计及管理

│ │ ├─62-如何对集群进行容量规划

│ │ ├─63-在私有云上管理Elasticsearch集群的一些方法

│ │ ├─64-在公有云上管理与部署Elasticsearch集群

│ │ ├─65-生产环境常用配置与上线清单

│ │ ├─66-监控Elasticsearch集群

│ │ ├─67-诊断集群的潜在问题

│ │ ├─68-解决集群Yellow与Red的问题

│ │ ├─69-提升集群写性能

│ │ ├─70-提升集群读性能

│ │ ├─71-集群压力测试

│ │ ├─72-段合并优化及注意事项

│ │ ├─73-缓存及使用Breaker限制内存使用

│ │ ├─74-一些运维的相关建议

│ │ ├─75-使用Shrink与RolloverAPI有效管理时间序列索引

│ │ ├─76-索引全生命周期管理及工具介绍

│ │ ├─77-Logstash入门及架构介绍

│ │ ├─78-利用JDBC插件导入数据到Elasticsearch

│ │ ├─79-Beats介绍

│ │ ├─80-使用IndexPattern配置数据

│ │ ├─81-使用KibanaDiscover探索数据

│ │ ├─82-基本可视化组件介绍

│ │ ├─83-构建Dashboard

│ │ ├─84-用Monitoring和Alerting监控Elasticsearch集群

│ │ ├─85-用APM进行程序性能监控

│ │ ├─86-用机器学习实现时序数据的异常检测（上）

│ │ ├─87-用机器学习实现时序数据的异常检测（下）

│ │ ├─88-用ELK进行日志管理

│ │ ├─89-用Canvas做数据演示

│ │ ├─90-项目需求分析及架构设计

│ │ ├─91-将电影数据导入Elasticsearch

│ │ ├─92-搭建你的电影搜索服务

│ │ ├─93-需求分析及架构设计

│ │ ├─94-数据Extract&Enrichment

│ │ ├─95-构建InsightsDashboard

│ │ ├─96-Elastic认证介绍

│ │ ├─97-考点梳理

│ │ ├─98-集群数据备份

│ │ └─99-基于Java和Elasticseach构建应用

│ ├─19-SpringBoot与Kubernetes云原生微服务实践

│ │ ├─02-背景说明

│ │ ├─03-课程目标和主要内容

│ │ ├─04-课程案例需求

│ │ ├─05-课程补充说明

│ │ ├─06-为何采用微服务架构？

│ │ ├─07-架构设计和技术栈选型

│ │ ├─08-数据和接口模型设计：账户服务

│ │ ├─09-数据和接口模型设计：业务服务

│ │ ├─10-Dubbo、SpringCloud和Kubernetes该如何选型（上）

│ │ ├─11-Dubbo、SpringCloud和Kubernetes该如何选型（中）

│ │ ├─12-Dubbo、SpringCloud和Kubernetes该如何选型（下）

│ │ ├─13-技术中台到底讲什么？

│ │ ├─14-Staffjoy项目结构组织

│ │ ├─15-谷歌为何采用单体仓库（Mono-Repo）？

│ │ ├─16-微服务接口参数校验为何重要？

│ │ ├─17-如何实现统一异常处理？

│ │ ├─18-DTO和DMO为什么要互转？

│ │ ├─19-如何实现基于Feign的强类型接口？

│ │ ├─20-为什么框架层就要考虑分环境配置？

│ │ ├─21-异步处理为何要复制线程上下文信息？

│ │ ├─22-为你的接口添加Swagger文档

│ │ ├─23-主流微服务框架概览

│ │ ├─24-网关和BFF是如何演化出来的（上）

│ │ ├─25-网关和BFF是如何演化出来的（下）

│ │ ├─26-网关和反向代理是什么关系？

│ │ ├─27-网关需要分集群部署吗？

│ │ ├─28-如何设计一个最简网关？

│ │ ├─29-Faraday网关代码解析（上）

│ │ ├─30-Faraday网关代码解析（下）

│ │ ├─31-生产级网关需要考虑哪些环节？

│ │ ├─32-主流开源网关概览

│ │ ├─33-安全认证架构演进：单块阶段（上）

│ │ ├─34-安全认证架构演进：单块阶段（下）

│ │ ├─35-安全认证架构演进：微服务阶段

│ │ ├─36-基于JWT令牌的安全认证架构

│ │ ├─37-JWT的原理是什么？

│ │ ├─38-JWT有哪两种主要流程？

│ │ ├─39-Staffjoy安全认证架构和SSO

│ │ ├─40-用户认证代码剖析

│ │ ├─41-服务调用鉴权代码剖析

│ │ ├─42-如何设计用户角色鉴权？

│ │ ├─43-SpringBoot微服务测试该如何分类？

│ │ ├─44-什么是契约驱动测试？

│ │ ├─45-什么是测试金字塔？

│ │ ├─46-单元测试案例分析

│ │ ├─47-集成测试案例分析

│ │ ├─48-组件测试案例分析

│ │ ├─49-MockvsSpy

│ │ ├─50-何谓生产就绪(ProductionReady)？

│ │ ├─51-SpringBoot如何实现分环境配置

│ │ ├─52-ApollovsSpringCloudConfigvsK8sConfigMap

│ │ ├─53-CATvsZipkinvsSkywalking(上)

│ │ ├─54-CATvsZipkinvsSkywalking(下)

│ │ ├─55-结构化日志和业务审计日志

│ │ ├─56-集中异常监控和Sentry

│ │ ├─57-EFK&Prometheus&Skywalking+Kubernetes集成架构

│ │ ├─58-本地开发部署架构和软件需求

│ │ ├─59-手工服务部署和测试(上)

│ │ ├─60-手工服务部署和测试(中)

│ │ ├─61-手工服务部署和测试(下)

│ │ ├─62-SkyWalking调用链监控实验

│ │ ├─63-Docker和DockerCompose简介

│ │ ├─64-容器镜像构建Dockerfile解析

│ │ ├─65-DockerCompose服务部署文件剖析

│ │ ├─66-将Staffjoy部署到本地DockerCompose环境(上)

│ │ ├─67-将Staffjoy部署到本地DockerCompose环境(下)

│ │ ├─68-到底什么是云原生架构？

│ │ ├─69-Kubernetes背景和架构

│ │ ├─70-Kubernetes有哪些基本概念(上)

│ │ ├─71-Kubernetes有哪些基本概念(下)

│ │ ├─72-理解Kubernetes节点网络和Pod网络

│ │ ├─73-深入理解Service和ServiceDiscovery

│ │ ├─74-NodePortvsLoadBalancervsIngress

│ │ ├─75-本地测试Kubernetes部署文件剖析

│ │ ├─76-本地测试Kubernetes环境搭建

│ │ ├─77-将Staffjoy部署到本地Kubernetes环境(上)

│ │ ├─78-将Staffjoy部署到本地Kubernetes环境(下)

│ │ ├─79-生产环境Kubernetes部署文件剖析

│ │ ├─80-阿里云Kubernetes环境创建

│ │ ├─81-将Staffjoy部署到阿里云Kubernetes环境

│ │ ├─82-Kubernetes应用动态配置实验

│ │ ├─83-Kubernetes应用金丝雀发布实验

│ │ ├─84-阿里云资源释放

│ │ ├─85-课程复盘

│ │ ├─86-项目扩展和应用

│ │ ├─87-Account服务

│ │ ├─88-Company服务

│ │ ├─89-Mail、SMS和Bot服务

│ │ ├─90-Faraday服务

│ │ ├─91-WhoAmI服务

│ │ ├─92-WWW服务

│ │ ├─93-前端应用

│ │ └─94-结课测试&结束语

│ ├─2-微服务架构实战160讲

│ │ ├─01-第一模块课程介绍

│ │ ├─02-微服务安全要解决什么问题

│ │ ├─03-白话OAuth2

│ │ ├─04-OAuth2的正式定义

│ │ ├─05-OAuth2有哪些典型模式

│ │ ├─06-OAuth2模式该如何选型

│ │ ├─07-SpringSecurityOAuth2架构简介

│ │ ├─08-【实验】授权码模式授权服务器

│ │ ├─09-【实验】简化模式授权服务器

│ │ ├─10-【实验】密码模式授权服务器

│ │ ├─100-Hystrix生产最佳实践

│ │ ├─101-参考资源和后续课程预览

│ │ ├─102-第六模块课程介绍

│ │ ├─103-服务发现需求和模式（上）

│ │ ├─104-服务发现需求和模式（下）

│ │ ├─105-NetflixEureka和Ribbon背景介绍

│ │ ├─106-Eureka和Ribbon架构设计原理

│ │ ├─107-【实验】SpringCloudEureka和Ribbon基础实战

│ │ ├─108-【实验】SpringCloudEureka和Ribbon高级实验

│ │ ├─109-SpringCloudEureka和Ribbon主要配置项

│ │ ├─11-【实验】客户端模式授权服务器

│ │ ├─110-Eureka进阶：自保护模式

│ │ ├─111-Eureka进阶：健康检查和蓝绿部署

│ │ ├─112-【实验】SpringCloudZuul、Eureka和Ribbon集成实验（上）

│ │ ├─113-【实验】SpringCloudZuul、Eureka和Ribbon集成实验（下）

│ │ ├─114-常用服务发现组件比较

│ │ ├─115-ServiceMesh和Istio简介

│ │ ├─116-基于Eureka、Zuul和容器云的持续交付架构

│ │ ├─117-参考资源和后续课程预览

│ │ ├─118-第七模块课程介绍

│ │ ├─119-监控模式分类

│ │ ├─12-实验一扩展环节

│ │ ├─120-BusDevOps和测量驱动开发MDD

│ │ ├─121-Prometheus简介

│ │ ├─122-Prometheus架构设计

│ │ ├─123-Prometheus基本概念

│ │ ├─124-【实验】Prometheus起步查询实验（上）

│ │ ├─125-【实验】Prometheus起步查询实验（中）

│ │ ├─126-【实验】Prometheus起步查询实验（下）

│ │ ├─127-【实验】Prometheus+Grafana展示实验（上）

│ │ ├─128-【实验】Prometheus+Grafana展示实验（下）

│ │ ├─129-【实验】Prometheus+Alertmanager告警实验（上）

│ │ ├─13-【实验】Web应用接入授权服务器

│ │ ├─130-【实验】Prometheus+Alertmanager告警实验（下）

│ │ ├─131-【实验】Java应用埋点和监控实验

│ │ ├─132-【实验】NodeExporter系统监控实验

│ │ ├─133-【实验】SpringBootActuator监控实验

│ │ ├─134-Prometheus监控最佳实践

│ │ ├─135-主流开源时序数据库比较

│ │ ├─136-开源分布式监控平台ZMon简介

│ │ ├─137-微服务监控体系总结

│ │ ├─138-参考资源和后续课程预览

│ │ ├─139-课程概述和背景

│ │ ├─14-实验二扩展环节

│ │ ├─140-架构和设计

│ │ ├─141-开发环境搭建

│ │ ├─142-基础代码(codereview)

│ │ ├─143-数据访问模块(codereview)

│ │ ├─144-OAuth2服务模块(codereview)

│ │ ├─145-Web服务模块(codereview)

│ │ ├─146-启动流程(codereview)

│ │ ├─147-起步准备实验(lab02)

│ │ ├─148-OAuth2授权码模式实验(lab03)

│ │ ├─149-OAuth2简化模式实验(lab04)

│ │ ├─15-什么是JWT令牌

│ │ ├─150-OAuth2用户名密码模式实验(lab05)

│ │ ├─151-OAuth2客户端模式实验(lab06)

│ │ ├─152-OAuth2令牌校验实验(lab07)

│ │ ├─153-OAuth2令牌刷新实验(lab08)

│ │ ├─154-项目复盘和扩展环节

│ │ ├─155-参考资源和后续课程预览

│ │ ├─156-课程概述和背景

│ │ ├─157-需求和架构设计

│ │ ├─158-开发环境搭建(lab01)（上）

│ │ ├─159-开发环境搭建(lab01)（下）

│ │ ├─16-【实验】授权服务器支持JWT令牌

│ │ ├─160-项目业务代码(CodeReview)

│ │ ├─161-Apollo配置中心集成(lab02)

│ │ ├─162-Zuul-Eureka-Ribbon-Hystrix集成(CodeReview)

│ │ ├─163-GraviteeOAuth2集成(lab03)

│ │ ├─164-Zuul网关集中令牌校验(CodeReview)

│ │ ├─165-CAT调用链集成(lab04)（上）

│ │ ├─166-CAT调用链集成(lab04)（下）

│ │ ├─167-Demo展示(lab05)（上）

│ │ ├─168-Demo展示(lab05)（下）

│ │ ├─169-Prometheus监控集成(CodeReview)

│ │ ├─17-实验三扩展环节

│ │ ├─170-生产扩展环节

│ │ ├─171-课程复盘总结&结课测试

│ │ ├─18-【实验】Android无线应用接入授权服务器

│ │ ├─19-【实验】AngularJS单页应用实验和课后扩展

│ │ ├─20-【实验】GitHub社交登录实验和课后扩展

│ │ ├─21-【实验】OAuth2安全风险CSRF实验

│ │ ├─22-OpenIdConnect简介

│ │ ├─23-下一代微服务安全架构

│ │ ├─24-参考资源和后续课程预览

│ │ ├─25-Apollo作者的产品介绍

│ │ ├─26-第二模块课程介绍

│ │ ├─27-课程概述

│ │ ├─28-业务需求

│ │ ├─29-配置定义和场景

│ │ ├─30-开关驱动开发原理

│ │ ├─31-携程Apollo配置中心介绍

│ │ ├─32-Apollo核心概念

│ │ ├─33-Apollo快速起步(Lab01)

│ │ ├─34-Apollo快速起步扩展实验

│ │ ├─35-Apollo架构设计之服务器端

│ │ ├─36-Apollo架构设计之客户端

│ │ ├─37-Apollo架构设计之高可用和监控

│ │ ├─38-Apollo分布式部署指南

│ │ ├─39-ApolloJava客户端和多语言接入

│ │ ├─40-ApolloClientAPI实操(Lab02)

│ │ ├─41-ApolloClient和Spring集成~XML方式(Lab03)

│ │ ├─42-ApolloClient和Spring集成~代码方式(Lab04)

│ │ ├─43-ApolloClient和SpringBoot集成(Lab05)

│ │ ├─44-Apollo开放平台接入实操(Lab06)

│ │ ├─45-SpringCloudConfig简介

│ │ ├─46-ApollovsSpringCloudConfig

│ │ ├─47-ApolloFAQ和开发常见问题

│ │ ├─48-参考资源和后续课程预览

│ │ ├─49-第三模块课程介绍

│ │ ├─50-Zuul网关和基本应用场景

│ │ ├─51-Zuul网关高级应用场景

│ │ ├─52-Zuul网关架构剖析

│ │ ├─53-Zuul网关代码剖析(CodeReview)

│ │ ├─54-Zuul网关过滤器管理工具(CodeReview)

│ │ ├─55-前置过滤器实验(Lab01)

│ │ ├─56-路由过滤器实验(Lab02)

│ │ ├─57-后置过滤器实验(Lab03)

│ │ ├─58-Zuul网关对接Apollo(Lab04)

│ │ ├─59-Zuul网关生产部署实践

│ │ ├─60-Zuul网关路由管理实践

│ │ ├─61-基于网关的两层路由体系

│ │ ├─62-SpringCloudZuul(Lab05)

│ │ ├─63-Zuul2

│ │ ├─64-Zuul网关生产最佳实践

│ │ ├─65-参考资源和后续课程预览

│ │ ├─66-第四模块课程介绍

│ │ ├─67-调用链监控业务需求

│ │ ├─68-调用链监控原理

│ │ ├─69-调用链监控产品和比较

│ │ ├─70-点评CAT背景介绍

│ │ ├─71-CAT典型报表

│ │ ├─72-CAT告警简介

│ │ ├─73-CAT架构设计

│ │ ├─74-【实验】CAT本地部署

│ │ ├─75-CAT埋点案例和代码剖析（CodeReview）

│ │ ├─76-【实验】CAT埋点案例

│ │ ├─77-Zuul网关集成CAT代码剖析（CodeReview）

│ │ ├─78-【实验】Zuul网关集成CAT

│ │ ├─79-CAT生产埋点实践

│ │ ├─80-CAT生产部署实践

│ │ ├─81-CAT生产治理实践

│ │ ├─82-SpringCloudSleuth简介

│ │ ├─83-【实验】SpringCloudSleuth

│ │ ├─84-参考资源和后续课程预览

│ │ ├─85-第五模块课程介绍

│ │ ├─86-容错限流需求

│ │ ├─87-容错限流原理

│ │ ├─88-NetflixHystrix背景介绍

│ │ ├─89-Hystrix设计原理

│ │ ├─90-Hystrix主要概念

│ │ ├─91-信号量vs线程池隔离

│ │ ├─92-Hystrix主要配置项

│ │ ├─93-【实验】Hystrix基础实验

│ │ ├─94-Hystrix模拟案例分析(CodeReview)

│ │ ├─95-【实验】Hystrix+Dashboard实验（上）

│ │ ├─96-【实验】Hystrix+Dashboard实验（下）

│ │ ├─97-网关集成Hystrix(CodeReview)

│ │ ├─98-【实验】SpringCloudHystrix实验

│ │ └─99-NetflixTurbine简介

│ ├─20-TypeScript开发实战

│ │ ├─01-重塑“类型思维”

│ │ ├─02-类型基础（1）：强类型与弱类型

│ │ ├─03-类型基础（2）：动态类型与静态类型

│ │ ├─04-编写你的第一个TypeScript程序

│ │ ├─05-基本类型

│ │ ├─06-枚举类型

│ │ ├─07-接口（1）：对象类型接口

│ │ ├─08-接口（2）：函数类型接口

│ │ ├─09-函数相关知识点梳理

│ │ ├─10-类（1）：继承和成员修饰符

│ │ ├─11-类（2）：抽象类与多态

│ │ ├─12-类与接口的关系

│ │ ├─13-泛型（1）：泛型函数与泛型接口

│ │ ├─14-泛型（2）：泛型类与泛型约束

│ │ ├─15-类型检查机制（1）：类型推断

│ │ ├─16-类型检查机制（2）：类型兼容性

│ │ ├─17-类型检查机制（3）：类型保护

│ │ ├─18-高级类型（1）：交叉类型与联合类型

│ │ ├─19-高级类型（2）：索引类型

│ │ ├─20-高级类型（3）：映射类型

│ │ ├─21-高级类型（4）：条件类型

│ │ ├─22-ES6与CommonJS的模块系统

│ │ ├─23-使用命名空间

│ │ ├─24-理解声明合并

│ │ ├─25-如何编写声明文件

│ │ ├─26-配置tsconfig

│ │ ├─27-配置tsconfig

│ │ ├─28-配置tsconfig

│ │ ├─29-编译工具：从ts-loader到Babel

│ │ ├─30-代码检查工具：从TSLint到ESLint

│ │ ├─31-使用Jest进行单元测试

│ │ ├─32-创建项目

│ │ ├─33-组件与类型（1）：函数组件与类组件

│ │ ├─34-组件与类型（2）：高阶组件与Hooks

│ │ ├─35-事件处理与数据请求

│ │ ├─36-列表渲染与路由

│ │ ├─37-Redux与类型

│ │ ├─38-搭建服务端开发环境

│ │ ├─39-列表的CRUD

│ │ ├─40-导出Excel

│ │ ├─41-搭建Vue开发环境

│ │ ├─42-组件封装

│ │ ├─43-组件发布

│ │ ├─44-共存策略

│ │ ├─45-宽松策略

│ │ ├─46-严格策略

│ │ └─47-结课测试&结束语

│ ├─21-Swift核心技术与实战

│ │ ├─03-Swift版本历史和各版本特性快览

│ │ ├─04-Swift和Objective-C的主要区别

│ │ ├─05-swiftc：强大的命令行工具

│ │ ├─06-REPL：Swift交互式解释器

│ │ ├─07-Playground：Swift学习的乐园

│ │ ├─08-如何在Swift中定义常量和变量

│ │ ├─09-Swift中的数值类型

│ │ ├─10-如何使用Tuple组合多个值

│ │ ├─100-没有最方便，只有更方便：对Swift标准库的一些扩展

│ │ ├─101-如何在Swift中进行自动布局

│ │ ├─102-如何进行图片加载和缓存

│ │ ├─103-以一种优雅安全的方式使用资源文件

│ │ ├─104-如何在项目中将内容分享到社交平台

│ │ ├─105-Swift和Objective-C的运行时简介

│ │ ├─106-桥接问题

│ │ ├─107-如何在Swift和Objective-C中相互调用

│ │ ├─108-Swift和Objective-C混合编程踩坑指南

│ │ ├─109-如何搭建一个iOSSwift工程

│ │ ├─11-如何在Swift中使用Optional

│ │ ├─110-商城整体架构、UI设计和模块拆分

│ │ ├─111-编写mockAPI

│ │ ├─112-登录注册页模块开发

│ │ ├─113-商城列表页模块开发

│ │ ├─114-商城详情页模块开发

│ │ ├─115-商城个人中心页模块开发

│ │ ├─116-商城订单页模块开发

│ │ ├─117-结束语

│ │ ├─118｜加餐1：可选链

│ │ ├─119｜加餐2：SwiftKVC

│ │ ├─12-Optional实现原理探究

│ │ ├─120｜加餐3：Swift面试中的要点注意事项&结课测试

│ │ ├─13-如何在Swift中创建和初始化字符串

│ │ ├─14-Swift字符串的常见操作

│ │ ├─15-如何使用索引访问和修改字符串

│ │ ├─16-如何在Swift中获取子串和进行字符串比较

│ │ ├─17-赋值和算数运算符

│ │ ├─18-在Swift里如何处理算术结果溢出

│ │ ├─19-为了Optional：合并空值运算符

│ │ ├─20-Swift的新宠：区间运算符

│ │ ├─21-强大的位运算符

│ │ ├─22-位运算符应用举例（1）

│ │ ├─23-位运算符应用举例（2）

│ │ ├─24-运算符优先级和结合性

│ │ ├─25-如何为类和结构体自定义运算符实现

│ │ ├─26-如在Swift中定义自己的运算符

│ │ ├─27-如何在Swift里进行循环控制

│ │ ├─28-更加强大的switch

│ │ ├─29-如何在Swift里进行控制转移

│ │ ├─30-如何使用guard来改善你的条件判断

│ │ ├─31-Swift中的模式和模式匹配

│ │ ├─32-在Swift中创建数组的N种方式

│ │ ├─33-访问和操作数组：遍历和索引

│ │ ├─34-访问和操作数组：查找操作

│ │ ├─35-访问和操作数组：添加和删除

│ │ ├─36-访问和操作数组：ArraySlice

│ │ ├─37-访问和操作数组：重排操作

│ │ ├─38丨访问和操作数组：拼接操作

│ │ ├─39丨深入理解数组：底层实现探究

│ │ ├─40丨如何用数组来实现栈和队列

│ │ ├─41丨Set：定义和创建

│ │ ├─42丨Set：访问和修改

│ │ ├─43丨Set：执行Set计算和判断

│ │ ├─44-实现自己的集合算法

│ │ ├─45-深入理解集合：底层实现探究

│ │ ├─46-Dictionary：Swift中的字典类型

│ │ ├─47-字典的常见操作

│ │ ├─48-深入理解字典：底层实现探究

│ │ ├─49-Swift中如何定义和使用函数

│ │ ├─50-函数的形式参数和返回值

│ │ ├─51-函数类型和内嵌函数

│ │ ├─52-闭包和闭包表达式

│ │ ├─53-闭包捕获值

│ │ ├─54-逃逸闭包和自动闭包

│ │ ├─55-如何使用Swift中的高阶函数

│ │ ├─56-函数式编程（1）

│ │ ├─57-函数式编程（2）

│ │ ├─58-Swift面向对象概述

│ │ ├─59-枚举从此站起来了

│ │ ├─60-如何为类、结构体以及枚举添加属性

│ │ ├─61-如何为类、结构体以及枚举添加方法

│ │ ├─62-像访问数组和字典一样访问类和结构体：下标和下标重载

│ │ ├─63-如何进行类的初始化和反初始化

│ │ ├─64-如何在Swift中实现继承

│ │ ├─65-如何在Swift中实现多态和进行类型转换

│ │ ├─66-如何为现有的类、结构体、枚举或协议添加新功能

│ │ ├─67丨Swift中的协议

│ │ ├─68丨协议和扩展

│ │ ├─69丨面向协议编程初探（1）

│ │ ├─70丨面向协议编程初探（2）

│ │ ├─71丨泛型的发展历史与泛型的概述

│ │ ├─72丨如何在Swift中定义泛型函数

│ │ ├─73丨如何在Swift中定义泛型类型

│ │ ├─74丨Swift泛型中的类型约束

│ │ ├─75-为了协议：关联类型

│ │ ├─76-如何为泛型定义要求：where字句

│ │ ├─77-泛型下标

│ │ ├─78丨泛型编程思想浅谈

│ │ ├─79-如何在Swift中创建一个线程

│ │ ├─80-更高级的抽象：CocoaOperation

│ │ ├─81丨多线程编程新思路：GCD概览

│ │ ├─82-如何使用GCD：基本操作指南

│ │ ├─83-深度使用GCD：高级特性指南

│ │ ├─84-深入理解GCD：源码剖析

│ │ ├─85-如何保证线程安全和同步

│ │ ├─86-实践出真知：多线程典型应用场景分析

│ │ ├─87-拓宽思路：其他常见的多线程编程模式

│ │ ├─88-SwiftUI：Apple全新的UI框架

│ │ ├─89-SwiftUI设计工具使用指南

│ │ ├─90-如何使用SwiftUI构建可复用的组件

│ │ ├─91-如何用SwiftUI实现动画

│ │ ├─92-深入理解SwiftUI：实现原理探秘

│ │ ├─93-如何在Swift里进行错误处理

│ │ ├─94-Swift中代码访问权限控制

│ │ ├─95-不透明类型

│ │ ├─96-Swift中的自动引用计数

│ │ ├─97-Swift中的内存安全性

│ │ ├─98-如何在项目中进行网络请求

│ │ └─99-如何进行JSON的序列化和反序列化

│ ├─22-ZooKeeper实战与源码剖析

│ │ ├─03-什么是ZooKeeper？

│ │ ├─04-ZooKeeper提供什么服务？

│ │ ├─05-开始使用ZooKeeper

│ │ ├─06-使用ZooKeeper实现Master-Worker协同

│ │ ├─07-ZooKeeper架构解析

│ │ ├─08-ZooKeeperAPI简介

│ │ ├─09-ZooKeeperAPI：Watch示例

│ │ ├─10-使用ZooKeeper实现分布式队列

│ │ ├─11-使用ZooKeeper实现分布式锁

│ │ ├─12-使用ZooKeeper实现选举

│ │ ├─13-使用ApacheCurator简化ZooKeeper开发

│ │ ├─14-如何安装配置一个ZooKeeper生产环境？

│ │ ├─15-如何进行ZooKeeper的监控？

│ │ ├─16-通过ZooKeeperObserver实现跨区域部署

│ │ ├─17-通过动态配置实现不中断服务的集群成员变更

│ │ ├─18-ZooKeeper节点是如何存储数据的

│ │ ├─19-使用ZooKeeper实现服务发现（1）

│ │ ├─20-使用ZooKeeper实现服务发现（2）

│ │ ├─21-使用ZooKeeper实现服务发现（3）

│ │ ├─22-Kafka是如何使用ZooKeeper的

│ │ ├─23-什么是Paxos协议

│ │ ├─24-对比Chubby和ZooKeeper

│ │ ├─25-Raft协议解析

│ │ ├─26-什么是etcd？

│ │ ├─27-etcdAPI：KV部分

│ │ ├─28-etcdAPI：Watch和Lease部分

│ │ ├─29-使用etcd实现分布式队列

│ │ ├─30-使用etcd实现分布式锁

│ │ ├─31-如何搭建一个etcd生产环境？

│ │ ├─32-存储数据结构之B+tree

│ │ ├─33-存储数据结构之LSM

│ │ ├─34-本地存储技术总结

│ │ ├─35-ZooKeeper本地存储源码解析

│ │ ├─36-网络编程基础

│ │ ├─37-事件驱动的网络编程

│ │ ├─38-Java的事件驱动网络编程

│ │ ├─39-ZooKeeper的客户端网络通信源码解读

│ │ ├─40-ZooKeeper的服务器网络通信源码解读

│ │ ├─41-ZooKeeper的RequestProcessor源码解读

│ │ ├─42-Standalone的ZooKeeper是如何处理客户端请求的？

│ │ ├─43-Quorum模式下ZooKeeper节点的RequestProcessorPipeline

│ │ ├─44-ZooKeeper的LeaderElection

│ │ ├─45-ZooKeeper的Zab协议

│ │ ├─46-客户端和服务器端交互：Watch和Session

│ │ └─47-结课测试&结束语

│ ├─23-Node

│ │ ├─03-Node

│ │ ├─04-Node

│ │ ├─05-课程实战项目介绍

│ │ ├─06-什么是技术预研？

│ │ ├─07-Node

│ │ ├─08-第一个Node

│ │ ├─09-模块：CommonJS规范

│ │ ├─10-模块：使用模块规范改造石头剪刀布游戏

│ │ ├─11-模块：npm

│ │ ├─12-模块：Node

│ │ ├─13-异步：非阻塞I-O

│ │ ├─14-异步：异步编程之callback

│ │ ├─15-异步：事件循环

│ │ ├─16-异步：异步编程之Promise

│ │ ├─17-异步：异步编程之async-await

│ │ ├─18-HTTP：什么是HTTP服务器？

│ │ ├─19-HTTP：简单实现一个HTTP服务器

│ │ ├─20-HTTP：实现网页版石头剪刀布

│ │ ├─21-HTTP：用express优化石头剪刀布游戏

│ │ ├─22-HTTP：用koa优化石头剪刀布游戏

│ │ ├─23-RPC调用：什么是RPC调用？

│ │ ├─24-RPC调用：Node

│ │ ├─25-RPC调用：Node

│ │ ├─26-项目启动：整体需求分析

│ │ ├─27-项目启动：极客时间App下载页开发

│ │ ├─28-课程详情页：极客时间详情页需求解构

│ │ ├─29-课程详情页：将ES6模版字符串改造成模板引擎

│ │ ├─30-课程详情页：极客时间详情页需求实现

│ │ ├─31-课程播放页：极客时间播放页需求解构

│ │ ├─32-课程播放页：GraphQLAPI服务

│ │ ├─33-课程播放页：极客时间播放页需求实现

│ │ ├─34-课程列表页：极客时间列表页需求解构

│ │ ├─35-课程列表页：用Vue-React进行服务端渲染

│ │ ├─36-课程列表页：极客时间列表页需求实现

│ │ ├─37-性能工具：HTTP服务的性能测试

│ │ ├─38-性能工具：Node

│ │ ├─39-代码优化：JavaScript代码性能优化

│ │ ├─40-代码优化：内存管理优化

│ │ ├─41-代码优化：Node

│ │ ├─42-多进程优化：Node

│ │ ├─43-多进程优化：Node

│ │ ├─44-多进程优化：进程守护与管理

│ │ ├─45-架构优化：动静分离

│ │ ├─46-架构优化：反向代理与缓存服务

│ │ ├─47-概念：框架设计和工程化

│ │ ├─48-概念：设计模式

│ │ ├─49-概念：Serverless

│ │ ├─50-服务端框架搭建：koaless

│ │ ├─51-服务端框架搭建：屏蔽请求细节

│ │ ├─52-服务端框架搭建：完成服务端框架

│ │ ├─53-云函数式工程实现：服务端代码

│ │ ├─54-云函数式工程实现：工具端代码

│ │ ├─55-加餐：调试Node

│ │ ├─56-结课测试&结束语

│ │ └─57-彩蛋：这是一个严肃的课程

│ ├─24-Netty源码剖析与实战

│ │ ├─03-揭开Netty面纱

│ │ ├─04-为什么舍近求远：不直接用JDKNIO？

│ │ ├─05-为什么孤注一掷：独选Netty？

│ │ ├─06-Netty的前尘往事

│ │ ├─07-Netty的现状与趋势

│ │ ├─08-Netty怎么切换三种I-O模式？

│ │ ├─09-源码剖析：Netty对I-O模式的支持

│ │ ├─10-Netty如何支持三种Reactor？

│ │ ├─11-源码剖析：Netty对Reactor的支持

│ │ ├─12-TCP粘包-半包Netty全搞定

│ │ ├─13-源码剖析：Netty对处理粘包-半包的支持

│ │ ├─14-常用的“二次”编解码方式

│ │ ├─15-源码剖析：Netty对常用编解码的支持

│ │ ├─16-keepalive与idle监测

│ │ ├─17-源码剖析：Netty对keepalive与idle监测的支持

│ │ ├─18-Netty的那些“锁”事

│ │ ├─19-Netty如何玩转内存使用

│ │ ├─20-源码解析：Netty对堆外内存和内存池的支持

│ │ ├─21-Netty代码编译与总览

│ │ ├─22-源码剖析：启动服务

│ │ ├─23-源码剖析：构建连接

│ │ ├─24-源码剖析：接收数据

│ │ ├─25-源码剖析：业务处理

│ │ ├─26-源码剖析：发送数据

│ │ ├─27-源码剖析：断开连接

│ │ ├─28-源码剖析：关闭服务

│ │ ├─29-编写网络应用程序的基本步骤

│ │ ├─30-案例介绍和数据结构设计

│ │ ├─31-实现服务器端编解码

│ │ ├─32-实现一个服务器端

│ │ ├─33-实现客户端编解码

│ │ ├─34-完成一个客户端雏形

│ │ ├─35-引入-响应分发-完善客户端

│ │ ├─36-Netty编码中易错点解析

│ │ ├─37-调优参数：调整System参数夯实基础

│ │ ├─38-调优参数：权衡Netty核心参数

│ │ ├─39-调优参数：图解费脑的三个参数

│ │ ├─40-跟踪诊断：如何让应用易诊断？

│ │ ├─41-跟踪诊断：应用能可视，心里才有底

│ │ ├─42-跟踪诊断：让应用内存不“泄露”？

│ │ ├─43-优化使用：用好自带注解省点心

│ │ ├─44-优化使用：“整改”线程模型让-响应-健步如飞

│ │ ├─45-优化使用：增强写，延迟与吞吐量的抉择

│ │ ├─46-优化使用：如何让应用丝般“平滑”？

│ │ ├─47-优化使用：为不同平台开启native

│ │ ├─48-安全增强：设置“高低水位线”等保护好自己

│ │ ├─49-安全增强：启用空闲监测

│ │ ├─50-安全增强：简单有效的黑白名单

│ │ ├─51-安全增强：少不了的自定义授权

│ │ ├─52-安全增强：拿来即用的SSL-对话呈现表象

│ │ ├─53-安全增强：拿来即用的SSL-抓包暴露本质

│ │ ├─54-安全增强：拿来即用的SSL-轻松融入案例

│ │ ├─55-Cassandra如何使用Netty？

│ │ ├─56-Dubbo如何使用Netty？

│ │ ├─57-Hadoop如何使用Netty？

│ │ ├─58-赏析Netty之美

│ │ ├─59-如何给Netty贡献代码？

│ │ └─60-结课测试&结束语

│ ├─25-移动端自动化测试实战

│ │ ├─03-自动化测试的价值

│ │ ├─04-自动化测试常见误区

│ │ ├─05-自动化测试的技术体系

│ │ ├─06-UI分层测试体系

│ │ ├─07-AndroidApp的常见概念

│ │ ├─08-Android调试桥adb命令详解

│ │ ├─09-自动化测试常用命令

│ │ ├─10-Appium架构介绍

│ │ ├─11-AppiumDesktop安装

│ │ ├─12-AppiumServer安装

│ │ ├─13-AppiumDesktop用例录制

│ │ ├─14-用例结构解析

│ │ ├─15-使用隐式等待让用例更稳定

│ │ ├─16-控件定位方法

│ │ ├─17-常用自动化API

│ │ ├─18-长按-滑动等TouchAction应用

│ │ ├─19-测试用例的改造

│ │ ├─20-capability使用进阶

│ │ ├─21-Appium设备交互API

│ │ ├─22-使用显式等待处理复杂等待条件

│ │ ├─23-高级XPath定位

│ │ ├─24-AndroidToast识别

│ │ ├─25-使用断言验证预期结果(1)

│ │ ├─25-使用断言验证预期结果

│ │ ├─26-参数化与数据驱动

│ │ ├─27-Native原生App的自动化测试

│ │ ├─28-Hybrid混合App的自动化测试

│ │ ├─29-纯HTML5站自动化测试

│ │ ├─30-小程序自动化测试

│ │ ├─31-iOS测试工具体系

│ │ ├─32-AppStore与苹果证书体系

│ │ ├─33-iOS模拟器自动化测试

│ │ ├─34-iOS真机测试

│ │ ├─35-iOSWebView测试

│ │ ├─36-Safari测试

│ │ ├─37-PageObject设计模式

│ │ ├─38-PageObject六大设计原则

│ │ ├─39-PageObject第一个例子

│ │ ├─40-基于PageObject模式的移动自动化测试实战

│ │ ├─41-BasePage封装改进

│ │ ├─42-Appium错误排查与日志分析

│ │ ├─43-Appium原理与JSONWP协议分析

│ │ ├─44-Appium源代码分析

│ │ ├─45-Appium二次封装实战

│ │ ├─46-自动遍历测试方法与常见技术介绍

│ │ ├─47-MonkeyMaxim遍历测试工具

│ │ ├─48-AppCrawler跨平台自动遍历测试

│ │ ├─49-移动自动化测试平台价值

│ │ ├─50-技术架构与智能设备选型

│ │ ├─51-多设备管理平台STF

│ │ ├─52-SeleniumGrid方案剖析

│ │ ├─53-基于Jenkins的自动化调度详解

│ │ ├─54-多设备回归测试

│ │ ├─55-多设备多分辨率的兼容性测试方法

│ │ ├─56-测试用例调度

│ │ ├─57-手机等智能设备调度

│ │ ├─58-测试报告定制

│ │ └─59-结课测试&结束语

│ ├─26-MongoDB高手课

│ │ ├─03-认识文档数据库MongoDB

│ │ ├─04-MongoDB特色及优势

│ │ ├─05-实验：安装MongoDB

│ │ ├─06-MongoDB基本操作

│ │ ├─07-实验：HelloWorld程序开发

│ │ ├─08-聚合查询

│ │ ├─09-实验：聚合查询

│ │ ├─10-复制集机制及原理

│ │ ├─11-实验：搭建MongoDB复制集

│ │ ├─12-MongoDB全家桶

│ │ ├─13-模型设计基础

│ │ ├─14-JSON文档模型设计特点

│ │ ├─15-文档模型设计之一：基础设计

│ │ ├─16-文档模型设计之二：工况细化

│ │ ├─17-文档模型设计之三：模式套用

│ │ ├─18-设计模式集锦

│ │ ├─19-事务开发：写操作事务

│ │ ├─20-事务开发：读操作事务之一

│ │ ├─21-事务开发：读操作事务之二

│ │ ├─22-事务开发：多文档事务

│ │ ├─23-ChangeStream

│ │ ├─24-MongoDB开发最佳实践

│ │ ├─25-分片集群机制及原理

│ │ ├─26-分片集群设计

│ │ ├─27-实验：分片集群搭建及扩容

│ │ ├─28-MongoDB监控最佳实践

│ │ ├─29-MongoDB备份与恢复

│ │ ├─30-备份与恢复操作

│ │ ├─31-MongoDB安全架构

│ │ ├─32-MongoDB安全加固实践

│ │ ├─33-MongoDB索引机制（一）

│ │ ├─34-MongoDB索引机制（二）

│ │ ├─35-MongoDB读写性能机制

│ │ ├─36-性能诊断工具

│ │ ├─37-高级集群设计：两地三中心

│ │ ├─38-实验：搭建两地三中心集群

│ │ ├─39-高级集群设计：全球多写

│ │ ├─40-MongoDB上线及升级

│ │ ├─41-MongoDB应用场景及选型

│ │ ├─42-MongoDB典型案例（一）

│ │ ├─43-MongoDB典型案例（二）

│ │ ├─44-关系型数据库迁移

│ │ ├─45-数据库迁移方式及工具

│ │ ├─46-Oracle迁移实战

│ │ ├─47-MongoDB+Spark实时大数据

│ │ ├─48-MongoDB+Spark连接实战

│ │ ├─49-MongoDBSQL套接件

│ │ ├─50-MongoDB与微服务

│ │ ├─51-MongoDB与数据中台

│ │ ├─52-MongoDB数据中台案例

│ │ └─53-结果测试&结束语

│ ├─27-小马哥讲Spring核心编程思想

│ │ ├─02-内容综述

│ │ ├─03-课前准备：学习三件套（工具、代码与大脑）

│ │ ├─04-特性总览：核心特性、数据存储、Web技术、框架整合与测试

│ │ ├─05-Spring版本特性：Spring各个版本引入了哪些新特性？

│ │ ├─06-Spring模块化设计：Spring功能特性如何在不同模块中组织？

│ │ ├─07-Java语言特性运用：各种Java语法特性是怎样被Spring各种版本巧妙运用的？

│ │ ├─08-JDKAPI实践：Spring怎样取舍JavaI-O、集合、反射、动态代理等API的使用？

│ │ ├─09-JavaEEAPI整合：为什么Spring要与“笨重”的JavaEE共舞？

│ │ ├─10-Spring编程模型：Spring实现了哪些编程模型？

│ │ ├─100-SpringBean初始化后阶段：BeanPostProcessor

│ │ ├─101-SpringBean初始化完成阶段：SmartInitializingSingleton

│ │ ├─102-SpringBean销毁前阶段：DestructionAwareBeanPostProcessor用在怎样的场景

│ │ ├─103-SpringBean销毁阶段：@PreDestroy、DisposableBean以及自定义方法

│ │ ├─104-SpringBean垃圾收集（GC）：何时需要GCSpringBean？

│ │ ├─105-面试题精选

│ │ ├─106-Spring配置元信息：Spring存在哪些配置元信息？它们分别用在什么场景？

│ │ ├─107-SpringBean配置元信息：BeanDefinition

│ │ ├─108-SpringBean属性元信息：PropertyValues

│ │ ├─109-Spring容器配置元信息

│ │ ├─11-Spring核心价值：我们能从SpringFramework中学到哪些经验和教训呢？

│ │ ├─110-基于XML资源装载SpringBean配置元信息

│ │ ├─111-基于Properties资源装载SpringBean配置元信息：为什么Spring官方不推荐？

│ │ ├─112-基于Java注解装载SpringBean配置元信息

│ │ ├─113-SpringBean配置元信息底层实现之XML资源

│ │ ├─114-SpringBean配置元信息底层实现之Properties资源

│ │ ├─115-SpringBean配置元信息底层实现之Java注解

│ │ ├─116-基于XML资源装载SpringIoC容器配置元信息

│ │ ├─117-基于Java注解装载SpringIoC容器配置元信息

│ │ ├─118-基于ExtensibleXMLauthoring扩展SpringXML元素

│ │ ├─119-ExtensibleXMLauthoring扩展原理

│ │ ├─12-面试题精选

│ │ ├─120-基于Properties资源装载外部化配置

│ │ ├─121-基于YAML资源装载外部化配置

│ │ ├─122-面试题

│ │ ├─123-引入动机：为什么Spring不使用Java标准资源管理，而选择重新发明轮子？

│ │ ├─124-Java标准资源管理：JavaURL资源管理存在哪些潜规则？

│ │ ├─125-Spring资源接口：Resource接口有哪些语义？它是否“借鉴”了SUN的实现呢？

│ │ ├─126-Spring内建Resource实现：Spring框架提供了多少种内建的Resource实现呢？

│ │ ├─127-SpringResource接口扩展：Resource能否支持写入以及字符集编码？

│ │ ├─128-Spring资源加载器：为什么说Spring应用上下文也是一种Spring资源加载器？

│ │ ├─129-Spring通配路径资源加载器：如何理解路径通配Ant模式？

│ │ ├─13-IoC发展简介：你可能对IoC有些误会？

│ │ ├─130-Spring通配路径模式扩展：如何扩展路径匹配的规则？

│ │ ├─131-依赖注入SpringResource：如何在XML和Java注解场景注入Resource对象？

│ │ ├─132-依赖注入ResourceLoader：除了ResourceLoaderAware回调注入，还有哪些注入方法？

│ │ ├─133-面试题精选

│ │ ├─134-Spring国际化使用场景

│ │ ├─135-Spring国际化接口：MessageSource不是技术的创造者，只是技术的搬运工？

│ │ ├─136-层次性MessageSource：双亲委派不是ClassLoader的专利吗？

│ │ ├─137-Java国际化标准实现：ResourceBundle潜规则多？

│ │ ├─138-Java文本格式化：MessageFormat脱离Spring场景，能力更强大？

│ │ ├─139-MessageSource开箱即用实现：ResourceBundle+MessageFormat组合拳？

│ │ ├─14-IoC主要实现策略：面试官总问IoC和DI的区别，他真的理解吗？

│ │ ├─140-MessageSource内建依赖：到底“我”是谁？

│ │ ├─141-课外资料：SpringBoot为什么要新建MessageSourceBean？

│ │ ├─142-面试题精选

│ │ ├─143-Spring校验使用场景：为什么Validator并不只是Bean的校验？

│ │ ├─144-Validator接口设计：画虎不成反类犬？

│ │ ├─145-Errors接口设计：复杂得没有办法理解？

│ │ ├─146-Errors文案来源：Spring国际化充当临时工？

│ │ ├─147-自定义Validator：为什么说Validator容易实现，却难以维护？

│ │ ├─148-Validator的救赎：如果没有BeanValidation，Validator将会在哪里吗？

│ │ ├─149-面试题精选

│ │ ├─15-IoC容器的职责：IoC除了依赖注入，还涵盖哪些职责呢？

│ │ ├─150-Spring数据绑定使用场景：为什么官方文档描述一笔带过？

│ │ ├─151-Spring数据绑定组件：DataBinder

│ │ ├─152-DataBinder绑定元数据：PropertyValues不是SpringBean属性元信息吗？

│ │ ├─153-DataBinder绑定控制参数：ignoreUnknownFields和ignoreInvalidFields有什么作用？

│ │ ├─154-Spring底层JavaBeans替换实现：BeanWrapper源于JavaBeans而高于JavaBeans？

│ │ ├─155-BeanWrapper的使用场景：Spring数据绑定只是副业？

│ │ ├─156-课外资料：标准JavaBeans是如何操作属性的

│ │ ├─157-DataBinder数据校验：又见Validator

│ │ ├─158-面试题精选

│ │ ├─159-Spring类型转换的实现：Spring提供了哪几种类型转换的实现？

│ │ ├─16-除了Spring，还有其它的IOC容器实现吗？

│ │ ├─160-使用场景：Spring类型转换各自的使用场景以及发展脉络是怎样的？

│ │ ├─161-基于JavaBeans接口的类型转换：Spring是如何扩展PropertyEditor接口实现类型转换的？

│ │ ├─162-Spring内建PropertyEditor扩展：哪些常见类型被Spring内建PropertyEditor实现？

│ │ ├─163-自定义PropertyEditor扩展：不尝试怎么知道它好不好用？

│ │ ├─164-SpringPropertyEditor的设计缺陷：为什么基于PropertyEditor扩展并不适合作为类型转换？

│ │ ├─165-Spring3通用类型转换接口：为什么Converter接口设计比PropertyEditor更合理？

│ │ ├─166-Spring内建类型转换器：Spring的内建类型转换器到底有多丰富？

│ │ ├─167-Converter接口的局限性：哪种类型转换场景Converter无法满足？有什么应对之策？

│ │ ├─168-GenericConverter接口：为什么GenericConverter比Converter更通用？

│ │ ├─169-优化GenericConverter接口：为什么GenericConverter需要补充条件判断？

│ │ ├─17-传统IoC容器实现：JavaBeans也是IoC容器吗？

│ │ ├─170-扩展Spring类型转换器：为什么最终注册的都是ConditionalGenericConverter？

│ │ ├─171-统一类型转换服务：ConversionService足够通用吗？

│ │ ├─172-ConversionService作为依赖-能够同时作为依赖查找和依赖注入的来源吗？

│ │ ├─173-面试题精选

│ │ ├─174-Java泛型基础：泛型参数信息在擦写后还会存在吗？

│ │ ├─175-Java5类型接口-Type：Java类型到底是Type还是Class？

│ │ ├─176-Spring泛型类型辅助类：GenericTypeResolver

│ │ ├─177-Spring泛型集合类型辅助类：GenericCollectionTypeResolver

│ │ ├─178-Spring方法参数封装-MethodParameter：不仅仅是方法参数

│ │ ├─179-Spring4

│ │ ├─18-轻量级IoC容器：如何界定IoC容器的“轻重”？

│ │ ├─180-ResolvableType的局限性：形式比人强？

│ │ ├─181-面试题精选

│ │ ├─182-Java事件-监听器编程模型：为什么Java中没有提供标准实现？

│ │ ├─183-面向接口的事件-监听器设计模式：单事件监听和多事件监听怎么选？

│ │ ├─184-面向注解的事件-监听器设计模式：便利也会带来伤害？

│ │ ├─185-Spring标准事件-ApplicationEvent：为什么不用EventObject？

│ │ ├─186-基于接口的Spring事件监听器：ApplicationListener为什么选择单事件监听模式？

│ │ ├─187-基于注解的Spring事件监听器：@EventListener有哪些潜在规则？

│ │ ├─188-注册SpringApplicationListener：直接注册和间接注册有哪些差异？

│ │ ├─189-Spring事件发布器：Spring4

│ │ ├─19-依赖查找VS

│ │ ├─190-Spring层次性上下文事件传播：这是一个Feature还是一个Bug？

│ │ ├─191-Spring内建事件（Built-inEvents）：为什么ContextStartedEvent和ContextStoppedEvent是鸡肋事件？-深入剖析源码，掌握核心编程特性

│ │ ├─192-Spring4

│ │ ├─193-自定义Spring事件：自定义事件业务用得上吗？

│ │ ├─194-依赖注入ApplicationEventPublisher：事件推送还会引起Bug？

│ │ ├─195-依赖查找ApplicationEventPublisher：ApplicationEventPublisher从何而来？

│ │ ├─196-ApplicationEventPublisher底层实现：ApplicationEventMulticaster也是JavaObservable的延伸？

│ │ ├─197-同步和异步Spring事件广播：Spring对J

│ │ ├─198-Spring4

│ │ ├─199-Spring事件-监听器实现原理：面向接口和注解的事件-监听器实现有区别吗？

│ │ ├─20-构造器注入VS

│ │ ├─200-课外资料：SpringBoot和SpringCloud事件也是Spring事件？

│ │ ├─201-面试题精选

│ │ ├─202-Spring注解驱动编程发展历程

│ │ ├─203-Spring核心注解场景分类

│ │ ├─204-Spring注解编程模型

│ │ ├─205-Spring元注解（Meta-Annotations）

│ │ ├─206-Spring模式注解（StereotypeAnnotations）

│ │ ├─207-Spring组合注解（ComposedAnnotations）

│ │ ├─208-Spring注解属性别名（AttributeAliases）

│ │ ├─209-Spring注解属性覆盖（AttributeOverrides）

│ │ ├─21-面试题精选

│ │ ├─210-Spring@Enable模块驱动

│ │ ├─211-Spring条件注解

│ │ ├─212-课外资料：SpringBoot和SpringCloud是怎样在Spring注解内核上扩展的

│ │ ├─213-面试题精选

│ │ ├─214-理解SpringEnvironment抽象

│ │ ├─215-SpringEnvironment接口使用场景

│ │ ├─216-Environment占位符处理

│ │ ├─217-理解条件配置SpringProfiles

│ │ ├─218-Spring4重构@Profile

│ │ ├─219-依赖注入Environment

│ │ ├─22-SpringIoC依赖查找：依赖注入还不够吗？依赖查找存在的价值几何？

│ │ ├─220-依赖查找Environment

│ │ ├─221-依赖注入@Value

│ │ ├─222-Spring类型转换在Environment中的运用

│ │ ├─223-Spring类型转换在@Value中的运用

│ │ ├─224-Spring配置属性源PropertySource

│ │ ├─225-Spring內建的配置属性源

│ │ ├─226-基于注解扩展Spring配置属性源

│ │ ├─227-基于API扩展Spring外部化配置属性源

│ │ ├─228-课外资料：Spring4

│ │ ├─229-面试题精选

│ │ ├─23-SpringIoC依赖注入：Spring提供了哪些依赖注入模式和类型呢？

│ │ ├─230-Spring应用上下文启动准备阶段

│ │ ├─231-BeanFactory创建阶段

│ │ ├─232-BeanFactory准备阶段

│ │ ├─233-BeanFactory后置处理阶段

│ │ ├─234-BeanFactory注册BeanpostProcessor阶段

│ │ ├─235-初始化内建Bean：MessageSource

│ │ ├─236-初始化内建Bean：Spring事件广播器

│ │ ├─237-Spring应用上下文刷新阶段

│ │ ├─238-Spring事件监听器注册阶段

│ │ ├─239-BeanFactory初始化完成阶段

│ │ ├─24-SpringIoC依赖来源：依赖注入和查找的对象来自于哪里？

│ │ ├─240-Spring应用上下刷新完成阶段

│ │ ├─241-Spring应用上下文启动阶段

│ │ ├─242-Spring应用上下文停止阶段

│ │ ├─243-Spring应用上下文关闭阶段

│ │ ├─244-面试题精选

│ │ ├─245-结束语

│ │ ├─25-SpringIoC配置元信息：SpringIoC有哪些配置元信息？它们的进化过程是怎样的？

│ │ ├─26-SpringIoC容器：BeanFactory和ApplicationContext谁才是SpringIoC容器？

│ │ ├─27-Spring应用上下文：ApplicationContext除了IoC容器角色，还提供哪些特性？

│ │ ├─28-使用SpringIoC容器：选BeanFactory还是ApplicationContext？

│ │ ├─29-SpringIoC容器生命周期：IoC容器启停过程中发生了什么？

│ │ ├─30-面试题精选

│ │ ├─31-定义Bean：什么是BeanDefinition？

│ │ ├─32-BeanDefinition元信息：除了Bean名称和类名，还有哪些Bean元信息值得关注？

│ │ ├─33-命名SpringBean：id和name属性命名Bean，哪个更好？

│ │ ├─34-SpringBean的别名：为什么命名Bean还需要别名？

│ │ ├─35-注册SpringBean：如何将BeanDefinition注册到IoC容器？

│ │ ├─36-实例化SpringBean：Bean实例化的姿势有多少种？

│ │ ├─37-初始化SpringBean：Bean初始化有哪些方式？

│ │ ├─38-延迟初始化SpringBean：延迟初始化的Bean会影响依赖注入吗？

│ │ ├─39-销毁SpringBean：销毁Bean的基本操作有哪些？

│ │ ├─40-回收SpringBean：SpringIoC容器管理的Bean能够被垃圾回收吗？

│ │ ├─41-面试题精选

│ │ ├─42-依赖查找的今世前生：SpringIoC容器从Java标准中学到了什么？

│ │ ├─43-单一类型依赖查找：如何查找已知名称或类型的Bean对象？

│ │ ├─44-集合类型依赖查找：如何查找已知类型多个Bean集合？

│ │ ├─45-层次性依赖查找：依赖查找也有双亲委派？

│ │ ├─46-延迟依赖查找：非延迟初始化Bean也能实现延迟查找？

│ │ ├─47-安全依赖查找

│ │ ├─48-内建可查找的依赖：哪些SpringIoC容器内建依赖可供查找？

│ │ ├─49-依赖查找中的经典异常：Bean找不到？Bean不是唯一的？Bean创建失败？

│ │ ├─50-面试题精选

│ │ ├─51-依赖注入的模式和类型：Spring提供了哪些依赖注入的模式和类型？

│ │ ├─52-自动绑定（Autowiring）：为什么Spring会引入Autowiring？

│ │ ├─53-自动绑定（Autowiring）模式：各种自动绑定模式的使用场景是什么？

│ │ ├─54-自动绑定（Autowiring）限制和不足：如何理解和挖掘官方文档中深层次的含义？

│ │ ├─55-Setter方法依赖注入：Setter注入的原理是什么？

│ │ ├─56-构造器依赖注入：官方为什么推荐使用构造器注入？

│ │ ├─57-字段注入：为什么Spring官方文档没有单独列举这种注入方式？

│ │ ├─58-方法注入：方法注入是@Autowired专利吗？

│ │ ├─59-接口回调注入：回调注入的使用场景和限制有哪些？

│ │ ├─60-依赖注入类型选择：各种依赖注入有什么样的使用场景？

│ │ ├─61-基础类型注入：String和Java原生类型也能注入Bean的属性，它们算依赖注入吗？

│ │ ├─62-集合类型注入：注入Collection和Map类型的依赖区别？还支持哪些集合类型？

│ │ ├─63-限定注入：如何限定Bean名称注入？如何实现Bean逻辑分组注入？

│ │ ├─64-延迟依赖注入：如何实现延迟执行依赖注入？与延迟依赖查找是类似的吗？

│ │ ├─65-依赖处理过程：依赖处理时会发生什么？其中与依赖查找的差异在哪？

│ │ ├─66-@Autowired注入：@Autowired注入的规则和原理有哪些？

│ │ ├─67-JSR-330@Inject注入：@Inject与@Autowired的注入原理有怎样的联系？

│ │ ├─68-Java通用注解注入原理：Spring是如何实现@Resource和@EJB等注解注入的？

│ │ ├─69-自定义依赖注入注解：如何最简化实现自定义依赖注入注解？

│ │ ├─70-面试题精选

│ │ ├─71-依赖查找的来源：除容器内建和自定义SpringBean之外，还有其他来源提供依赖查找吗？

│ │ ├─72-依赖注入的来源：难道依赖注入的来源与依赖查找的不同吗？

│ │ ├─73-Spring容器管理和游离对象：为什么会有管理对象和游离对象？

│ │ ├─74-SpringBeanDefinition作为依赖来源：SpringBean的来源

│ │ ├─75-单例对象作为依赖来源：单体对象与普通SpringBean存在哪些差异？

│ │ ├─76-非Spring容器管理对象作为依赖来源：如何理解ResolvableDependency？

│ │ ├─77-外部化配置作为依赖来源：@Value是如何将外部化配置注入SpringBean的？

│ │ ├─78-面试题精选

│ │ ├─79-SpringBean作用域：为什么SpringBean需要多种作用域？

│ │ ├─80-singleton-Bean作用域：单例Bean在当前Spring应用真是唯一的吗？

│ │ ├─81-prototype-Bean作用域：原型Bean在哪些场景下会创建新的实例？

│ │ ├─82-request-Bean作用域：requestBean会在每次HTTP请求创建新的实例吗？

│ │ ├─83-session-Bean作用域：sessionBean在SpringMVC场景下存在哪些局限性？

│ │ ├─84-application-Bean作用域：applicationBean是否真的有必要？

│ │ ├─85-自定义Bean作用域：设计Bean作用域应该注意哪些原则？

│ │ ├─86-课外资料：SpringCloudRefreshScope是如何控制Bean的动态刷新？

│ │ ├─87-面试题精选

│ │ ├─88-SpringBean元信息配置阶段：BeanDefinition配置与扩展

│ │ ├─89-SpringBean元信息解析阶段：BeanDefinition的解析

│ │ ├─90-SpringBean注册阶段：BeanDefinition与单体Bean注册

│ │ ├─91-SpringBeanDefinition合并阶段：BeanDefinition合并过程是怎样出现的？

│ │ ├─92-SpringBeanClass加载阶段：BeanClassLoader能够被替换吗

│ │ ├─93-SpringBean实例化前阶段：Bean的实例化能否被绕开？

│ │ ├─94-SpringBean实例化阶段：Bean实例是通过Java反射创建吗？

│ │ ├─95-SpringBean实例化后阶段：Bean实例化后是否一定被是使用吗？

│ │ ├─96-SpringBean属性赋值前阶段：配置后的PropertyValues还有机会修改吗？

│ │ ├─97-Aware接口回调阶段：众多Aware接口回调的顺序是安排的？

│ │ ├─98-SpringBean初始化前阶段：BeanPostProcessor

│ │ ├─99-SpringBean初始化阶段：@PostConstruct、InitializingBean以及自定义方法

│ │ ├─加餐1：为什么说ObjectFactory提供的是延迟依赖查找

│ │ ├─加餐2-依赖查找（注入）的Bean会被缓存吗？

│ │ ├─加餐3-@Bean的处理流程是怎样的？

│ │ ├─加餐4-BeanFactory如何处理循环依赖的？

│ │ └─加餐5-MyBatis与SpringFramework是如何集成的？

│ ├─28-Electron开发实战

│ │ ├─02-内容综述：学完这门课程你能得到什么？

│ │ ├─03-Electron介绍：为什么Electron这么火？

│ │ ├─04-揭秘Electron架构原理：Chromium+Node

│ │ ├─05-桌面端技术选型：如何选择合适的桌面端技术？

│ │ ├─06-Electron开发准备：环境搭建及前期准备

│ │ ├─07-第一个Electron应用：开发一个简单版的番茄钟（上）

│ │ ├─08-第一个Electron应用：开发一个简单版的番茄钟（下）

│ │ ├─09-与Web开发不同（一）：主进程与渲染进程

│ │ ├─10-与Web开发不同（二）：进程间通信

│ │ ├─11-与Web开发不同（三）：Native能力及原生GUI

│ │ ├─12-与Web开发不同（四）：释放前端想象力，基于Electron能做什么？

│ │ ├─13-实战项目综述：整体需求分析

│ │ ├─14-设计思路：做远程控制有几步？

│ │ ├─15-项目架构与基础业务：Electron与React框架结合

│ │ ├─16-主页面基础业务：RealWorldIPC

│ │ ├─17-傀儡端实现（一）：基于Electron能力捕获桌面视频流

│ │ ├─18-傀儡端实现（二）：如何接收&响应指令？

│ │ ├─19-傀儡端实现（三）：基于WebRTC传输视频流（上）

│ │ ├─20-傀儡端实现（四）：基于WebRTC传输视频流（下）

│ │ ├─21-信令服务：如何连接两端（上）

│ │ ├─22-信令服务：如何连接两端（下）

│ │ ├─23-指令传输实现：如何建立数据传输？

│ │ ├─24-项目完善与总结（上）：App特性

│ │ ├─25-项目完善与总结（下）：原生GUI

│ │ ├─26-Electron应用打包：从HTML到安装包

│ │ ├─27-Electron应用更新（一）：软件更新的痛点

│ │ ├─28-Electron应用更新（二）：线上项目如何更新？

│ │ ├─29-Electron质量监控：桌面端的质量抓手是什么？

│ │ ├─30-使用原生能力：如何集成C++能力？

│ │ ├─31-Electron自动化测试：如何编写端到端测试？

│ │ ├─32-Electron体验优化：如何优化白屏问题？

│ │ ├─33-Electron客户端的安全：从XSS到RCE

│ │ ├─34-Electronbadparts：辩证看待Electron技术

│ │ └─35-结课测试&结束语

│ ├─29-NETCore开发实战

│ │ ├─03-

│ │ ├─04-Startup：掌握ASP

│ │ ├─05-依赖注入：良好架构的起点

│ │ ├─06-作用域与对象释放行为：你知道IDisposable对象释放的时机和坑吗？

│ │ ├─07-用Autofac增强容器能力：引入面向切面编程（AOP）的能力

│ │ ├─08-配置框架：让服务无缝适应各种环境

│ │ ├─09-命令行配置提供程序：最简单快捷的配置注入方法

│ │ ├─10-环境变量配置提供程序：容器环境下配置注入的最佳途径

│ │ ├─11-文件配置提供程序：自由选择配置的格式

│ │ ├─12-配置变更监听：配置热更新能力的核心

│ │ ├─13-配置绑定：使用强类型对象承载配置数据

│ │ ├─14-自定义配置数据源：低成本实现定制化配置方案

│ │ ├─15-选项框架：服务组件集成配置的最佳实践

│ │ ├─16-选项数据热更新：让服务感知配置的变化

│ │ ├─17-为选项数据添加验证：避免错误配置的应用接收用户流量

│ │ ├─18-日志框架：聊聊记日志的最佳姿势

│ │ ├─19-日志作用域：解决不同请求之间的日志干扰

│ │ ├─20-结构化日志组件Serilog：记录对查询分析友好的日志

│ │ ├─21-中间件：掌控请求处理过程的关键

│ │ ├─22-异常处理中间件：区分真异常与逻辑异常

│ │ ├─23-静态文件中间件：前后端分离开发合并部署骚操作

│ │ ├─24-文件提供程序：让你可以将文件放在任何地方

│ │ ├─25-路由与终结点：如何规划好你的WebAPI

│ │ ├─26-工程结构概览：定义应用分层及依赖关系

│ │ ├─27-定义Entity：区分领域模型的内在逻辑和外在行为

│ │ ├─28-工作单元模式（UnitOfWork）：管理好你的事务

│ │ ├─29-定义仓储：使用EFCore实现仓储层

│ │ ├─30-领域事件：提升业务内聚，实现模块解耦

│ │ ├─31-APIController：定义API的最佳实践

│ │ ├─32-集成事件：解决跨微服务的最终一致性

│ │ ├─33-集成事件：使用RabbitMQ来实现EventBus

│ │ ├─34-MediatR：轻松实现命令查询职责分离模式（CQRS）

│ │ ├─35-MediatR：让领域事件处理更加优雅

│ │ ├─36-HttpClientFactory：管理向外请求的最佳实践

│ │ ├─37-gRPC：内部服务间通讯利器

│ │ ├─38-gRPC：用代码生成工具提高生产效率

│ │ ├─39-Polly：用失败重试机制提升服务可用性

│ │ ├─40-Polly：熔断慢请求避免雪崩效应

│ │ ├─41-网关与BFF：区分场景与职责

│ │ ├─42-网关与BFF：使用JWT来实现身份认证与授权

│ │ ├─43-安全：反跨站请求伪造

│ │ ├─44-安全：防开放重定向攻击

│ │ ├─45-安全：防跨站脚本

│ │ ├─46-安全：跨域请求

│ │ ├─47-缓存：为不同的场景设计合适的缓存策略

│ │ ├─48-部署：演示一个部署流程

│ │ ├─49-ConfigMap：实现基本配置方案

│ │ ├─50-配置：使用分布式配置中心方案版本化管理配置

│ │ ├─51-健康检查：与Liveness、Readiness、Startup探测集成实现高可用

│ │ ├─52-健康检查：搭建全量健康检查探针和看板

│ │ ├─53-ForwardedHeaders：确保服务在负载均衡下正常工作

│ │ ├─54-安全：介绍强制HTTPS的两种方式

│ │ ├─55-日志：与EFK日志三件套集成

│ │ ├─56-日志：Exceptionless日志系统

│ │ ├─57-追踪：集成SkyWalking

│ │ ├─58-监控与告警：Prometheus与AlertManager

│ │ ├─59-监控与告警：用Granfana实现监控看板

│ │ ├─60-prometheus-net：自定义监控指标利器

│ │ └─61-结课测试&结束语

│ ├─3-零基础学Python（2018版）

│ │ ├─01-Python语言的特点

│ │ ├─02-Python的发展历史与版本

│ │ ├─03-Python的安装

│ │ ├─04-Python程序的书写规则

│ │ ├─05-基础数据类型

│ │ ├─06-变量的定义和常用操作

│ │ ├─07-序列的概念

│ │ ├─08-字符串的定义和使用

│ │ ├─09-字符串的常用操作

│ │ ├─10-元组的定义和常用操作

│ │ ├─11-列表的定义和常用操作

│ │ ├─12-条件语句

│ │ ├─13-for循环

│ │ ├─14-while循环

│ │ ├─15-for循环语句中的if嵌套

│ │ ├─16-while循环语句中的if嵌套

│ │ ├─17-字典的定义和常用操作

│ │ ├─18-列表推导式与字典推导式

│ │ ├─19-文件的内建函数

│ │ ├─20-文件的常用操作

│ │ ├─21-异常的检测和处理

│ │ ├─22-函数的定义和常用操作

│ │ ├─23-函数的可变长参数

│ │ ├─24-函数的变量作用域

│ │ ├─25-函数的迭代器与生成器

│ │ ├─26-Lambda表达式

│ │ ├─27-Python内建函数

│ │ ├─28-闭包的定义

│ │ ├─29-闭包的使用

│ │ ├─30-装饰器的定义

│ │ ├─31-装饰器的使用

│ │ ├─32-自定义上下文管理器

│ │ ├─33-模块的定义

│ │ ├─34-PEP8编码规范(1)

│ │ ├─34-PEP8编码规范

│ │ ├─35-类与实例

│ │ ├─36-如何增加类的属性和方法

│ │ ├─37-类的继承

│ │ ├─38-类的使用-自定义with语句

│ │ ├─39-多线程编程的定义

│ │ ├─40-经典的生产者和消费者问题

│ │ ├─41-Python标准库的定义

│ │ ├─42-正则表达式库re

│ │ ├─43-正则表达式的元字符

│ │ ├─44-正则表达式分组功能实例

│ │ ├─45-正则表达式库函数match与search的区别

│ │ ├─46-正则表达式库替换函数sub()的实例

│ │ ├─47-日期与时间函数库

│ │ ├─48-数学相关库

│ │ ├─49-使用命令行对文件和文件夹操作

│ │ ├─50-文件与目录操作库

│ │ ├─51-机器学习的一般流程与NumPy安装

│ │ ├─52-NumPy的数组与数据类型

│ │ ├─53-NumPy数组和标量的计算

│ │ ├─54-NumPy数组的索引和切片

│ │ ├─55-pandas安装与Series结构

│ │ ├─56-Series的基本操作

│ │ ├─57-Dataframe的基本操作

│ │ ├─58-层次化索引

│ │ ├─59-Matplotlib的安装与绘图

│ │ ├─60-机器学习分类的原理

│ │ ├─61-Tensorflow的安装

│ │ ├─62-根据特征值分类的模型和代码

│ │ ├─63-网页数据的采集与urllib库

│ │ ├─64-网页常见的两种请求方式get和post

│ │ ├─65-HTTP头部信息的模拟

│ │ ├─66-requests库的基本使用

│ │ ├─67-结合正则表达式爬取图片链接

│ │ ├─68-BeautifulSoup的安装和使用

│ │ ├─69-使用爬虫爬取新闻网站

│ │ ├─70-使用爬虫爬取图片链接并下载图片

│ │ └─71-如何分析源代码并设计合理的代码结构&结课测试

│ ├─30-NLP实战高手课

│ │ ├─03-AI概览：宣传片外的人工智能

│ │ ├─04-AI项目流程：从实验到落地

│ │ ├─05-NLP领域简介：NLP基本任务及研究方向

│ │ ├─06-NLP应用：智能问答系统

│ │ ├─07-NLP应用：文本校对系统

│ │ ├─08-NLP的学习方法：如何在AI爆炸时代快速上手学习？

│ │ ├─09-深度学习框架简介：如何选择合适的深度学习框架？

│ │ ├─10-深度学习与硬件：CPU

│ │ ├─100-WikiSQL任务简介

│ │ ├─101-ASDL和AST

│ │ ├─102-Tranx简介

│ │ ├─103-LambdaCaculus概述

│ │ ├─104-Lambda-DCS概述

│ │ ├─105-InductiveLogicProgramming：基本设定

│ │ ├─106-InductiveLogicProgramming：一个可微的实现

│ │ ├─107-增强学习的基本设定：增强学习与传统的预测性建模有什么区别？

│ │ ├─108-最短路问题和DijkstraAlgorithm

│ │ ├─109-Q-learning：如何进行Q-learning算法的推导？

│ │ ├─11-深度学习与硬件：GPU

│ │ ├─110-Rainbow：如何改进Q-learning算法？

│ │ ├─111-PolicyGradient：如何进行PolicyGradient的基本推导？

│ │ ├─112-A2C和A3C：如何提升基本的PolicyGradient算法

│ │ ├─113-Gumbel-trick：如何将离散的优化改变为连续的优化问题？

│ │ ├─114-MCTS简介：如何将“推理”引入到强化学习框架中

│ │ ├─115-DirectPolictyGradient：基本设定及Gumbel-trick的使用

│ │ ├─116-DirectPolictyGradient：轨迹生成方法

│ │ ├─117-AutoML及NeuralArchitectureSearch简介

│ │ ├─118-AutoML网络架构举例

│ │ ├─119-RENAS：如何使用遗传算法和增强学习探索网络架构

│ │ ├─12-深度学习与硬件：TPU

│ │ ├─120-DifferentiableSearch：如何将NAS变为可微的问题

│ │ ├─121-层次搜索法：如何在模块之间进行搜索？

│ │ ├─122-LeNAS：如何搜索搜索space

│ │ ├─123-超参数搜索：如何寻找算法的超参数

│ │ ├─124-Learningtooptimize：是否可以让机器学到一个新的优化器

│ │ ├─125-遗传算法和增强学习的结合

│ │ ├─126-使用增强学习改进组合优化的算法

│ │ ├─127-多代理增强学习概述：什么是多代理增强学习？

│ │ ├─128-AlphaStar介绍：AlphaStar中采取了哪些技术？

│ │ ├─129-IMPALA：多Agent的Actor-Critic算法

│ │ ├─13-AI项目部署：基本原则

│ │ ├─130-COMA-Agent之间的交流

│ │ ├─131-多模态表示学习简介

│ │ ├─132-知识蒸馏：如何加速神经网络推理

│ │ ├─133-DeepGBM：如何用神经网络捕捉集成树模型的知识

│ │ ├─134-文本推荐系统和增强学习

│ │ ├─135-RL训练方法集锦：简介

│ │ ├─136-RL训练方法-RL实验的注意事项

│ │ ├─137-PPO算法

│ │ ├─138-Reward设计的一般原则

│ │ ├─139-解决SparseReward的一些方法

│ │ ├─14-AI项目部署：框架选择

│ │ ├─140-ImitationLearning和Self-imitationLearning

│ │ ├─141-增强学习中的探索问题

│ │ ├─142-Model-basedReinforcementLearning

│ │ ├─143-TransferReinforcementLearning和Few-shotReinforcementLearning

│ │ ├─144-Quora问题等价性案例学习：预处理和人工特征

│ │ ├─145-Quora问题等价性案例学习：深度学习模型

│ │ ├─146-文本校对案例学习

│ │ ├─147-微服务和Kubernetes简介

│ │ ├─148-Docker简介

│ │ ├─149-Docker部署实践

│ │ ├─15-AI项目部署：微服务简介

│ │ ├─150-Kubernetes基本概念

│ │ ├─151-Kubernetes部署实践

│ │ ├─152-Kubernetes自动扩容

│ │ ├─153-Kubernetes服务发现

│ │ ├─154-KubernetesIngress

│ │ ├─155-Kubernetes健康检查

│ │ ├─156-Kubernetes灰度上线

│ │ ├─157-KubernetesStatefulSets

│ │ ├─158-Istio简介：Istio包含哪些功能？

│ │ ├─159-Istio实例和CircuitBreaker

│ │ ├─16-统计学基础：随机性是如何改变数据拟合的本质的？

│ │ ├─160-结束语

│ │ ├─17-神经网络基础：神经网络还是复合函数

│ │ ├─18-神经网络基础：训练神经网络

│ │ ├─19-神经网络基础：神经网络的基础构成

│ │ ├─20-Embedding简介：为什么Embedding更适合编码文本特征？

│ │ ├─21-RNN简介：马尔可夫过程和隐马尔可夫过程

│ │ ├─22-RNN简介：RNN和LSTM

│ │ ├─23-CNN：卷积神经网络是什么？

│ │ ├─24-环境部署：如何构建简单的深度学习环境？

│ │ ├─25-PyTorch简介：Tensor和相关运算

│ │ ├─26-PyTorch简介：如何构造Dataset和DataLoader？

│ │ ├─27-PyTorch简介：如何构造神经网络？

│ │ ├─28-文本分类实践：如何进行简单的文本分类？

│ │ ├─29-文本分类实践的评价：如何提升进一步的分类效果？

│ │ ├─30-经典的数据挖掘方法：数据驱动型开发早期的努力

│ │ ├─31-表格化数据挖掘基本流程：看看现在的数据挖掘都是怎么做的？

│ │ ├─32-Pandas简介：如何使用Pandas对数据进行处理？

│ │ ├─33-Matplotlib简介：如何进行简单的可视化分析？

│ │ ├─34-半自动特征构建方法：TargetMeanEncoding

│ │ ├─35-半自动特征构建方法：CategoricalEncoder

│ │ ├─36-半自动特征构建方法：连续变量的离散化

│ │ ├─37-半自动特征构建方法：EntityEmbedding

│ │ ├─38-半自动构建方法：EntityEmbedding的实现

│ │ ├─39-半自动特征构建方法：连续变量的转换

│ │ ├─40-半自动特征构建方法：缺失变量和异常值的处理

│ │ ├─41-自动特征构建方法：Symboliclearning和AutoCross简介

│ │ ├─42-降维方法：PCA、NMF和tSNE

│ │ ├─43-降维方法：DenoisingAutoEncoders

│ │ ├─44-降维方法：VariationalAutoEncoder

│ │ ├─45-变量选择方法

│ │ ├─46-集成树模型：如何提升决策树的效果

│ │ ├─47-集成树模型：GBDT和XgBoost的数学表达

│ │ ├─48-集成树模型：LightGBM简介

│ │ ├─49-集成树模型：CatBoost和NGBoost简介

│ │ ├─50-神经网络建模：如何让神经网络实现你的数据挖掘需求

│ │ ├─51-神经网络的构建：ResidualConnection和DenseConnection

│ │ ├─52-神经网络的构建：NetworkinNetwork

│ │ ├─53-神经网络的构建：GatingMechanism和Attention

│ │ ├─54-神经网络的构建：Memory

│ │ ├─55-神经网络的构建：ActivationFunction

│ │ ├─56-神经网络的构建：Normalization

│ │ ├─57-神经网络的训练：初始化

│ │ ├─58-神经网络的训练：学习率和Warm-up

│ │ ├─59-神经网络的训练：新的PyTorch训练框架

│ │ ├─60-Transformer：如何通过Transformer榨取重要变量？

│ │ ├─61-Transformer代码实现剖析

│ │ ├─62-xDeepFM：如何用神经网络处理高维的特征？

│ │ ├─63-xDeepFM的代码解析

│ │ ├─64-时序建模：如何用神经网络解决时间序列的预测问题？

│ │ ├─65-图嵌入：如何将图关系纳入模型？

│ │ ├─66-图网络简介：如何在图结构的基础上建立神经网络？

│ │ ├─67-模型融合基础：如何让你所学到的模型方法一起发挥作用？

│ │ ├─68-高级模型融合技巧：Metades是什么？

│ │ ├─69-挖掘自然语言中的人工特征：如何用传统的特征解决问题？

│ │ ├─70-重新审视WordEmbedding：NegativeSampling和ContextualEmbedding

│ │ ├─71-深度迁移学习模型：从ELMo到BERT

│ │ ├─72-深度迁移学习模型：RoBERTa、XLNet、ERNIE和T5

│ │ ├─73-深度迁移学习模型：ALBERT和ELECTRA

│ │ ├─74-深度迁移学习模型的微调：如何使用TensorFlow在TPU对模型进行微调

│ │ ├─75-深度迁移学习模型的微调：TensorFlowBERT代码简析

│ │ ├─76-深度迁移学习的微调：如何利用PyTorch实现深度迁移学习模型的微调及代码简析

│ │ ├─77-优化器：Adam和AdamW

│ │ ├─78-优化器：Lookahead，Radam和Lamb

│ │ ├─79-多重loss的方式：如何使用多重loss来提高模型准确率？

│ │ ├─80-数据扩充的基本方法：如何从少部分数据中扩充更多的数据并避免过拟合？

│ │ ├─81-UDA：一种系统的数据扩充框架

│ │ ├─82-LabelSmoothing和LogitSqueezing

│ │ ├─83-底层模型拼接：如何让不同的语言模型融合在一起从而达到更好的效果？

│ │ ├─84-上层模型拼接：如何在语言模型基础上拼接更多的模型？

│ │ ├─85-长文本分类：截取、关键词拼接和预测平均

│ │ ├─86-VirtualAdverserialTraining：如何减少一般对抗训练难收敛的问题并提高结果的鲁棒性？

│ │ ├─87-其他Embedding的训练：还有哪些Embedding方法？

│ │ ├─88-训练预语言模型

│ │ ├─89-多任务训练：如何利用多任务训练来提升效果？

│ │ ├─90-DomainAdaptation：如何利用其它有标注语料来提升效果？

│ │ ├─91-Few-shotLearning：是否有更好的利用不同任务的方法？

│ │ ├─92-半监督学习：如何让没有标注的数据也派上用场？

│ │ ├─93-依存分析和SemanticParsing概述

│ │ ├─94-依存分析和UniversalDepdencyRelattions

│ │ ├─95-如何在Stanza中实现DependencyParsing

│ │ ├─96-ShiftReduce算法

│ │ ├─97-基于神经网络的依存分析算法

│ │ ├─98-树神经网络：如何采用TreeLSTM和其它拓展方法？

│ │ └─99-SemanticParsing基础：SemanticParsing的任务是什么？

│ ├─31-ServiceMesh实战

│ │ ├─03-ServiceMesh的起源：为什么会出现ServiceMesh技术？

│ │ ├─04-ServiceMesh的发展：ServiceMesh技术是如何演进的？

│ │ ├─05-微服务通信的济世良方：什么是ServiceMesh？它能帮你做什么？

│ │ ├─06-列王的纷争：市面上有哪些主流的ServiceMesh产品？

│ │ ├─07-王者的诞生：为什么Istio有如此高的呼声？

│ │ ├─08-Istio的自我救赎：为什么Istio发生了两次重大的架构变更？

│ │ ├─09-核心功能之流量控制：Istio是如何实现流量控制功能的？

│ │ ├─10-服务的可观察性：如何理解服务可视化的重要性？

│ │ ├─11-保卫你的网格：Istio是如何设计安全架构的？

│ │ ├─12-安装与部署：如何安装Istio？它都支持哪些环境和部署方式？

│ │ ├─13-动态路由：用VirtualService和DestinationRule设置路由规则

│ │ ├─14-网关：用Gateway管理进入网格的流量

│ │ ├─15-服务入口：用ServiceEntry扩展你的网格服务

│ │ ├─16-流量转移：灰度发布是如何实现的？

│ │ ├─17-Ingress：控制进入网格的请求

│ │ ├─18-Egress：用Egress实现访问外部服务

│ │ ├─19-超时重试：提升系统的健壮性和可用性

│ │ ├─20-熔断：“秒杀”场景下的过载保护是如何实现的？

│ │ ├─21-故障注入：在Istio中实现一个“ChaosMonkey”

│ │ ├─22-流量镜像：解决线上问题排查的难题

│ │ ├─23-洞察你的服务：使用Kiali观测你的微服务应用

│ │ ├─24-指标：使用Prometheus收集指标

│ │ ├─25-监控：使用Grafana查看系统的整体状态

│ │ ├─26-日志：如何获取Envoy的日志并进行调试

│ │ ├─27-分布式追踪：使用Jeager对应用进行分布式追踪

│ │ ├─28-守卫网格：配置TLS安全网关

│ │ ├─29-双重保障：为应用设置不同级别的双向TLS

│ │ ├─30-授权策略：如何实现JWT身份认证与授权？

│ │ ├─31-实战演练（一）：项目准备和构建过程

│ │ ├─32-实战演练（二）：实现自动化灰度发布

│ │ ├─33-实战演练（三）：提升系统的弹性能力

│ │ ├─34-实战演练（四）：配置安全策略

│ │ ├─35-实战演练（五）：收集指标并监控应用

│ │ ├─36-实战演练（六）：集成ELKStack日志套件

│ │ ├─37-实战演练（七）：集成分布式追踪工具

│ │ ├─38-调试工具和方法：调试网格的工具和方法有哪些？

│ │ ├─39-实践经验总结：实际落地中的常见问题有哪些？

│ │ ├─40-未来架构——从ServiceMesh迈向云原生

│ │ └─41-结果测试&结束语

│ ├─32-微信小程序全栈开发实战

│ │ ├─03-小程序的特点及开发能力

│ │ ├─04-新的一年，微信小程序开放了哪些新功能？

│ │ ├─05-小程序运行机制简介：从零构建一个WebApp需要做哪些事情？

│ │ ├─06-开发环境配置：创建你的第一个小程序项目

│ │ ├─07-icon组件：关于图标的4个实现方案

│ │ ├─08-progress组件：如何自定义实现一个环形进度条？

│ │ ├─09-rich-text组件：如何单击预览rich-text中的图片并保存？

│ │ ├─10-view容器组件及Flex布局（一）：学习容器组件view及其重要属性

│ │ ├─100-购物车页面：实现向购物车添加商品的接口

│ │ ├─101-购物车页面：实现“加入购物车”功能

│ │ ├─102-购物车页面：实现购物车拉取接口

│ │ ├─103-购物车页面：调用购物车列表接口与绑定页面数据

│ │ ├─104-购物车页面：实现改变购物车商品数量的接口

│ │ ├─105-购物车页面：实现商品增减

│ │ ├─106-购物车页面：实现批量删除

│ │ ├─107-确认订单页面：实现地址项与商品列表UI

│ │ ├─108-确认订单页面：绑定商品列表数据

│ │ ├─109-确认订单页面：实现确认订单页面其它UI

│ │ ├─11-view容器组件及Flex布局（二）：介绍flex布局中常用的样式及样式值

│ │ ├─110-购物车页面：尝试使用计算属性

│ │ ├─111-快递地址列表页面：创建快递列表页面UI

│ │ ├─112｜新增地址页：创建新增收货地址页面UI与双向绑定

│ │ ├─113｜微信接口：验证接口是否可用

│ │ ├─114｜收货地址列表页：从微信获取预存的收货地址

│ │ ├─115｜后端：创建address模型与列表接口

│ │ ├─116｜后端：创建新增收货地址接口、添加索引

│ │ ├─117｜新增地址页：实现收货地址新增功能

│ │ ├─118｜收货地址列表页：拉取真是收货地址并渲染

│ │ ├─119｜收货地址列表页：优化微信收货地址获取的逻辑

│ │ ├─12-可移动容器及可移动区域（一）：学习使用movable-view与movable-area组件

│ │ ├─120｜后端：实现收货地址编辑接口

│ │ ├─121｜新增编辑地址页：实现前端编辑功能

│ │ ├─122｜地址列表页：实现滑动删除功能的UI

│ │ ├─123｜地址列表页：实现地址删除接口及前端删除功能

│ │ ├─124｜微信支付：申请微信认证及微信支付

│ │ ├─125｜微信支付：登录商户平台作支付开发准备

│ │ ├─126｜微信支付：安装微信支付模块koa3-wechat

│ │ ├─127｜微信支付：初始化koa3-wechat支付模块

│ │ ├─128｜微信支付：使用koa3-wechat调用统一下单接口准备支付参数

│ │ ├─129｜微信支付：使用wx

│ │ ├─13-可移动容器及可移动区域（二）：如何实现侧滑删除功能

│ │ ├─130｜微信支付：确认支付订单状态

│ │ ├─131｜微信支付：在云服务器上部署测试代码与配置nginx

│ │ ├─132｜微信支付：测试支付确认接口是否可用

│ │ ├─133｜确认下单页：清空已经下单的购物车商品

│ │ ├─134｜微信支付：实现退款接口

│ │ ├─135｜微信支付：尝试使用weixin-pay调用统一下单接口准备支付参数

│ │ ├─136｜微信支付：解决weixin-pay退款失败的问题

│ │ ├─137｜小微商户：申请帐号与支付测试

│ │ ├─138｜小微商户：试用小微商户

│ │ ├─139｜小微商户：实现下单接口

│ │ ├─14-scroll-view介绍：在小程序中如何实现滚动锚定？

│ │ ├─140｜小微商户：在手机上测试支付功能

│ │ ├─141｜小微商户：解决商户ID不能为空等问题

│ │ ├─142｜小微商户：实现支付结果回调的接口

│ │ ├─143｜小微商户：实现退款接口

│ │ ├─144｜公众号：公众号开发接入配置

│ │ ├─145｜公众号：接管公众号消息并作应答

│ │ ├─146｜微信认证：关于小程序公众号开放平台等帐号认证

│ │ ├─147｜服务号：网页授权的两种方式

│ │ ├─148｜云数据库：将线下数据库同步至线上

│ │ ├─149｜网页授权：通过测试号拉取用户信息

│ │ ├─15-scroll-view介绍：如果渲染一个滚动的长列表？

│ │ ├─150｜网页授权：在微信开发者工具中测试网页授权代码

│ │ ├─151｜测试：使用内网穿透服务ngrok

│ │ ├─152｜微页面：如何实现JS-SDK的初始化

│ │ ├─153｜云开发：创建第一个小程序云开发项目

│ │ ├─154｜云开发：创建第一个云开发环境

│ │ ├─155｜云开发：创建第一个云函数login

│ │ ├─156｜云函数：如何获取用户的openid

│ │ ├─157｜微信支付：基于云函数实现微信支付

│ │ ├─158｜云数据库：如何创建集合并实现数据的基本操作

│ │ ├─159｜云函数：如何在本地调试云函数

│ │ ├─16-滚动选择器（一）：学习使用选择器组件

│ │ ├─160｜云数据库：如何在小程序中操作云数据库

│ │ ├─161｜TCB：小程序与公众号共享云环境

│ │ ├─162｜云开发：使用实时数据监听实现多端信息同步

│ │ ├─163｜云数据库与云存储：使用事务与图片的上传下载功能

│ │ ├─164｜云环境：通过安装扩展应用快速实现功能

│ │ ├─165｜广告：创建与展示Banner广告

│ │ ├─166｜广告：创建与使用视频激励广告

│ │ ├─167｜广告：使用封面广告与自定义模板广告

│ │ ├─168｜插件开发：关于微信小程序插件的基础介绍

│ │ ├─169｜插件开发：创建第一个插件项目

│ │ ├─17-滚动选择器（二）：使用两种方式自定义实现省、市、区三级联动的选择器

│ │ ├─170｜插件开发：实现“每日天气”第一个版本的功能

│ │ ├─171｜插件开发：插件的提交审核与使用

│ │ ├─172｜插件开发：实现第二个版本的功能“每日微报”

│ │ ├─173｜插件开发：在插件中调用云函数

│ │ ├─174｜订阅与通知：实现消息订阅功能

│ │ ├─175｜插件开发：转发插件内页面

│ │ ├─176｜在小程序中使用Vue：使用kbone创建同构项目

│ │ ├─177｜Webpack构建小程序项目的示例：支持原生混合开发与云开发

│ │ ├─178｜课程答疑：如何使用源码

│ │ ├─179｜课程回顾及结束语

│ │ ├─18-滑动选择器表单组件：如何基于wxs自定义一个竖向的slider？

│ │ ├─19-页面链接组件：如何自定义一个导航栏？

│ │ ├─20-image媒体组件（上）：如何实现图片的懒加载？

│ │ ├─21-image媒体组件（下）：开发中经常遇到的问题？

│ │ ├─22-如何实现直播间功能？（一）：了解live-pusher、live-player组件的主要属性及使用限制

│ │ ├─23-如何实现直播间功能？（二）：如何开启、使用腾讯云的云直播功能

│ │ ├─24-如何实现直播间功能？（三）：安装与使用ffmepg，及使用ffmpeg进行推拉流验证

│ │ ├─25-如何实现直播间功能？（四）：使用live-pusher、live-player组件在小程序中实现直播功能

│ │ ├─26-如何实现直播间功能？（五）：同层渲染

│ │ ├─27-如何实现直播间功能？（六）：live-pusher、live-player组件在开发中的常见问题

│ │ ├─28-web-view（一）：了解session、cookie等相关基本概念

│ │ ├─29-web-view（二）：了解常见的四种鉴权方式

│ │ ├─30-web-view（三）：如何使用koa框架，及如何进行热加载？

│ │ ├─31-web-view（四）：如何在服务器端实现cookie与sesson的生成？

│ │ ├─32-web-view（五）：如何将session存储到服务器端，及如何实现token验证？

│ │ ├─33-web-view（六）：基于koa中间件，实现微信一键登录的后端接口

│ │ ├─34-web-view（七）：实现微信用户一键登录

│ │ ├─35-web-view（八）：了解正确的微信登录姿势

│ │ ├─36-web-view（九）：web-view组件在开发的常见问题讲解

│ │ ├─37-WebGL介绍（一）：了解WebGL相关的基础概念

│ │ ├─38-WebGL介绍（二）：如何在小程序中取到WebGL上下文环境对象

│ │ ├─39-WebGL介绍（三）：了解WebGL的世界坐标系

│ │ ├─40-WebGL介绍（四）：重新认识右手坐标系及如何编写顶点着色器代码

│ │ ├─41-WebGL介绍（五）：学习片断着色器编写，了解变量修饰变型uniform与attribute

│ │ ├─42-WebGL介绍（六）：了解在WebGL中裁剪空间是如何裁剪出来的

│ │ ├─43-WebGL介绍（七）：了解着色器变量值的绑定及三种三角形绘制模式之间的差异

│ │ ├─44-WebGL介绍（八）：在着色器中使用共享变量，绘制一个颜色渐变的正方形

│ │ ├─45-WebGL介绍（九）：完成动画

│ │ ├─46-WebGL介绍（十）：绘制一个旋转的立方体

│ │ ├─47-WebGL介绍（十一）：在3D绘制中使用纹理材质

│ │ ├─48-WebGL介绍（十二）：如何创建相机、场景及光源

│ │ ├─49-WebGL介绍（十三）：创建加载器、渲染器与控制器，完成3D模型文件的加载与展示

│ │ ├─50-网络接口简介（一）：如何使用wx

│ │ ├─51-网络接口简介（二）：将登录代码模块化封装

│ │ ├─52-网络接口简介（三）：Promise介绍及6个常用方法

│ │ ├─53-网络接口简介（四）：Promise三个方法any、all与race的使用介绍

│ │ ├─54-网络接口简介（五）：基于Promise+await、async关键字改写登录模块

│ │ ├─55-网络接口简介（六）：关于Page页面隐藏代码执行及Promise对象的catch处理的补充

│ │ ├─56-网络接口简介（七）：学习EventChannel对象

│ │ ├─57-网络接口简介（八）：观察者模式介绍及Event模块实现

│ │ ├─58-网络接口简介（九）：扩展wxp模块的request3方法，实现用户登录的自动融合

│ │ ├─59-tabBar组件（一）：系统默认的tabBar组件如何开启及使用

│ │ ├─60-tabBar组件（二）：基于系统提供的自定义方式，实现一个tabBar组件

│ │ ├─61-tabBar组件（三）：通过自定义组件扩展的方式，给任意组件添加通用方法

│ │ ├─62-开放接口（一）：如何对Page进行全局扩展

│ │ ├─63-开放接口（二）：优化前后端登录代码，解决后端解密错误

│ │ ├─64-设备能力：如何实现扫码连WiFi功能？

│ │ ├─65-前期留言集中答疑（一）

│ │ ├─66-前期留言集中答疑（二）

│ │ ├─67-搭建UI框架（一）：如何基于Vant快速创建小程序页面？

│ │ ├─68-搭建UI框架（二）：使用art-template模板引擎

│ │ ├─69-搭建UI框架（三）：规整后端koa项目结构

│ │ ├─70-用户登录（一）：创建与使用数据库

│ │ ├─71-用户登录（二）：创建sessionKeymodel并完善用户登录

│ │ ├─72-商品列表页：创建分类模型

│ │ ├─73-商品列表页：使用存储过程初始化分类表

│ │ ├─74-商品列表页：创建商品表、品牌表

│ │ ├─75-商品列表页：创建商品描述表

│ │ ├─76-商品列表页：创建商品SKU表

│ │ ├─77-商品列表页：初始化SKU表数据

│ │ ├─78-商品列表页：创建商品列表接口

│ │ ├─79-商品列表页：关联查询

│ │ ├─80-商品列表页：实现vtabs侧边栏导航

│ │ ├─81-商品列表页：调用商品分类分页列表接口

│ │ ├─82-商品列表页：实现延迟加载

│ │ ├─83-商品列表页：修改vtabs组件算法

│ │ ├─84-商品列表页：实现分页加载

│ │ ├─85-商品列表页：使用骨架屏

│ │ ├─86-商品详情页：创建商品详情接口

│ │ ├─87-商品详情页：使用EventChannel

│ │ ├─88-商品详情页：显示标题与价格

│ │ ├─89-商品详情页：使用Sketch

│ │ ├─90-商品详情页：使用蓝湖

│ │ ├─91-商品详情页：实现选择商品规格的UI

│ │ ├─92-商品详情页：在底部添加商品导航组件

│ │ ├─93-商品详情页：实现商品规格接口

│ │ ├─94-商品详情页：展示商品规格以供选择

│ │ ├─95-购物车页面：整合用户自动登录功能

│ │ ├─96-购物车页面：添加tabBar导航

│ │ ├─97-购物车页面：构建商品列表

│ │ ├─98-购物车页面：实现编辑模式与正常模式切换

│ │ └─99-购物车页面：创建购物车模型

│ ├─33-TensorFlow2项目进阶实战

│ │ ├─01-课程介绍：AI进阶需要落地实战

│ │ ├─02-内容综述：如何快速?效学习AI与TensorFlow2

│ │ ├─03-TensorFlow2新特性

│ │ ├─04-TensorFlow2核心模块

│ │ ├─05-TensorFlow2vsTensorFlow1

│ │ ├─06-TensorFlow2落地应?

│ │ ├─07-TensorFlow2开发环境搭建

│ │ ├─08-TensorFlow2数据导入与使?

│ │ ├─09-使用tf

│ │ ├─10-使用tf

│ │ ├─11-使用tf

│ │ ├─12-FashionMNIST数据集介绍

│ │ ├─13-使用TensorFlow2训练分类网络

│ │ ├─14-行业背景：AI新零售是什么

│ │ ├─15-用户需求：线下门店业绩如何提升？

│ │ ├─16-长期?标：货架数字化与业务智能化

│ │ ├─17-短期目标：自动化陈列审核和促销管理

│ │ ├─18-方案设计：基于深度学习的检测-分类的AI流水线

│ │ ├─19-方案交付：支持在线识别和API调用的AISaaS

│ │ ├─20-基础：目标检测问题定义与说明

│ │ ├─21-基础：深度学习在目标检测中的应用(1)

│ │ ├─21-基础：深度学习在目标检测中的应用

│ │ ├─22-理论：R-CNN系列二阶段模型综述

│ │ ├─23-理论：YOLO系列一阶段模型概述(1)

│ │ ├─23-理论：YOLO系列一阶段模型概述

│ │ ├─24-应用：RetinaNet与FacolLoss带来了什么

│ │ ├─25-应用：检测数据标注方法与流程

│ │ ├─26-应用：划分检测训练集与测试集

│ │ ├─27-应用：生成CSV格式数据集与标注

│ │ ├─28-应用：使用TensorFlow2训练RetinaNet

│ │ ├─29-应用：使用RetinaNet检测货架商品

│ │ ├─30-扩展：目标检测常用数据集综述

│ │ ├─31-扩展：目标检测更多应用场景介绍

│ │ ├─32-基础：图像分类问题定义与说明

│ │ ├─33-基础：越来越深的图像分类网络

│ │ ├─34-应?：检测SKU抠图与分类标注流程

│ │ ├─35-应?：分类训练集与验证集划分

│ │ ├─36-应?：使?TensorFlow2训练ResNet

│ │ ├─37-应用：使用ResNet识别货架商品

│ │ ├─38-扩展：图像分类常用数据集综述

│ │ ├─39-扩展：图像分类更多应?场景介绍

│ │ ├─40-串联AI流程理论：商品检测与商品识别

│ │ ├─41-串联AI流程实战：商品检测与商品识别

│ │ ├─42-展现AI效果理论：使用OpenCV可视化识别结果

│ │ ├─43-展现AI效果实战：使用OpenCV可视化识别结果

│ │ ├─44-搭建AISaaS理论：Web框架选型

│ │ ├─45-搭建AISaaS理论：数据库ORM选型

│ │ ├─46-搭建AISaaS理论：10分钟快速开发AISaaS

│ │ ├─47-搭建AISaaS实战：10分钟快速开发AISaaS

│ │ ├─48-交付AISaaS：10分钟快速掌握容器部署

│ │ ├─49-交付AISaaS：部署和测试AISaaS

│ │ ├─50-使?TensorFlow2实现图像数据增强

│ │ ├─51-使?TensorFlow2实现分布式训练

│ │ ├─52-使?TensorFlowHub迁移学习

│ │ ├─53-使?@tf

│ │ ├─54-使?TensorFlowServing部署云端服务

│ │ ├─55-使?TensorFlowLite实现边缘智能

│ │ └─56-结束语

│ ├─34-分布式系统案例课

│ │ ├─03-需求收集和总体架构设计

│ │ ├─04-存储设计

│ │ ├─05-计数服务设计（上）

│ │ ├─06-计数服务设计（下）

│ │ ├─07-查询服务设计

│ │ ├─08-技术栈选型

│ │ ├─09-进一步考量和总结

│ │ ├─10-PMQ2

│ │ ├─11-PMQ2

│ │ ├─12-PMQ2

│ │ ├─13-PMQ2

│ │ ├─14-PMQ3

│ │ ├─15-Kafka的动态重平衡是如何工作的？（上）

│ │ ├─16-Kafka的动态重平衡是如何工作的？（下）

│ │ ├─17-消息队列设计和治理最佳实践

│ │ ├─18-第四章目录和大纲

│ │ ├─19-微服务的四大技术难题是什么？

│ │ ├─20-如何解决微服务的数据一致性分发问题？

│ │ ├─21-如何解决微服务的数据聚合Join问题？

│ │ ├─22-如何解决微服务的分布式事务问题？（上）

│ │ ├─23-如何解决微服务的分布式事务问题？（下）

│ │ ├─24-阿里分布式事务中间件Seata解析

│ │ ├─25-Uber微服务编排引擎Cadence解析

│ │ ├─26-如何理解UberCadence的架构设计？

│ │ ├─27-如何实现遗留系统的解耦拆分？

│ │ ├─28-拍拍贷系统拆分项目案例

│ │ ├─29-CQRS-CDC技术在Netflix的实践

│ │ ├─30-第四章总结

│ │ ├─31-SessionServer项目背景

│ │ ├─32-总体架构设计

│ │ ├─33-如何设计一个高性能基于内存的LRUCache？

│ │ ├─34-如何设计一个高性能大容量持久化的ConcurrentHashmap？

│ │ ├─35-设计评估和总结

│ │ ├─36-SaaS项目healthchecks

│ │ ├─37-SaaS项目healthchecks

│ │ ├─38-如何设计一个轻量级的基于DB的延迟任务队列？

│ │ ├─39-如何设计一把轻量级的锁？

│ │ ├─40-如何设计一个分布式限流系统？

│ │ ├─41-如何设计一个分布式TopK系统实现实时防爬虫？

│ │ ├─42-第七章目标和大纲

│ │ ├─43-为什么说ServiceMesh是微服务的未来(上)

│ │ ├─44-为什么说ServiceMesh是微服务的未来(下)

│ │ ├─45-解析EnvoyProxy(上)

│ │ ├─46-解析EnvoyProxy(下)

│ │ ├─47-Envoy在Lyft的实践

│ │ ├─48-解析Istio

│ │ ├─49-K8sIngress、IstioGateway和APIGateway该如何选择？(上)

│ │ ├─50-K8sIngress、IstioGateway和APIGateway该如何选择？(下)

│ │ ├─51-SpringCloud、K8s和Istio该如何集成？

│ │ ├─52-第八章目标和大纲

│ │ ├─53-拍拍贷案例：大型网站架构是如何演进的？

│ │ ├─54-最小可用架构：MinimumViableArchitecture（上）

│ │ ├─55-最小可用架构：MinimumViableArchitecture（下）

│ │ ├─56-如何构建基于OAuth2-JWT的微服务架构？（上）

│ │ ├─57-如何构建基于OAuth2-JWT的微服务架构？（下）

│ │ ├─58-拍拍贷案例：如何实现数据中心机房的迁移？

│ │ ├─59-携程-Netflix案例：如何实现同城双活和异地多活？

│ │ ├─60-第九章大纲

│ │ ├─61-学习开源项目的6个层次和8种方法（上）

│ │ ├─62-学习开源项目的6个层次和8种方法（中）

│ │ ├─63-学习开源项目的6个层次和8种方法（下）

│ │ ├─64-百万年薪架构师是如何炼成的？

│ │ ├─65-解读一份大厂的研发岗职级体系

│ │ └─66-结课测试&结束语

│ ├─35-Web安全攻防实战

│ │ ├─03-Web安全前端基础：HTML

│ │ ├─04-Web安全前端基础：CSS、JavaScript

│ │ ├─05-探究网站的运作原理：用Python写一个简单的WebApp

│ │ ├─06-Web框架的运作原理：用Django快速搭建一个网站

│ │ ├─07-HTTP协议是怎么工作的？

│ │ ├─08-常见的Web安全漏洞都有哪些？

│ │ ├─09-Web渗透工具入门：BurpSuite、cURL、Postman

│ │ ├─10-Web渗透插件入门：Wappalyzer、HackBar

│ │ ├─100-如何做好用户隐私保护？——开发者视角

│ │ ├─101-如何做好用户隐私保护？——用户体验及产品设计视角

│ │ ├─102-网络钓鱼防范：钓鱼网站、邮件钓鱼的防控

│ │ ├─103-怎样建立安全开发流程（SDL）？

│ │ ├─104-漏洞修补应当遵循怎样的流程？

│ │ ├─105-如何建立安全监控规范？

│ │ ├─106-结束语

│ │ ├─11-文件上传漏洞：漏洞原理&一句话木马

│ │ ├─12-文件上传漏洞初阶：后缀名绕过&原理探究

│ │ ├─13-文件上传漏洞中阶：前端验证绕过、

│ │ ├─14-文件上传漏洞高阶：文件流绕过、字符串截断绕过、文件头检测绕过

│ │ ├─15-文件上传漏洞：初探源码审计

│ │ ├─16-文件上传漏洞：初探Fuzz

│ │ ├─17-Web安全后端基础：数据库的基本概念

│ │ ├─18-Web安全后端基础：极简MySQL入门

│ │ ├─19-SQL注入漏洞的原理及其危害

│ │ ├─20-从协议视角看注入：GET型注入攻击及防御

│ │ ├─21-从协议视角看注入：POST型注入攻击及防御

│ │ ├─22-SQL注入实战：判断SQL注入点&防御方式

│ │ ├─23-宏观视角看注入：5种不同的SQL注入类型

│ │ ├─24-SQL注入实战：利用时间盲注绕过无报错无回显场景

│ │ ├─25-SQL注入实战：隐蔽的HTTP头盲注

│ │ ├─26-SQL注入实战：利用数据库的bug进行报错注入

│ │ ├─27-SQL注入实战：实施报错注入攻击

│ │ ├─28-SQL注入实战：威力巨大的堆叠注入

│ │ ├─29-SQL注入实战：游离在常规分类外的OOB注入

│ │ ├─30-SQL注入实战：浅谈OOB注入原理

│ │ ├─31-SQL注入实战：OOB注入之环境准备

│ │ ├─32-SQL注入实战：OOB注入关键函数解析之loadfile

│ │ ├─33-SQL注入实战：实施OOB注入攻击

│ │ ├─34-SQL注入实战：如何绕过WAF之混淆注入原理

│ │ ├─35-SQL注入实战：如何绕过WAF之union、where、limit过滤绕过

│ │ ├─36-SQL注入实战：如何绕过WAF之groupby、select、单引号、hex、unhex、substr绕过

│ │ ├─37-SQL注入实战：如何绕过WAF之空格、等号、双写、双重编码绕过

│ │ ├─38-SQL注入实战：如何绕过WAF之数据库底层编码注入攻击

│ │ ├─39-SQL注入实战：如何绕过WAF之二次注入攻击

│ │ ├─40-SQL注入实战：激动人心的命令执行

│ │ ├─41-SQL注入实战：webshell类型命令执行与交互

│ │ ├─42-SQL注入实战：UDF类型命令执行与交互

│ │ ├─43-SQL注入实战：玩转Linux权限管理之用户和组

│ │ ├─44-SQL注入实战：玩转Linux权限管理之文件权限

│ │ ├─45-SQL注入实战：自动化注入攻击之了解sqlmap

│ │ ├─46-SQL注入实战：玩转sqlmap之携带cookie

│ │ ├─47-SQL注入实战：玩转sqlmap之通过level设定检测深度

│ │ ├─48-SQL注入实战：玩转sqlmap之读写server文件

│ │ ├─49-SQL注入实战：玩转sqlmap之实战脱库

│ │ ├─50-SQL注入实战：自动化注入攻击之FuzzDB+Burp组合拳

│ │ ├─51-SQL注入实战：欣赏优秀的Web后门之核心功能

│ │ ├─52-SQL注入实战：欣赏优秀的Web后门之免杀

│ │ ├─53-SQL注入实战：面向NoSQL数据库的注入攻击

│ │ ├─54-SQL注入实战：浅谈SQL注入防御方式及原理之预编译

│ │ ├─55-SQL注入实战：浅谈SQL注入防御方式及原理之过滤

│ │ ├─56-加密算法与随机数

│ │ ├─57-Spring框架安全攻击和防御-什么是框架级漏洞

│ │ ├─58-Spring框架安全攻击和防御-CVE-2017-8046利用

│ │ ├─59-Spring框架安全攻击和防御-CVE-2017-8046分析

│ │ ├─60-反射型XSS漏洞原理、案例及防御措施

│ │ ├─61-存储型XSS漏洞原理、案例及防御措施

│ │ ├─62-DOM型XSS漏洞原理、案例及防御措施

│ │ ├─63-伪协议与编码绕过

│ │ ├─64-XSS蠕虫实战案例分析

│ │ ├─65-XSS混淆编码

│ │ ├─66-CSRF跨站请求伪造漏洞原理、攻击演练

│ │ ├─67-同源策略及跨源访问

│ │ ├─68-XSS及CSRF综合利用案例分析：点击劫持

│ │ ├─69-HTML5新标签及相应的安全分析（一）

│ │ ├─70-HTML5新标签及相应的安全分析（二）

│ │ ├─71-XSS之模板注入-初探Node

│ │ ├─72-XSS之模板注入-模板引擎与XSS的关系

│ │ ├─73-XSS之模板注入-经典注入手法

│ │ ├─74-Javascript与RCE（远程代码执行）

│ │ ├─75-BlackHat议题追踪：XSS的危害不够大？-构造攻击链

│ │ ├─76-BlackHat议题追踪：XSS的危害不够大？-CSRF到XSS

│ │ ├─77-BlackHat议题追踪：XSS的危害不够大？-XSS到RCE

│ │ ├─78-SSRF服务端请求伪造

│ │ ├─79-Apache安全专题-配置错误诱发的漏洞

│ │ ├─80-Apache安全专题-CVE-2017-15715

│ │ ├─81-Nginx安全专题-CRLF注入攻击

│ │ ├─82-Nginx安全专题-CVE-2017-7529

│ │ ├─83-Tomcat安全专题

│ │ ├─84-PHP安全专题：了解PHP环境

│ │ ├─85-PHP安全专题：远程（本地）文件包含

│ │ ├─86-PHP安全专题：学习黑魔法函数

│ │ ├─87-PHP安全专题：序列化及反序列化漏洞

│ │ ├─88-PHP安全专题：浅谈PHP安全编码

│ │ ├─89-JavaWeb安全专题：JavaWeb基础

│ │ ├─90-JavaWeb安全专题：浅谈代码审计思路

│ │ ├─91-Node

│ │ ├─92-Node

│ │ ├─93-Node

│ │ ├─94-Node

│ │ ├─95-DDoS之协议层拒绝服务攻击：SYN泛洪、UDP泛洪、ICMP泛洪

│ │ ├─96-DDoS之应用层拒绝服务攻击：Slowloris攻击、HTTPPostDoS

│ │ ├─97-如何做好认证与会话管理？

│ │ ├─98-访问控制：水平权限&垂直权限

│ │ └─99-互联网公司运营安全、业务安全、业务逻辑安全策略规范

│ ├─36-Selenium自动化测试实战

│ │ ├─03-聊聊Web自动化测试：黑盒、白盒、α测试、β测试、冒烟测试、回归测试

│ │ ├─04-Selenium三剑客：WebDriver、IDE、Grid一网打尽

│ │ ├─05-Selenium开发环境搭建

│ │ ├─06-下载安装浏览器驱动：教你解决最麻烦的版本匹配问题

│ │ ├─07-第一个Selenium测试：Selenium测试流程、源码分析

│ │ ├─08-实现元素定位：掌握Selenium八大定位方法

│ │ ├─09-通过打车生活案例，深入剖析WebDriver运行原理

│ │ ├─10-掌握WebDriver核心方法和属性的使用

│ │ ├─11-掌握WebElement核心方法和属性的使用

│ │ ├─12-form表单：熟练掌握form表单操作步骤

│ │ ├─13-掌握checkbox和radiobutton的定位技巧

│ │ ├─14-下拉列表：熟练使用Select类，来实现下拉列表定位

│ │ ├─15-弹框处理：掌握alert、confirm、prompt三种弹出的用法

│ │ ├─16-Selenium三种等待方式：剖析原理、用法和应用场景

│ │ ├─17-Selenium等待条件：掌握17种元素等待条件

│ │ ├─18-掌握鼠标单击、双击、右击，键盘输入、键盘组合键的应用

│ │ ├─19-熟练执行JavaScript的方法和技巧，掌握JavaScript操作滚动条

│ │ ├─20-Selenium屏幕截图：实现屏幕截屏、按照日期时间格式保存图片

│ │ ├─21-掌握frame、iframe定位，熟练frame的切入和切出

│ │ ├─22-下载安装SeleniumIDE：下载安装Chrome、Firefox插件IDE

│ │ ├─23-熟练SeleniumIDE菜单栏、工具类、命令窗口的使用

│ │ ├─24-SeleniumIDE实现录制和回放及脚本导出

│ │ ├─25-项目环境搭建：安装JDK、MySQL、Tomcat和测试系统

│ │ ├─26-需求分析和用例设计：深度挖掘需求，掌握测试用例设计范式

│ │ ├─27-项目架构设计：掌握分层设计思想，合理设计目录和包结构

│ │ ├─28-解决验证码问题-方案一：使用pytesseract和Pillow实现验证码识别

│ │ ├─29-解决验证码问题-方案二：通过第三方AI库识别验证码

│ │ ├─30-实现工具类：设计获得验证码、随机字符串生成、cookie操作工具类

│ │ ├─31-完成用户注册测试用例：解决验证码、等待弹框等复杂内容

│ │ ├─32-完成用户登录测试用例：实现登录成功和失败测试

│ │ ├─33-完成管理员登录测试用例：完成验证码正确和错误测试用例

│ │ ├─34-完成文章分类测试用例：解决测试用例依赖问题

│ │ ├─35-完成添加、删除文章测试用例

│ │ ├─36-unittest简介：测试用例、测试套件、测试运行器、测试加载器

│ │ ├─37-unittest中的方法：掌握各种setup、teardown和断言方法

│ │ ├─38-测试用例、测试套件和测试加载器：掌握加载测试用例的四种方法

│ │ ├─39-使用unittest重构测试用例：掌握使用unittest模块的方法和技巧

│ │ ├─40-为项目添加测试报告：使用第三方模块实现测试报告

│ │ ├─41-pytest框架简介：pytest安装、用例编写规则、执行用例

│ │ ├─42-pytest标记：查找测试策略、标记测试函数

│ │ ├─43-pytest参数化处理：使用参数化装饰器、解析列表、元组、字典等数据

│ │ ├─44-pytestFixture：使用fixture实现用例之间的调用

│ │ ├─45-pytestsetup和teardown

│ │ ├─46-pytestallure生成测试报告

│ │ ├─47-使用pytest重构项目：实现用例依赖、测试报告、数据参数化

│ │ ├─48-logging模块简介：日志的作用、等级和常用函数

│ │ ├─49-logging日志格式输出：日志发生的时间、文件、模块、行号等信息格式输出

│ │ ├─50-logging模块四大组件：Logger、Handler、Formatter、Filter的用法

│ │ ├─51-为项目添加日志：将日志应用到项目

│ │ ├─52-使用csv模块读取CSV文件，使用pytest参数化实现DDT

│ │ ├─53-使用json模块读取json文件，使用pytest参数化实现DDT

│ │ ├─54-使用xlrd模块读取excel文件，使用pytest参数化实现DDT

│ │ ├─55-Selenium读取数据库数据：将数据保存到数据库，实现数据驱动的测试

│ │ ├─56-SeleniumDDT：使用DDT模块实现数据驱动的测试

│ │ ├─57-使用DDT思想重构项目：使用数据库保存数据，将数据驱动思想应用到项目

│ │ ├─58-POM设计模式简介：理解页面-对象-模型设计模式，实现代码的松耦合

│ │ ├─59-设计BasePage类：设计基类，提高项目的代码重用性

│ │ ├─60-设计项目页面对应的PO类：使用POM设计模式设计PO类

│ │ ├─61-设计项目测试用例：将POM设计模式应用到项目

│ │ ├─62-SeleniumGrid下载安装：配置Java运行环境，下载安装SeleniumGrid

│ │ ├─63-Selenium注册node节点

│ │ ├─64-使用Selenium执行远程测试

│ │ ├─65-Jenkins环境搭建：下载安装Jenkins

│ │ ├─66-在Jenkins中运行项目

│ │ ├─67-邮件通知：实现邮件通知功能

│ │ ├─68-定时运行项目，实现真正的自动化测试

│ │ └─69-结课测试&结束语

│ ├─37-Flink核心技术与实战

│ │ ├─03-流处理技术概览

│ │ ├─04-Flink发展历史与应用场景

│ │ ├─05-Flink核心特性

│ │ ├─06-Flink集群架构

│ │ ├─07-Flink集群运行模式

│ │ ├─08-Flink集群资源管理器支持

│ │ ├─09-Standalone原理讲解与实操演示

│ │ ├─10-FlinkOnYarn部署讲解

│ │ ├─11-FlinkOnYarn实操演示

│ │ ├─12-FlinkOnKubernetes部署讲解

│ │ ├─13-FlinkOnKubernetes实操：Session模式

│ │ ├─14-FlinkOnKubernetes实操：Per-job模式

│ │ ├─15-FlinkOnKubernetesNative部署讲解

│ │ ├─16-FlinkOnKubernetesNative实操演示

│ │ ├─17-Flink高可用配置原理讲解

│ │ ├─18-Flink高可用配置实操演示

│ │ ├─19-分布式流处理模型

│ │ ├─20-DataStreamAPI实践原理

│ │ ├─21-Flink时间概念

│ │ ├─22-Watermark实践原理

│ │ ├─23-Watermark与Window的关系

│ │ ├─24-WatermarkGenerator

│ │ ├─25-Windows窗口计算

│ │ ├─26-WindowAssigner

│ │ ├─27-WindowTrigger

│ │ ├─28-WindowEvictors

│ │ ├─29-WindowFunction

│ │ ├─30-Windows多流合并

│ │ ├─31-ProcessFunction应用

│ │ ├─32-SideOutput旁路输出

│ │ ├─33-AsynchronousI-O异步操作

│ │ ├─34-Pipeline与StreamGraph转换

│ │ ├─35-Flink类型系统

│ │ ├─36-自定义SourceFunction

│ │ ├─37-项目实战：基于DataStreamAPI实现PV，UV统计

│ │ ├─38-有状态计算概念

│ │ ├─39-状态类型及应用

│ │ ├─40-KeyedState介绍与使用

│ │ ├─41-OperatorState介绍与使用

│ │ ├─42-BroadcastState介绍与使用

│ │ ├─43-Checkpoint实现原理

│ │ ├─44-Savepoint与Checkpoint

│ │ ├─45-StateBackends状态管理器

│ │ ├─46-StateSchemaEvolution

│ │ ├─47-State序列化与反序列化

│ │ ├─48-QueryableState介绍与使用

│ │ ├─49｜项目实战：实时交易反欺诈项目介绍

│ │ ├─50｜项目实战：实时交易反欺诈项目演示

│ │ ├─51｜FlinkTableAPI-SQL介绍与使用

│ │ ├─52｜TableAPI-SQL核心概念

│ │ ├─53｜DataStream&DataSet与Table相互转换

│ │ ├─54｜TableConnector介绍与使用

│ │ ├─55｜QueryingDynamicTables

│ │ ├─56｜TimeStamp与Watermark时间属性定义

│ │ ├─57｜QueryWithTemporalCondition

│ │ ├─58｜JoinWithDynamicTable

│ │ ├─59｜JoinWithTemporalFunction

│ │ ├─60｜JoinWithTemporalTables

│ │ ├─61｜Catalog原理与使用

│ │ ├─62｜ApacheHive集成

│ │ ├─63｜SQLClient介绍与使用

│ │ ├─64｜FlinkSQLTable数据类型

│ │ ├─65｜自定义Function

│ │ ├─66｜TableConnector使用

│ │ ├─67｜自定义Connector

│ │ ├─68｜newtablesource&tablesinkapi

│ │ ├─69｜项目实战：基于FlinkSQL实现Top10商品统计

│ │ ├─70｜Runtime整体架构

│ │ ├─71｜FlinkClient实现原理

│ │ ├─72｜ResourceManager资源管理

│ │ ├─73｜Dispatcher任务分发器

│ │ ├─74｜JobGraph提交与运行（上）

│ │ ├─75｜JobGraph提交与运行（下）

│ │ ├─76｜Task执行与调度

│ │ ├─77｜Task重启和容错策略

│ │ ├─78｜集群组件RPC通信机制

│ │ ├─79｜NetworkStatck实现原理

│ │ ├─80｜Flink内存管理

│ │ ├─81｜Metric指标分类与采集

│ │ ├─82｜FlinkRESTAPI介绍与使用

│ │ ├─83｜Checkpoint监控与调优

│ │ ├─84｜反压监控与原理

│ │ ├─85｜Flink内存配置与调优

│ │ ├─86｜PyFlink实践与应用

│ │ ├─87｜Flink复杂事件处理：Complexeventprocess(1)

│ │ ├─87｜Flink复杂事件处理：Complexeventprocess

│ │ ├─88｜Alink机器学习框架介绍与使用

│ │ ├─89｜StatefulFunction介绍与使用

│ │ ├─90｜实时推荐系统项目设计与实现

│ │ └─91｜结束语

│ ├─38-张汉东的Rust实战课

│ │ ├─03-Rust语言学习观

│ │ ├─04-Rust语言概览

│ │ ├─05-语法面面观：词法结构

│ │ ├─06-语法面面观：面向表达式（上）

│ │ ├─07-语法面面观：面向表达式（中）

│ │ ├─08-语法面面观：面向表达式（下）

│ │ ├─09-语法面面观：数据类型（上）

│ │ ├─10-语法面面观：数据类型（下）

│ │ ├─100-Rust异步编程之编写异步echo服务(下)

│ │ ├─101-Rust异步编程之深入理解异步Task模型

│ │ ├─102-Rust异步编程之Waker实现

│ │ ├─103-Rust异步编程之Futures库源码导读（一）

│ │ ├─104-Rust异步编程之Futures库源码导读（二）

│ │ ├─105-Rust异步编程之Futures库源码导读（三）

│ │ ├─106-Rust异步编程之Futures库源码导读（四）

│ │ ├─107-Rust异步编程之async-await语法背后

│ │ ├─108-Rust异步编程之生成器（上）

│ │ ├─109-Rust异步编程之生成器(下)

│ │ ├─11-语法面面观：函数与闭包（上）

│ │ ├─110-Rust异步编程之Pin与Unpin(一)

│ │ ├─111-Rust异步编程之Pin与Unpin(二)

│ │ ├─112-Rust异步编程之Pin与Unpin(三）

│ │ ├─113-Rust异步编程之Pin与Unpin（四）

│ │ ├─114-Rust异步编程之no-std异步生态介绍

│ │ ├─115-Rust异步编程之实现异步缓存（上）

│ │ ├─116-Rust异步编程之实现异步缓存（下）

│ │ ├─117-Rust异步编程之异步运行时生态介绍

│ │ ├─118-Rust异步编程之smol运行时（一）

│ │ ├─119-Rust异步编程之smol运行时（二）

│ │ ├─12-语法面面观：函数与闭包（中）

│ │ ├─120-Rust异步编程之smol运行时（三）

│ │ ├─121-Rust异步编程之smol运行时（四）

│ │ ├─122-Rust异步编程之smol运行时（五）

│ │ ├─123-Rust异步编程之smol运行时（六）

│ │ ├─124-Rust异步编程之smol运行时（七）

│ │ ├─125-Rust异步编程之smol运行时（八）

│ │ ├─126-Rust异步编程之smol运行时（九）

│ │ ├─127-Rust异步编程之smol运行时（十）

│ │ ├─128-Rust异步编程之async-std运行时（一）

│ │ ├─129-Rust异步编程之async-std运行时（二）

│ │ ├─13-语法面面观：函数与闭包（下）

│ │ ├─130-Rust异步编程之tokio运行时（一）

│ │ ├─131-Rust异步编程之tokio运行时（二）

│ │ ├─132-Rust异步编程之tokio运行时（三）

│ │ ├─133-Rust异步编程之tokio运行时（四）

│ │ ├─134-Rust异步编程之tokio运行时（五）

│ │ ├─135-Rust异步编程之tokio运行时（六）

│ │ ├─136-Rust异步编程之tokio运行时（七）

│ │ ├─137-Rust异步编程之tokio运行时（八）

│ │ ├─138-Rust异步编程之tokio运行时（九）

│ │ ├─139-Rust异步编程之tokio运行时（十）

│ │ ├─14-语法面面观：模式匹配

│ │ ├─140-Rust异步Web框架开篇

│ │ ├─141-Rust异步Web框架之Rocket（一）

│ │ ├─142-Rust异步Web框架之Rocket（二）

│ │ ├─143-Rust异步Web框架之Rocket（三）

│ │ ├─144-Rust异步Web框架之tide

│ │ ├─145-Rust异步Web框架之actix-web（一）

│ │ ├─146-Rust异步Web框架之actix-web（二）

│ │ ├─147-Rust异步Web框架之gotham-and-thruster

│ │ ├─148-Rust异步Web框架之tower（一）

│ │ ├─149-Rust异步Web框架之tower（二）

│ │ ├─15-语法面面观：智能指针（上）

│ │ ├─150-Rust异步Web框架之hyper（一）

│ │ ├─151-Rust异步Web框架之hyper（二）

│ │ ├─152-Rust异步Web框架之hyper（三）

│ │ ├─153-Rust异步Web框架之warp

│ │ ├─154-Web框架实战之http库介绍

│ │ ├─155-Web框架实战之了解hyper-towerhttp-http-body之间的层次关系

│ │ ├─156-Web框架实战之创建初始项目

│ │ ├─157-Web框架实战之设计框架接口

│ │ ├─158-Web框架实战之实现路由结构

│ │ ├─159-Web框架实战之实现路由结构（二）

│ │ ├─16-语法面面观：智能指针（下）

│ │ ├─160-Web框架实战之实现路由结构（三）

│ │ ├─161-Web框架实战之实现路由结构（四）

│ │ ├─162-Web框架实战之实现路由结构（五）

│ │ ├─163-Web框架实战之实现Handler（一）

│ │ ├─164-Web框架实战之实现Handler（二）

│ │ ├─165-Web框架实战之实现Handler（三）

│ │ ├─166-Web框架实战之实现Handler（四）

│ │ ├─167-Web框架实战之添加tracing打印

│ │ ├─168-Web框架实战之实现提取器（一）

│ │ ├─169-Web框架实战之实现提取器（二）

│ │ ├─17-语法面面观：字符与字符串（上）

│ │ ├─170-Web框架实战之实现提取器（三）

│ │ ├─171-Web框架实战之实现提取器和中间件（四）

│ │ ├─172-Web框架实战之错误处理支持

│ │ ├─173-课程完结回顾

│ │ ├─18-语法面面观：字符与字符串（下）

│ │ ├─19-语法面面观：集合容器（上）

│ │ ├─20-语法面面观：集合容器（下）

│ │ ├─21-语法面面观：迭代器（上）

│ │ ├─22-语法面面观：迭代器（下）

│ │ ├─23-Rust语法面面观：模块

│ │ ├─24-Rust语法面面观：Cargo包管理器（上）

│ │ ├─25-Rust语法面面观：Cargo包管理器（下）

│ │ ├─26-语法面面观：实际项目的组织结构（上）

│ │ ├─27-语法面面观：实际项目的组织结构（下）

│ │ ├─28-语法面面观：定义自己的Crate（上）

│ │ ├─29-语法面面观：定义自己的Crate（中）

│ │ ├─30-语法面面观：定义自己的Crate（下）

│ │ ├─31-作业&第二章预告

│ │ ├─32-本章内容介绍：Rust语言架构

│ │ ├─33-所有权：内存管理基础知识

│ │ ├─34-所有权：安全管理之内存安全

│ │ ├─35-所有权：Copy语义和Copytrait

│ │ ├─36-所有权：深入理解Copy行为

│ │ ├─37-所有权：深入理解Move语义

│ │ ├─38-所有权：Move与析构

│ │ ├─39-借用检查：完全理解Scope和NLL

│ │ ├─40-借用检查：深入理解生命周期和生命周期参数

│ │ ├─41-借用检查：深入理解生命周期参数Earlybound

│ │ ├─42-借用检查：深入理解生命周期参数Tvs&T

│ │ ├─43-借用检查：深入理解生命周期参数：trait对象的生命周期参数

│ │ ├─44-借用检查：深入理解生命周期参数：高阶生命周期（上）

│ │ ├─45-借用检查：深入理解生命周期参数：高阶生命周期（中）

│ │ ├─46-借用检查：深入理解生命周期参数：高阶生命周期（下）

│ │ ├─47-线程与并发：理解线程与并发

│ │ ├─48-线程与并发：线程间安全共享数据

│ │ ├─49-线程与并发：构建「无悔」并发系统（一）

│ │ ├─50-线程与并发：构建「无悔」并发系统（二）

│ │ ├─51-线程与并发：构建「无悔」并发系统（三）

│ │ ├─52-线程与并发：构建「无悔」并发系统（四）

│ │ ├─53-线程与并发：无锁并发（上）

│ │ ├─54-线程与并发：无锁并发（中）

│ │ ├─55-线程与并发：无锁并发（下）

│ │ ├─56-trait与泛型：trait静态分发

│ │ ├─57-trait与泛型：认识trait对象

│ │ ├─58-trait与泛型：泛型和trait实现模板方法

│ │ ├─59-trait与泛型：trait对象本质

│ │ ├─60-trait与泛型：对象安全本质

│ │ ├─61-trait与泛型：利用Enum代替trait对象

│ │ ├─62-trait与泛型：trait覆盖实现的一个解决方案

│ │ ├─63-trait与泛型：trait对象与Sized

│ │ ├─64-trait与泛型：trait对象与BoxSelf

│ │ ├─65-编程范式：Rust语言编程范式讨论（上）

│ │ ├─66-编程范式：Rust语言编程范式讨论（下）

│ │ ├─67-Rust错误处理概要

│ │ ├─68-Rust错误处理：Option

│ │ ├─69-Rust错误处理：Result（上）

│ │ ├─70-Rust错误处理：Result（下）

│ │ ├─71-Rust错误处理：try

│ │ ├─72-Rust错误处理：Panic

│ │ ├─73-Rust元编程之反射

│ │ ├─74-Rust元编程之反射的两种应用思路

│ │ ├─75-Rust元编程之编译过程与宏展开概述

│ │ ├─76-Rust元编程之声明宏上

│ │ ├─77-Rust元编程之声明宏下

│ │ ├─78-Rust元编程之过程宏三件套介绍

│ │ ├─79-Rust元编程之过程宏之Bang宏实现原理

│ │ ├─80-Rust元编程之过程宏-使用配置文件动态生成代码

│ │ ├─81-Rust元编程之过程宏Derive宏案例

│ │ ├─82-Rust元编程之过程宏属性宏

│ │ ├─83-客观理解UnsafeRust

│ │ ├─84-UnsafeRust之安全抽象

│ │ ├─85-UnsafeRust安全抽象之Drop检查

│ │ ├─86-UnsafeRust安全抽象之型变

│ │ ├─87-UnsafeRust之其他

│ │ ├─88-Rust异步编程之IO模型

│ │ ├─89-Rust异步编程之epoll和iouring

│ │ ├─90-Rust异步编程之事件驱动编程模型

│ │ ├─91-Rust异步编程之epoll代码实践

│ │ ├─92-Rust异步编程之Reactor代码实践

│ │ ├─93-Rust异步编程之MiniMio代码实践

│ │ ├─94-Rust异步编程之Mio代码实践(上）

│ │ ├─95-Rust异步编程之Mio代码实践(下）

│ │ ├─96-Rust异步编程之异步编程模型概要

│ │ ├─97-Rust异步编程之Future和Futures-rs介绍

│ │ ├─98-Rust异步编程之编写异步echo服务(上)

│ │ ├─99-Rust异步编程之编写异步echo服务(中)

│ │ └─学习方法推荐与课程组织逻辑

│ ├─39-Django快速开发实战

│ │ ├─03-初识Django：Django适合做什么？

│ │ ├─04-用2个命令创建一个包含用户管理功能的后台

│ │ ├─05-开始Django之旅：10分钟如何创建一个可以管理职位的后台

│ │ ├─06-产品体验优化：快速迭代完善应用

│ │ ├─07-添加自定义页面：让匿名用户可以浏览职位列表页

│ │ ├─08-添加自定义页面：让匿名用户可以查看职位详情

│ │ ├─09-开始一个正式的产品：产品背景、迭代思维与MVP产品规划

│ │ ├─10-唯快不破：在产品中使用产品迭代思维

│ │ ├─11-数据建模&企业级数据库设计原则

│ │ ├─12-创建应用和模型，分组展示页面内容

│ │ ├─13-产品新需求：如何批量从Excel文件导入候选人数据（命令行工具）

│ │ ├─14-产品体验优化：候选人列表筛选和查询

│ │ ├─15-省去单独的账号管理工作：企业域账号集成

│ │ ├─16-批量设置面试官：面试官的导入、授权

│ │ ├─17-产品新需求：如何导出候选人的数据到CSV（增加自定义的数据操作菜单）

│ │ ├─18-如何记录日志方便排查问题

│ │ ├─19-生产环境的配置如何管理更安全：生产环境与开发环境配置分离

│ │ ├─20-产品细节完善

│ │ ├─21-定制更美观的主题

│ │ ├─22-定制面试官权限

│ │ ├─23-系统报错功能：钉钉群消息集成&通知一面面试官

│ │ ├─24-允许候选人注册登录-集成Registration

│ │ ├─25-候选人简历存储：创建简历Model

│ │ ├─26-让候选人可以在线投递简历

│ │ ├─27-使用Bootstrap来定制页面样式

│ │ ├─28-简历评估&安排一面面试官

│ │ ├─29-定制列表字段，查看简历详情

│ │ ├─30-遗留系统集成：为已有系统数据库生成管理后台

│ │ ├─31-Django的中间件（Middleware）

│ │ ├─32-创建请求日志、性能日志记录中间件

│ │ ├─33-在Django中支持多语言

│ │ ├─34-错误和异常日志上报：Sentry集成

│ │ ├─35-错误和异常日志上报：捕获异常上报到Sentry并发送钉钉群通知

│ │ ├─36-Django安全防护：防止XSS跨站脚本攻击

│ │ ├─37-Django安全防护：CSRF跨站请求伪造和SQL注入攻击

│ │ ├─38-DjangoRestFramework开放API

│ │ ├─39-在Django中使用缓存&Redis的使用

│ │ ├─40-Django与Celery集成：Celery的使用

│ │ ├─41-Django与Celery集成：异步任务

│ │ ├─42-Django与Celery集成：定时任务

│ │ ├─43-文件和图片上传功能

│ │ ├─44-实践中的问题：多数据库路由

│ │ ├─45-Django之美：3行代码支持大数据量的关联外键(autocompletefields)

│ │ ├─46-Django之美：20行代码实现只读站点ReadOnlyAdmin

│ │ ├─47-Django之美：10行代码自动注册所有Model到Admin管理后台

│ │ ├─48-Django之美：Signals信号及其使用场景

│ │ ├─49-Django之美：优雅的架构设计-CSR架构总结之Celery

│ │ ├─50-Django之美：优雅的架构设计-CSR架构总结之Sentry&DjangoRestFramework

│ │ ├─51-Django之美：Django的常用插件

│ │ ├─52-生产环境要注意哪些事项：生产环境的应用部署

│ │ ├─53-应用水平扩展：使用负载均衡

│ │ ├─54-让网站访问更快：使用CDN加速

│ │ ├─55-让故障在第一时间被感知到：接入监控告警

│ │ ├─56-生产环境中的安全：生产环境的安全设计

│ │ ├─57-生产环境中的安全：应用安全

│ │ ├─58-生产环境中的安全：架构安全

│ │ ├─59-生产环境中的安全：数据安全

│ │ ├─60-生产环境中的安全：密码安全与业务安全

│ │ ├─61-云环境中的部署：Docker容器的基础用法

│ │ ├─62-云环境中的部署：如何像分发集装箱一样发布应用

│ │ ├─63-云环境中的部署：开发环境的容器化&构建小镜像

│ │ ├─64-云环境中的部署：什么时候需要容器编排

│ │ ├─65-云环境中的部署：阿里云上搭建Kubernetes集群

│ │ ├─66-云环境中的部署：管理监控容器中的Django应用

│ │ ├─67-云环境中的部署：应用日志收集与查询

│ │ ├─68-云环境中的持续集成：CI-CD的工作流程

│ │ ├─69-云环境中的持续集成：CI-CD的基本使用

│ │ ├─70-快速迭代的价值与挑战

│ │ ├─71-使用OOPD方法识别产品核心功能

│ │ ├─72-如何做技术方案设计与工作拆解

│ │ ├─73-如何保证交付质量和持续迭代

│ │ ├─74-如何更高效地寻求帮助？

│ │ ├─75-一名Hacker的成长之路

│ │ └─76-结束语

│ ├─4-React实战进阶45讲

│ │ ├─01-课程介绍

│ │ ├─02-React出现的历史背景及特性介绍

│ │ ├─03-以组件方式考虑UI的构建

│ │ ├─04-JSX的本质-不是模板引擎，而是语法糖

│ │ ├─05-React组件的生命周期及其使用场景

│ │ ├─06-理解VirtualDOM及key属性的作用

│ │ ├─07-组件设计模式-高阶组件和函数作为子组件

│ │ ├─08-理解新的ContextAPI及其使用场景

│ │ ├─09-使用脚手架工具创建React项目

│ │ ├─10-打包和部署

│ │ ├─11-Redux（1）-前端为何需要状态管理库

│ │ ├─12-Redux（2）-深入理解Store、Action、Reducer

│ │ ├─13-Redux（3）-在React中使用Redux

│ │ ├─14-Redux（4）-理解异步Action、Redux中间件

│ │ ├─15-Redux（5）-如何组织Action和Reducer

│ │ ├─16-Redux（6）-理解不可变数据（Immutability）

│ │ ├─17-ReactRouter（1）：路由不只是页面切换，更是代码组织方式

│ │ ├─18-ReactRouter（2）：参数定义，嵌套路由的使用场景

│ │ ├─19-UI组件库对比和介绍：Ant

│ │ ├─20-使用Next

│ │ ├─21-使用Jest、Enzyme等工具进行单元测试

│ │ ├─22-常用开发调试工具：ESLint、Prettier、ReactDevTool、ReduxDevTool

│ │ ├─23-前端项目的理想架构：可维护、可扩展、可测试、易开发、易建构

│ │ ├─24-拆分复杂度（1）：按领域模型（feature）组织代码，降低耦合度

│ │ ├─25-拆分复杂度（2）：如何组织component、action和reducer

│ │ ├─26-拆分复杂度（3）：如何组织ReactRouter的路由配置

│ │ ├─27-使用Rekit（1）：创建项目，代码生成和重构

│ │ ├─28-使用Rekit（2）：遵循最佳实践，保持代码一致性

│ │ ├─29-使用ReactRouter管理登录和授权

│ │ ├─30-实现表单（1）：初始数据，提交和跳转

│ │ ├─31-实现表单（2）：错误处理，动态表单元素，内容动态加载

│ │ ├─32-列表页（1）：搜索，数据缓存和分页

│ │ ├─33-列表页（2）：缓存更新，加载状态，错误处理

│ │ ├─34-页面数据需要来源多个请求的处理

│ │ ├─35-内容页的加载与缓存

│ │ ├─36-基于ReactRouter实现分步操作

│ │ ├─37-常见页面布局的实现

│ │ ├─38-使用ReactPortals实现对话框，使用antd对话框

│ │ ├─39-集成第三方JS库：以d3

│ │ ├─40-基于路由实现菜单导航

│ │ ├─41-React中拖放的实现

│ │ ├─42-性能永远是第一需求：时刻考虑性能问题

│ │ ├─43-网络性能优化：自动化按需加载

│ │ ├─44-使用Reselect避免重复计算

│ │ ├─45-下一代React：异步渲染

│ │ └─46-使用ChromeDevTool进行性能调优&结课测试

│ ├─40-小马哥讲SpringAOP编程思想

│ │ ├─03-知识储备：基础、基础，还是基础！

│ │ ├─04-AOP引入：OOP存在哪些局限性？

│ │ ├─05-AOP常见使用场景

│ │ ├─06-AOP概念：Aspect、JoinPoint和Advice等术语应该如何理解？

│ │ ├─07-JavaAOP设计模式：代理、判断和拦截器模式

│ │ ├─08-JavaAOP代理模式（Proxy）：Java静态代理和动态代理的区别是什么？

│ │ ├─09-JavaAOP判断模式（Predicate）：如何筛选JoinPoint？

│ │ ├─10-JavaAOP拦截器模式（Interceptor）：拦截执行分别代表什么？

│ │ ├─100-代理模式（Proxy）实现

│ │ ├─101-模板方法模式（TemplateMethod）实现

│ │ ├─102-责任链模式（ChainofResponsibility）实现

│ │ ├─103-观察者模式（Observer）实现

│ │ ├─104-策略模式（Strategy）实现

│ │ ├─105-命令模式（Command）实现

│ │ ├─106-状态模式（State）实现

│ │ ├─107-面试题精选

│ │ ├─108-SpringAOP在Spring事件（Events）

│ │ ├─109-SpringAOP在Spring事务（Transactions）理论基础

│ │ ├─11-SpringAOP功能概述：核心特性、编程模型和使用限制

│ │ ├─110-SpringAOP在Spring事务（Transactions）源码分析

│ │ ├─111-SpringAOP在Spring缓存（Caching）

│ │ ├─112-SpringAOP在Spring本地调度（Scheduling）

│ │ ├─113-面试题精选

│ │ ├─114-结束语

│ │ ├─12-SpringAOP编程模型：注解驱动、XML配置驱动和底层API

│ │ ├─13-SpringAOP设计目标：SpringAOP与AOP框架之间的关系是竞争还是互补？

│ │ ├─14-SpringAOPAdvice类型：SpringAOP丰富了哪些AOPAdvice呢？

│ │ ├─15-SpringAOP代理实现：为什么SpringFramework选择三种不同AOP实现？

│ │ ├─16-JDK动态代理：为什么Proxy

│ │ ├─17-CGLIB动态代理：为什么Java动态代理无法满足AOP的需要？

│ │ ├─18-AspectJ代理代理：为什么Spring推荐AspectJ注解？

│ │ ├─19-AspectJ基础：Aspect、JoinPoints、Pointcuts和Advice语法和特性

│ │ ├─20-AspectJ注解驱动：注解能完全替代AspectJ语言吗？

│ │ ├─21-面试题精选

│ │ ├─22-Spring核心基础：《小马哥讲Spring核心编程思想》还记得多少？

│ │ ├─23-@AspectJ注解驱动

│ │ ├─24-编程方式创建@AspectJ代理

│ │ ├─25-XML配置驱动-创建AOP代理

│ │ ├─26-标准代理工厂API-ProxyFactory

│ │ ├─27-@AspectJPointcut指令与表达式：为什么Spring只能有限支持？

│ │ ├─28-XML配置Pointcut

│ │ ├─29-API实现Pointcut

│ │ ├─30-@AspectJ拦截动作：@Around与@Pointcut有区别吗？

│ │ ├─31-XML配置AroundAdvice

│ │ ├─32-API实现AroundAdvice

│ │ ├─33-@AspectJ前置动作：@Before与@Around谁优先级执行？

│ │ ├─34-XML配置BeforeAdvice

│ │ ├─35-API实现BeforeAdvice

│ │ ├─36-@AspectJ后置动作-三种AfterAdvice之间的关系？

│ │ ├─37-XML配置三种AfterAdvice

│ │ ├─38-API实现三种AfterAdvice

│ │ ├─39-自动动态代理

│ │ ├─40-替换TargetSource

│ │ ├─42-SpringAOPAPI整体设计

│ │ ├─43-接入点接口-Joinpoint

│ │ ├─44-Joinpoint条件接口-Pointcut

│ │ ├─45-Pointcut操作-ComposablePointcut

│ │ ├─46-Pointcut便利实现

│ │ ├─47-PointcutAspectJ实现-AspectJExpressionPointcut

│ │ ├─48-Joinpoint执行动作接口-Advice

│ │ ├─49-JoinpointBeforeAdvice标准实现

│ │ ├─50-JoinpointBeforeAdviceAspectJ实现

│ │ ├─51-JoinpointAfterAdvice标准实现

│ │ ├─52-JoinpointAfterAdviceAspectJ实现

│ │ ├─53-Advice容器接口-Advisor

│ │ ├─54-Pointcut与Advice连接器-PointcutAdvisor

│ │ ├─55-Introduction与Advice连接器-IntroductionAdvisor

│ │ ├─56-Advisor的Interceptor适配器-AdvisorAdapter

│ │ ├─57-AdvisorAdapter实现

│ │ ├─58-AOP代理接口-AopProxy

│ │ ├─59-AopProxy工厂接口与实现

│ │ ├─60-JDKAopProxy实现-JdkDynamicAopProxy

│ │ ├─61-CGLIBAopProxy实现-CglibAopProxy

│ │ ├─62-AopProxyFactory配置管理器-AdvisedSupport

│ │ ├─63-Advisor链工厂接口与实现-AdvisorChainFactory

│ │ ├─64-目标对象来源接口与实现-TargetSource

│ │ ├─65-代理对象创建基础类-ProxyCreatorSupport

│ │ ├─66-AdvisedSupport事件监听器-AdvisedSupportListener

│ │ ├─67-ProxyCreatorSupport标准实现-ProxyFactory

│ │ ├─68-ProxyCreatorSupportIoC容器实现-ProxyFactoryBean

│ │ ├─69-ProxyCreatorSupportAspectJ实现-AspectJProxyFactory

│ │ ├─70-IoC容器自动代理抽象-AbstractAutoProxyCreator

│ │ ├─71-IoC容器自动代理标准实现

│ │ ├─72-IoC容器自动代理AspectJ实现-AspectJAwareAdvisorAutoProxyCreator

│ │ ├─73-AOPInfrastructureBean接口-AopInfrastructureBean

│ │ ├─74-AOP上下文辅助类-AopContext

│ │ ├─75-代理工厂工具类-AopProxyUtils

│ │ ├─76-AOP工具类-AopUtils

│ │ ├─77-AspectJEnable模块驱动实现-@EnableAspectJAutoProxy

│ │ ├─78-AspectJXML配置驱动实现-aop-aspectj-autoproxy

│ │ ├─79-AOP配置Schema-based实现-aop-config

│ │ ├─80-AspectSchema-based实现-aop-aspect

│ │ ├─81-PointcutSchema-based实现-aop-pointcut

│ │ ├─82-AroundAdviceSchema-based实现-aop-around

│ │ ├─83-BeforeAdviceSchema-based实现-aop-before

│ │ ├─84-AfterAdviceSchema-based实现-aop-after

│ │ ├─85-AfterReturningAdviceSchema-based实现-aop-after-returning

│ │ ├─86-AfterThrowingAdviceSchema-based实现-aop-after-throwing

│ │ ├─87-AdviserSchema-based实现-aop-advisor

│ │ ├─88-IntroductionSchema-based实现-aop-declare-parents

│ │ ├─89-作用域代理Schema-based实现-aop-scoped-proxy

│ │ ├─90-面试题精选

│ │ ├─91-抽象工厂模式（Abstractfactory）实现

│ │ ├─92-构建器模式（Builder）实现

│ │ ├─93-工厂方法模式（Factorymethod）实现

│ │ ├─94-原型模式（Prototype）实现

│ │ ├─95-单例模式（Singleton）实现

│ │ ├─96-适配器模式（Adapter）实现

│ │ ├─97-组合模式（Composite）实现

│ │ ├─98-装饰器模式（Decorator）实现

│ │ └─99-享元模式（Flyweight）实现

│ ├─41-爆款文案修炼手册

│ │ ├─01-关于这门课程：爆款文案的6项核心技能是什么？

│ │ ├─02-商人还是艺人？职业文案的三观

│ │ ├─03-月薪3万的文案，哪些是必备的独门技能？

│ │ ├─04-5条路径，爆款标题不求人

│ │ ├─05-5个标准，起个响亮好名字

│ │ ├─06-6重境界，轻松写出广告语

│ │ ├─07-文字传播力：案例揭秘

│ │ ├─08-4W原则：如何寻找你的沟通指南针？

│ │ ├─09-WHY：如何瞄准文案的传播目标？

│ │ ├─10-WHO：如何圈定文案的接收人群？

│ │ ├─11-WHAT：如何用文案诠释产品的卖点？

│ │ ├─12-HOW：如何设计文案的沟通语感？

│ │ ├─13-向经典致敬：为什么说现在的刷屏级创意，都是它们的二手货？

│ │ ├─14-哪些广告，只用文案就够了？

│ │ ├─15-哪些广告，不用文案也可以？

│ │ ├─16-容易得奖的创意，都在用这6大模板（上）

│ │ ├─17-容易得奖的创意，都在用这6大模板（下）

│ │ ├─18-阅读心理学：如何打造文案的黄金结构？

│ │ ├─19-克服冷脑：如何开始你的第一句？

│ │ ├─20-5个结尾技巧，精彩不重样

│ │ ├─21-8种方法，让长文案更好读

│ │ ├─22-变废为宝：不放过任何边角料

│ │ ├─23-刷牙测试法：如何修订你的文案

│ │ ├─24-如何选择字体，让阅读成为悦读？

│ │ ├─25-如何编排版式，建立视觉流通的秩序？

│ │ ├─26-如何运用图片，让读者的眼睛乖乖听话？

│ │ ├─27-如何制造文与图的化学反应？

│ │ ├─28-文稿管理：公司没空教你的4个基本动作

│ │ ├─29-创意，是个什么玩意？

│ │ ├─30-5步秘笈，掌握创意诞生的规律

│ │ ├─31-3种动脑游戏，学会“多快好省”

│ │ ├─32-迷宫理论：创意的评判法则

│ │ └─33-如何找到最难的核心创意，并延展成系列广告

│ ├─42-如何讲好一堂课

│ │ ├─01-以学生为中心的课程设计底层逻辑

│ │ ├─02-如何准备课程内容与素材

│ │ ├─03-如何设计课程结构与逻辑

│ │ ├─04-如何包装课程形式与呈现

│ │ ├─05-还原一个真实的课堂：教学七步法

│ │ ├─06-教学工作的基本环节与优秀课堂的标准

│ │ ├─07-教学与备课进阶过程：七步迭代法打磨课程

│ │ ├─08-如何设计课程亮点与互动：锁定学生的注意力

│ │ └─课程介绍

│ ├─43-HarmonyOS快速入门与实战

│ │ ├─01｜如何快速上手HarmonyOS实践？

│ │ ├─02｜宝宝巴士：HarmonyOS如何让亲子互动更有趣？

│ │ ├─03｜宝宝巴士：全场景分布式的亲子乐园是怎么实现的？

│ │ ├─04｜如何用Cocos引擎开启你HarmonyOS游戏之旅？

│ │ ├─05｜在线教育和小游戏在HarmonyOS上有什么解决方案？

│ │ ├─06｜HarmonyOS是怎么让多设备融合成一个“超级终端”的？

│ │ ├─07｜如何在HarmonyOS上做在线教育和游戏开发？

│ │ ├─08｜商家直播：如何实现互动跨端迁移流转？

│ │ └─09｜商家直播：如何实现多设备协同的开播方案？

│ ├─44-云计算必修小课

│ │ ├─01｜拨云见日——云上架构一点儿也不神秘

│ │ ├─02｜飞云掣电——澎湃算力的云中服务器

│ │ ├─03｜青云万里——10分钟带你了解Serverless平台

│ │ ├─05｜风轻云淡——如何用好对象存储（下）？

│ │ ├─06｜云净天空——谈云中负载均衡器（上）

│ │ ├─07｜云净天空——谈云中负载均衡器（下）

│ │ ├─08｜云合景从——弹性扩展，永无止境的伸缩

│ │ ├─09｜风虎云龙——云端存储十大技巧

│ │ └─10｜行云流水——如何选择合适的方式迁移上云？

│ ├─45-零基础学Python（2022版）【更新中】

│ │ ├─01｜如何配置Python开发环境？

│ │ ├─02-常用IDE：如何提高开发效率？

│ │ ├─03-如何站在官方文档的肩膀上自己“造轮子”？

│ │ ├─04-怎样运行你的第一行代码？

│ │ ├─05-怎样使用Gitee管理你的代码？

│ │ ├─06-学习编程有问题？去这里找答案！

│ │ ├─07｜跨越门槛：Python开发环境总结及实现原理

│ │ ├─08-修炼基本功：浅析输入输出

│ │ ├─09-变量：如何让计算机临时存储数据？

│ │ ├─10｜字符串（上）：Python是如何处理单词的？

│ │ ├─11｜字符串（下）：Python是如何处理单词的？

│ │ ├─12｜存储数字应该采用哪种数据类型？

│ │ ├─13｜何时使用数，何时使用字符串？

│ │ ├─14｜注释：如何写程序的说明书？

│ │ ├─15｜小试牛刀：如何制作简单计算器？

│ │ ├─16｜变量命名规范：如何编写优雅的程序？

│ │ ├─17｜告别新手村：Python编程基础知识

│ │ ├─18｜内置数据类型包括哪几种？

│ │ ├─19｜列表如何处理同类数据？

│ │ ├─20｜常见常新：列表的常见操作

│ │ ├─21｜元组：如何处理一次性数据？

│ │ ├─22｜常见常新：集合的常见操作

│ │ ├─23｜字典：如何处理映射类型的数据？

│ │ ├─24｜常见常新：字典的常见操作（上）

│ │ ├─25｜常见常新：字典的常见操作（下）

│ │ ├─26｜小试牛刀：如何利用类型转换实现手机通讯录？（上）

│ │ ├─27｜小试牛刀：如何利用类型转换实现手机通讯录？（下）

│ │ ├─28｜常见的内置数据类型都何时使用？

│ │ ├─29｜避坑指南：内置数据类型的常见错误

│ │ ├─30｜内置数据类型参考：如何使用官方文档与帮助？

│ │ ├─31｜再回首：“内置数据类型”单元小结

│ │ ├─32｜if语句：数据流程出现分支时，怎样编写程序？

│ │ ├─33｜match语句：如何通过match关键字来处理程序的分支逻辑？

│ │ ├─34｜while循环：需要多次重复执行某段程序时，怎么做？

│ │ ├─35｜for循环：如何遍历一个对象里的所有元素？

│ │ ├─36｜语句嵌套：如何处理多重循环的问题？

│ │ ├─37｜小试牛刀：如何设计一个飞机大战的程序？

│ │ ├─38｜避坑指南：判断和循环中的常见错误

│ │ ├─39｜再回首：“判断循环”单元小结

│ │ ├─内容综述：明确学习目的

│ │ └─课程介绍：这次我们都做了哪些升级？

│ ├─5-快速上手Kotlin开发

│ │ ├─01-讲给你的Kotlin快速上手课程

│ │ ├─02-Kotlin最基础语法

│ │ ├─03-Kotlin与Java完全兼容，就可以随便调用了吗？

│ │ ├─04-新手使用Kotlin常碰到的问题

│ │ ├─05-函数也能嵌套？这个特性要注意

│ │ ├─06-用扩展函数简化代码调用

│ │ ├─07-DSL的基础-Lambda闭包的语法

│ │ ├─08-函数的参数是函数-高阶函数的注意事项

│ │ ├─09-创建对象的关键-Kotlin的构造函数

│ │ ├─10-伴生对象-Kotlin特有的单例对象

│ │ ├─11-by关键字的使用

│ │ ├─12-Kotlin独有的特殊类

│ │ ├─13-解构-特殊的数据拆箱方式

│ │ ├─14-Kotlin的循环语法

│ │ ├─15-Kotlin海量的集合操作符

│ │ ├─16-作用域函数-你会爱上的自带函数

│ │ ├─17-运算符与中缀-定义你的专有运算符

│ │ ├─18-神奇的符号-Kotlin的反引号

│ │ ├─19-DSL是什么，原来早就用过了

│ │ ├─20-构建DSL的常用方式

│ │ ├─21-定义自己的DSL

│ │ ├─22-理解Kotlin中的常量与只读

│ │ ├─23-Kotlin的空安全是如何实现的

│ │ ├─24-Kotlin内联-noinline与crossinline

│ │ ├─25-Kotlin的真泛型与实现方式

│ │ ├─26-协程-提升性能的利器

│ │ ├─27-在Kotlin中使用协程

│ │ ├─28-协程的启动参数

│ │ ├─29-协程的语法糖

│ │ ├─30-suspend-知其然知其所以然

│ │ ├─31-协程的内部实现原理

│ │ ├─32-动手设计Kotlin协程的yield

│ │ ├─33-协程通信：Channel的使用

│ │ ├─34-小结-动手设计Channel版的EventBus

│ │ ├─35-NIO与BIO

│ │ ├─36-Kotlinx-io的对象缓存池

│ │ ├─37-Google推出KTX的目的

│ │ ├─38-KTX的实现

│ │ ├─39-KTX小结

│ │ ├─40-在团队中使用Kotlin

│ │ ├─41-用Kotlin改写现有工程

│ │ ├─42-滥用特性的后果：没人懂的代码

│ │ ├─43-Kotlin服务端开发框架

│ │ ├─44-HttpServlet创建Kotlin版Web应用

│ │ ├─45-SpringBoot创建RESTfulWeb服务

│ │ ├─46-Kotlin开发Web前端

│ │ ├─47-KotlinNative开发

│ │ ├─48-创建KotlinNative基础库

│ │ ├─49-如何用Kotlin实现AndroidMVP

│ │ └─50-AndroidMVP的Kotlin代码&结课测试

│ ├─6-算法面试通关40讲

│ │ ├─01-合格程序员的第一步：算法与数据结构

│ │ ├─02-如何事半功倍地学习算法与数据结构

│ │ ├─03-如何计算算法的复杂度

│ │ ├─04-如何通过LeetCode来进行算法题目练习

│ │ ├─05-理论讲解：数组&链表

│ │ ├─06-面试题：反转一个单链表&判断链表是否有环

│ │ ├─07-理论讲解：堆栈&队列

│ │ ├─08-面试题：判断括号字符串是否有效

│ │ ├─09-面试题：用队列实现栈&用栈实现队列

│ │ ├─10-理论讲解：优先队列

│ │ ├─11-面试题：返回数据流中的第K大元素

│ │ ├─12-面试题：返回滑动窗口中的最大值

│ │ ├─13-理论讲解：哈希表

│ │ ├─14-面试题：有效的字母异位词

│ │ ├─15-面试题：两数之和

│ │ ├─16-面试题：三数之和

│ │ ├─17-理论讲解：树&二叉树&二叉搜索树

│ │ ├─18-面试题：验证二叉搜索树

│ │ ├─19-面试题：二叉树&二叉搜索树的最近公共祖先

│ │ ├─20-理论讲解：二叉树遍历

│ │ ├─21-理论讲解：递归&分治

│ │ ├─22-面试题：Pow(x,n)

│ │ ├─23-面试题：求众数

│ │ ├─24-理论讲解：贪心算法

│ │ ├─25-面试题：买卖股票的最佳时机

│ │ ├─26-理论讲解：广度优先搜索

│ │ ├─27-理论讲解：深度优先搜索

│ │ ├─28-面试题：二叉树层次遍历

│ │ ├─29-面试题：二叉树的最大和最小深度

│ │ ├─30-面试题：生成有效括号组合

│ │ ├─31-理论讲解：剪枝

│ │ ├─32-面试题：N皇后问题

│ │ ├─33-面试题：数独问题

│ │ ├─34-理论讲解：二分查找

│ │ ├─35-面试题：实现一个求解平方根的函数

│ │ ├─36-理论讲解：字典树

│ │ ├─37-面试题：实现一个字典树

│ │ ├─38-面试题：二维网格中的单词搜索问题

│ │ ├─39-理论讲解：位运算

│ │ ├─40-面试题：统计位1的个数

│ │ ├─41-面试题：2的幂次方问题&比特位计数问题

│ │ ├─42-面试题：N皇后问题的另一种解法

│ │ ├─43-理论理解：动态规划（上）

│ │ ├─44-理论理解：动态规划（下）

│ │ ├─45-面试题：爬楼梯

│ │ ├─46-面试题：三角形的最小路径和

│ │ ├─47-面试题：乘积最大子序列

│ │ ├─48-面试题：股票买卖系列

│ │ ├─49-面试题：最长上升子序列

│ │ ├─50-面试题：零钱兑换

│ │ ├─51-面试题：编辑距离

│ │ ├─52-理论讲解：并查集

│ │ ├─53-面试题：岛屿的个数&朋友圈（上）

│ │ ├─54-面试题：岛屿的个数&朋友圈（下）

│ │ ├─55-理论讲解：LRUCache

│ │ ├─56-面试题：设计和实现一个LRUCache缓存机制

│ │ ├─57-理论讲解：布隆过滤器

│ │ ├─58-课程重点回顾

│ │ ├─59-FAQ答疑&面试中切题四件套

│ │ ├─60-回到起点：斐波拉契数列

│ │ ├─61-白板实战番外篇：斐波拉契数列

│ │ └─62-结课测试&最后的一些经验分享

│ ├─7-Nginx核心知识150讲

│ │ ├─01-课程综述

│ │ ├─02-Nginx适用于哪些场景？

│ │ ├─03-Nginx出现的历史背景

│ │ ├─04-为什么用Nginx：它的5个主要优点

│ │ ├─05-Nginx的四个主要组成部分

│ │ ├─06-Nginx的版本发布历史

│ │ ├─07-选择哪一个Nginx发行版本？

│ │ ├─08-编译出适合自己的Nginx

│ │ ├─09-Nginx配置文件的通用语法介绍

│ │ ├─10-Nginx命令行及演示：重载、热部署、日志切割

│ │ ├─100-对客户端请求的缓存处理流程

│ │ ├─101-接收上游响应的缓存处理流程

│ │ ├─102-如何减轻缓存失效时上游服务的压力

│ │ ├─103-及时清除缓存

│ │ ├─104-uwsgi、fastcgi、scgi指令的对照表

│ │ ├─105-memcached反向代理的用法

│ │ ├─106-搭建websocket反向代理

│ │ ├─107-用分片提升缓存效率

│ │ ├─108-openfilecache提升系统性能

│ │ ├─109-HTTP-2协议介绍

│ │ ├─11-用Nginx搭建一个可用的静态资源Web服务器

│ │ ├─110-搭建HTTP-2服务并推送资源

│ │ ├─111-gRPC反向代理

│ │ ├─112-stream四层反向代理的7个阶段及常用变量

│ │ ├─113-proxyprotocol协议与realip模块

│ │ ├─114-限并发连接、限IP、记日志

│ │ ├─115-stream四层反向代理处理SSL下游流量

│ │ ├─116-streampreread模块取出SSL关键信息

│ │ ├─117-streamproxy四层反向代理的用法

│ │ ├─118-UDP反向代理

│ │ ├─119-透传IP地址的3个方案

│ │ ├─12-用Nginx搭建一个具备缓存功能的反向代理服务

│ │ ├─120-性能优化方法论

│ │ ├─121-如何高效使用CPU

│ │ ├─122-多核间的负载均衡

│ │ ├─123-控制TCP三次握手参数

│ │ ├─124-建立TCP连接的优化

│ │ ├─125-滑动窗口与缓冲区

│ │ ├─126-优化缓冲区与传输效率

│ │ ├─127-慢启动与拥塞窗口

│ │ ├─128-TCP协议的keepalive功能

│ │ ├─129-减少关闭连接时的timewait端口数量

│ │ ├─13-用GoAccess实现可视化并实时监控access日志

│ │ ├─130-lingeringclose延迟关闭TCP连接

│ │ ├─131-应用层协议的优化

│ │ ├─132-磁盘IO的优化

│ │ ├─133-减少磁盘读写次数

│ │ ├─134-零拷贝与gzipstatic模块

│ │ ├─135-用tcmalloc优化内存分配

│ │ ├─136-使用GooglePerfTools分析Nginx

│ │ ├─137-使用stubstatus模块监控Nginx的状态

│ │ ├─138-第三方模块源码的阅读

│ │ ├─139-Nginx的启动流程

│ │ ├─14-从网络原理来看SSL安全协议

│ │ ├─140-HTTP第三方模块的初始化

│ │ ├─141-if指令是邪恶的吗？

│ │ ├─142-解读Nginx的核心转储文件

│ │ ├─143-通过debug日志定位问题

│ │ ├─144-OpenResty概述

│ │ ├─145-OpenResty中的Nginx模块与Lua模块

│ │ ├─146-如何在Nginx中嵌入Lua代码

│ │ ├─147-OpenResty中Lua与C代码交互的原理

│ │ ├─148-获取、修改请求与响应的SDK

│ │ ├─149-工具类型的SDK

│ │ ├─15-对称加密与非对称加密各自的应用场景

│ │ ├─150-同步且非阻塞的底层SDK：cosocket

│ │ ├─151-基于协程的并发编程SDK

│ │ ├─152-定时器及时间相关的SDK

│ │ ├─153-share

│ │ ├─154-子请求的使用方法

│ │ ├─155-基于OpenResty的WAF防火墙&结课测试

│ │ ├─16-SSL证书的公信力是如何保证的？

│ │ ├─17-SSL协议握手时Nginx的性能瓶颈在哪里？

│ │ ├─18-用免费SSL证书实现一个HTTPS站点

│ │ ├─19-基于OpenResty用Lua语言实现简单服务

│ │ ├─20-Nginx的请求处理流程

│ │ ├─21-Nginx的进程结构

│ │ ├─22-Nginx的进程结构实例演示

│ │ ├─23-使用信号管理Nginx的父子进程

│ │ ├─24-reload重载配置文件的真相

│ │ ├─25-热升级的完整流程

│ │ ├─26-优雅地关闭worker进程

│ │ ├─27-网络收发与Nginx事件间的对应关系

│ │ ├─28-Nginx网络事件实例演示

│ │ ├─29-Nginx的事件驱动模型

│ │ ├─30-epoll的优劣及原理

│ │ ├─31-Nginx的请求切换

│ │ ├─32-同步&异步、阻塞&非阻塞之间的区别

│ │ ├─33-Nginx的模块究竟是什么？

│ │ ├─34-Nginx模块的分类

│ │ ├─35-Nginx如何通过连接池处理网络请求

│ │ ├─36-内存池对性能的影响

│ │ ├─37-所有worker进程协同工作的关键：共享内存

│ │ ├─38-用好共享内存的工具：Slab管理器

│ │ ├─39-哈希表的maxsize与bucketsize如何配置

│ │ ├─40-Nginx中最常用的容器：红黑树

│ │ ├─41-使用动态模块来提升运维效率

│ │ ├─42-第三章内容介绍

│ │ ├─43-冲突的配置指令以谁为准？

│ │ ├─44-Listen指令的用法

│ │ ├─45-处理HTTP请求头部的流程

│ │ ├─46-Nginx中的正则表达式

│ │ ├─47-如何找到处理请求的server指令块

│ │ ├─48-详解HTTP请求的11个阶段

│ │ ├─49-11个阶段的顺序处理

│ │ ├─50-postread阶段：获取真实客户端地址的realip模块

│ │ ├─51-rewrite阶段的rewrite模块：return指令

│ │ ├─52-rewrite阶段的rewrite模块：重写URL

│ │ ├─53-rewrite阶段的rewrite模块：条件判断

│ │ ├─54-findconfig阶段：找到处理请求的location指令块

│ │ ├─55-preaccess阶段：对连接做限制的limitconn模块

│ │ ├─56-preaccess阶段：对请求做限制的limitreq模块

│ │ ├─57-access阶段：对ip做限制的access模块

│ │ ├─58-access阶段：对用户名密码做限制的authbasic模块

│ │ ├─59-access阶段：使用第三方做权限控制的authrequest模块

│ │ ├─60-access阶段的satisfy指令

│ │ ├─61-precontent阶段：按序访问资源的tryfiles模块

│ │ ├─62-实时拷贝流量：precontent阶段的mirror模块

│ │ ├─63-content阶段：详解root和alias指令

│ │ ├─64-static模块提供的3个变量

│ │ ├─65-static模块对url不以斜杠结尾却访问目录的做法

│ │ ├─66-index和autoindex模块的用法

│ │ ├─67-提升多个小文件性能的concat模块

│ │ ├─68-access日志的详细用法

│ │ ├─69-HTTP过滤模块的调用流程

│ │ ├─70-用过滤模块更改响应中的字符串：sub模块

│ │ ├─71-用过滤模块在http响应的前后添加内容：addition模块

│ │ ├─72-Nginx变量的运行原理

│ │ ├─73-HTTP框架提供的请求相关的变量

│ │ ├─74-HTTP框架提供的其他变量

│ │ ├─75-使用变量防盗链的referer模块

│ │ ├─76-使用变量实现防盗链功能实践：securelink模块

│ │ ├─77-为复杂的业务生成新的变量：map模块

│ │ ├─78-通过变量指定少量用户实现AB测试：splitclient模块

│ │ ├─79-根据IP地址范围的匹配生成新变量：geo模块

│ │ ├─80-使用变量获得用户的地理位置：geoip模块

│ │ ├─81-对客户端使用keepalive提升连接效率

│ │ ├─82-反向代理与负载均衡原理

│ │ ├─83-负载均衡策略：round-robin

│ │ ├─84-负载均衡哈希算法：iphash与hash模块

│ │ ├─85-一致性哈希算法：hash模块

│ │ ├─86-最少连接算法以及如何跨worker进程生效

│ │ ├─87-upstream模块提供的变量

│ │ ├─88-proxy模块处理请求的流程

│ │ ├─89-proxy模块中的proxypass指令

│ │ ├─90-根据指令修改发往上游的请求

│ │ ├─91-接收用户请求包体的方式

│ │ ├─92-与上游服务建立连接

│ │ ├─93-接收上游的响应

│ │ ├─94-处理上游的响应头部

│ │ ├─95-上游出现失败时的容错方案

│ │ ├─96-对上游使用SSL连接

│ │ ├─97-用好浏览器的缓存

│ │ ├─98-Nginx决策浏览器过期缓存是否有效

│ │ └─99-缓存的基本用法

│ ├─8-玩转Git三剑客

│ │ ├─02-安装Git

│ │ ├─03-使用Git之前需要做的最小配置

│ │ ├─04-创建第一个仓库并配置local用户信息

│ │ ├─05-通过几次commit来认识工作区和暂存区

│ │ ├─06-给文件重命名的简便方法

│ │ ├─07-通过gitlog查看版本演变历史

│ │ ├─08-gitk：通过图形界面工具来查看版本历史

│ │ ├─09-探密

│ │ ├─10-commit、tree和blob三个对象之间的关系

│ │ ├─11-小练习：数一数tree的个数

│ │ ├─12-分离头指针情况下的注意事项

│ │ ├─13-进一步理解HEAD和branch

│ │ ├─14-怎么删除不需要的分支？

│ │ ├─15-怎么修改最新commit的message？

│ │ ├─16-怎么修改老旧commit的message？

│ │ ├─17-怎样把连续的多个commit整理成1个？

│ │ ├─18-怎样把间隔的几个commit整理成1个？

│ │ ├─19-怎么比较暂存区和HEAD所含文件的差异？

│ │ ├─20-怎么比较工作区和暂存区所含文件的差异？

│ │ ├─21-如何让暂存区恢复成和HEAD的一样？

│ │ ├─22-如何让工作区的文件恢复为和暂存区一样？

│ │ ├─23-怎样取消暂存区部分文件的更改？

│ │ ├─24-消除最近的几次提交

│ │ ├─25-看看不同提交的指定文件的差异

│ │ ├─26-正确删除文件的方法

│ │ ├─27-开发中临时加塞了紧急任务怎么处理？

│ │ ├─28-如何指定不需要Git管理的文件？

│ │ ├─29-如何将Git仓库备份到本地？

│ │ ├─30-注册一个GitHub账号

│ │ ├─31-配置公私钥

│ │ ├─32-在GitHub上创建个人仓库

│ │ ├─33-把本地仓库同步到GitHub

│ │ ├─34-不同人修改了不同文件如何处理？

│ │ ├─35-不同人修改了同文件的不同区域如何处理？

│ │ ├─36-不同人修改了同文件的同一区域如何处理？

│ │ ├─37-同时变更了文件名和文件内容如何处理？

│ │ ├─38-把同一文件改成了不同的文件名如何处理？

│ │ ├─39-禁止向集成分支执行push-f操作

│ │ ├─40-禁止向集成分支执行变更历史的操作

│ │ ├─41-GitHub为什么会火？

│ │ ├─42-GitHub都有哪些核心功能？

│ │ ├─43-怎么快速淘到感兴趣的开源项目

│ │ ├─44-怎样在GitHub上搭建个人博客

│ │ ├─45-开源项目怎么保证代码质量？

│ │ ├─46-为何需要组织类型的仓库？

│ │ ├─47-创建团队的项目

│ │ ├─48-怎样选择适合自己团队的工作流？

│ │ ├─49-如何挑选合适的分支集成策略？

│ │ ├─50-启用issue跟踪需求和任务

│ │ ├─51-如何用project管理issue？

│ │ ├─52-项目内部怎么实施codereview？

│ │ ├─53-团队协作时如何做多分支的集成？

│ │ ├─54-怎样保证集成的质量？

│ │ ├─55-怎样把产品包发布到GitHub上？

│ │ ├─56-怎么给项目增加详细的指导文档？

│ │ ├─57-国内互联网企业为什么喜欢GitLab？

│ │ ├─58-GitLab有哪些核心的功能？

│ │ ├─59-GitLab上怎么做项目管理？

│ │ ├─60-GitLab上怎么做codereview？

│ │ ├─61-GitLab上怎么保证集成的质量？

│ │ └─62-怎么把应用部署到AWS上？

│ └─9-TensorFlow快速入门与实战

│ ├─01-课程介绍

│ ├─02-课程内容综述

│ ├─03-第一章内容概述

│ ├─04-TensorFlow产生的历史必然性

│ ├─05-TensorFlow与JeffDean的那些事

│ ├─06-TensorFlow的应用场景

│ ├─07-TensorFlow的落地应用

│ ├─08-TensorFlow的发展现状

│ ├─09-第二章内容概述

│ ├─10-搭建你的TensorFlow开发环境

│ ├─11-HelloTensorFlow

│ ├─12-在交互环境中使用TensorFlow

│ ├─13-在容器中使用TensorFlow

│ ├─14-第三章内容概述

│ ├─15-TensorFlow模块与架构介绍

│ ├─16-TensorFlow数据流图介绍

│ ├─17-张量（Tensor）是什么（上）

│ ├─18-张量（Tensor）是什么（下）

│ ├─19-变量（Variable）是什么（上）

│ ├─20-变量（Variable）是什么（下）

│ ├─21-操作（Operation）是什么（上）

│ ├─22-操作（Operation）是什么（下）

│ ├─23-会话（Session）是什么

│ ├─24-优化器（Optimizer）是什么

│ ├─25-第四章内容概述

│ ├─26-房价预测模型的前置知识

│ ├─27-房价预测模型介绍

│ ├─28-房价预测模型之数据处理

│ ├─29-房价预测模型之创建与训练

│ ├─30-TensorBoard可视化工具介绍

│ ├─31-使用TensorBoard可视化数据流图

│ ├─32-实战房价预测模型：数据分析与处理

│ ├─33-实战房价预测模型：创建与训练

│ ├─34-实战房价预测模型：可视化数据流图

│ ├─35-第五章内容概述

│ ├─36-手写体数字数据集MNIST介绍（上）

│ ├─37-手写体数字数据集MNIST介绍（下）

│ ├─38-MNISTSoftmax网络介绍（上）

│ ├─39-MNISTSoftmax网络介绍（下）

│ ├─40-实战MNISTSoftmax网络（上）

│ ├─41-实战MNISTSoftmax网络（下）

│ ├─42-MNISTCNN网络介绍

│ ├─43-实战MNISTCNN网络

│ ├─44-第六章内容概述

│ ├─45-准备模型开发环境

│ ├─46-生成验证码数据集

│ ├─47-输入与输出数据处理

│ ├─48-模型结构设计

│ ├─49-模型损失函数设计

│ ├─50-模型训练过程分析

│ ├─51-模型部署与效果演示

│ ├─52-第七部分内容介绍

│ ├─53-人脸识别问题概述

│ ├─54-典型人脸相关数据集介绍

│ ├─55-人脸检测算法介绍

│ ├─56-人脸识别算法介绍

│ ├─57-人脸检测工具介绍

│ ├─58-解析FaceNet人脸识别模型

│ ├─59-实战FaceNet人脸识别模型

│ ├─60-测试与可视化分析

│ ├─61-番外篇内容介绍

│ ├─62-TensorFlow社区介绍

│ ├─63-TensorFlow生态：TFX

│ ├─64-TensorFlow生态：Kubeflow

│ ├─65-如何参与TensorFlow社区开源贡献

│ ├─66-MLGDE是TensorFlow社区与开发者的桥梁

│ └─67-课程总结

本站所有资源均来自网络，版权归原作者所有，本站仅提供收集与推荐，若侵犯到您的权益，请【给我们反馈】，我们将在24小时内处理！

聚资料（juziliao.com）免责声明：

1. 本站所有资源来源于用户上传和网络，如有侵权请邮件联系站长！（gm@juziliao.com）

2. 分享目的仅供大家学习和交流，请不要用于商业用途！如需商用请联系原作者购买正版！

3.如有链接无法下载、失效或洽谈广告，请联系网站客服（微信：shangen0228）处理！

免费下载或者VIP会员资源能否直接商用？

提示下载完但解压或打开不了？

付款后没有资源信息怎么办？

付款后无法显示下载地址或者无法查看内容？

购买该资源后，可以退款吗？

相关文章