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

搜天地

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

课程介绍(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小时内处理！

下载权限

查看

￥

免费下载

评论并刷新后下载

登录后下载

查看演示

{{attr.name}}：

您当前的等级为

登录后免费下载登录小黑屋反思中，不准下载！评论后刷新页面下载评论支付以后下载请先登录您今天的下载次数（次）用完了，请明天再来支付积分以后下载立即支付支付以后下载立即支付您当前的用户组不允许下载升级会员

您已获得下载权限您可以每天下载资源次，今日剩余次

给TA打赏

共{{data.count}}人

人已打赏

.Net 2D 3D ACT AE AI AIO Albert AlexNet Algorithm Alibaba Allure Amazon Android Android开发 Angular AngularJS ANN Ansible Ant AntD AntDesign API APP APP架构 ASE AU AWS axios BDD BIO Bootstrap B站 B端 C++CAC CAD CAP CDC CDH Centos CG CHO ClassLoader Clickhouse Cloud CNN Connection cos CPA CSS CTF CVS C语言 DDD Debug Deployment DevOp DevOps disruptor Django DMP Docker Dubbo ECS Elasticsearch Electron Element ELK ensorflow ES ES6 etcd Excel Express Facebook ffmpeg Flink Flutter Form framework GC GEO Git GitHub GitLab gmv go Golang Google Go语言 Go进阶 GRE H5 hadoop HarmonyOS HashMap HBase HDFS Hive Hooks HR HTML html5 HTTP HttpClient HTTPS HTTP协议 IM IOS iOS开发 IP地址 Istio IT互联网 java JavaEE JavaScript JavaWeb java虚拟机 Jenkins Jest Jetpack Jmeter jQuery JS JVM K8S Kafka keep Keras KET Kotlin Kubernetes KVM k大 LeetCode LinkedIn Linux Loader LoadRunner Mac Martin Matplotlib Maven max MBA MCA MD Memory MET MG MongoDB MVP MyBatis MySQL Native NBA Netty NFT Nginx NIO NLP Node NoSQL NTF Numpy Nuxt Oauth2 OBS OC OKR OKR实战 OpenCV Oracle P2P panda Pandas PHP Pinterest PMP PPC ppi PPT PR Programming Project Promise PS PWA Python Python3 Python爬虫 PyTorch QPS RabbitMQ React ReactNative Redis Redis6 Redux RESTFul RNN rocketmq ROI ROS Router RPC RPC框架 Ruby Runtime Rust SaaS SAM SAT SCI SDK Selenium SEM Sentinel seo Serverless Shell Sketch SkyWalking Sleuth Snapseed Socket Spark Spring SpringAop SpringApplication SpringBoot SpringCloud SpringMVC SpringSecurity SQL SQLMAP SSD SSR Storm Swift SwiftUI Switch TDD TensorFlow toi Tomcat TypeScript UE Uffie UI UI设计 UML VBA View Vio vue Vue3 Vuex WAKE Web WebApi WebApp WebFlux WebGL Webpack Webpack5 Web前端 Web基础 Web安全 Web开发 web技术 Web框架 Windows Wireshark Word Worker WorkShop YouTube Zipkin Zookeeper 万物皆数三国三维上市专利写作专注力世界杯业务架构个人发展个人品牌个人成长个人管理个人财富课个性化推荐中考中间件举一反三乐理乐队乐高乘风习惯书单书籍买房乳腺二爷二维云原生云计算互动互动直播互联网互联网运营亚马逊交互设计交互设计师交友交易交通事故产品体验产品矩阵产品经理产品设计产品运营京东亲子亲密关系人体人像人像摄影人力资源人力资源管理人工智能人工神经网络人性人物人生人类简史人脸识别人际人际关系代数代码规范以太坊价值互联网价值投资企业企业战略企业架构企业管理企业级企业转型优化代码传感器传播伦理体育何从何巧何建侦探保险信息化信息架构信息流信息系统信用信用卡债务健康僵尸元宇宙光影入职全栈全栈工程师全栈开发全球化公众号公式共识机制兵器其他其它养成内功心法内存知识内存计算内容变现内核冒险写作写作课写字农场决策几何函数函数式函数式编程分享分布式分布式事务分布式架构分布式爬虫分布式系统分库分表分析思维刘超创业创业者创作创意创投创新创造力制作前端前端基础前端工程化前端开发前端架构剪辑副业办公软件功夫加密动作动态动效动效设计动机动画包装化学北极星区块链区块链技术医疗协议单词单车卖点博物危机管理卷积神经历史去中心化参数反向代理发明变现叙事可爱可视化可视化设计台湾合伙人合作合同合集吉他名词后台后期后期处理后端向上管理吴咏炜吸引力周期周鸿祎咖啡品牌品牌IP 品牌增长响应式哲学唐诗商业商业思维商业模式商城商战商机四级团购团队管理图像处理图形图形学图标图表在线教育地产地理场景场景设计垃圾回收城市基础入门基础理论基金基金投资增长声音复杂系统复杂网络复盘外卖外挂外汇多人多媒体多线程大元大前端大学大数据大数据分析大数据开发大数据技术大数据时代大数据架构大白头条头部套路女性婚姻婚姻家庭字体存储实战孙子兵法学习学习方法学习算法学习资料学前学术学英语学霸安全安全攻防安全漏洞安卓定位宝宝巴士宝洁实操项目实时流计算宣传片家居容器容器实战对抗对话导演小游戏小程序小米小马哥少女嵌入式工作与生活工作效率工作法工作流工程工程师巨龙市场营销布局并发并发框架并发编程广告广告投放应用开发延时建模建筑建造开发流程张汉东张雪录音彩色律师徐林得到微信微信小游戏微信小程序微信接口微商微服务微服务架构微服务框架微软心智心机心理心理学心算快手思想思维思维导图思维方式思维模型思考思考力性格性能优化性能分析性能测试恋爱恋爱必修课恐龙情感情绪成人成长战斗战术战法战略房产房产投资房产经纪房地产手写体手工手机摄影扑克打造爆款执行力技术思维技术管理技术类技术面试技能抓包投资投资实战投资理财抖音拍摄拟真拼多多持久指标掌控探秘探索接口推广推理推荐系统搜索搜索引擎搬砖搬运摄影摄影入门操作系统操盘支付支付宝支付开发政治故事效率效率提升敏捷敏捷开发教学数仓数字数字化数字化思维数字经济数字货币数学数据数据产品数据仓库数据分析数据可视化数据处理数据平台数据库数据库设计数据库集群数据建模数据挖掘数据科学数据结构数据结构与算法数据统计数据透视表数据采集数独整形整理文化文字文案文案修炼文档断层新人新商业新零售方案设计方法论旅行无忧时间管理星座晋升指南智商智慧暗黑暴力曹春晖有趣朋友圈服务器服务架构期权期货未来朱赟机器人机器学习李智慧李清照李玥李白李程远材质杜甫极客时间构图构成林外架构架构师架构设计框架框架设计案例解析梦想森林概率概率图模块化模块系统模拟模板正义武侠武器比特币氛围求职汇编语言汤峥嵘汽车沙盒沟通沟通技巧油画法学法律法律法规法律知识法门注意力流程管理流计算测试测试工程师测试方法测试驱动海报消息队列消费心理学淘宝深度学习渗透渗透测试渲染渲染器游戏游戏化游戏场景游戏开发游戏引擎游戏设计源代码分析源码源码分析源码解析漏洞漏洞挖掘演讲潜规则激励火车灵活性热身焦虑燃脂爆款文案爆款短视频爬虫爱课版式物理物联网特效犯罪独立狼叔玄奘王争王喆王维王者王者荣耀理论学理财生存用户体验用户体验设计用户画像用户研究甲骨文电商电商平台电影电视剧留学瘦身监控系统目标检测直播直播间知行合一知识图谱知识星球知识点短视频短视频剪辑短视频变现短视频运营研究研究方法破解硬件社交社交网络社会神学神经网络私教科学科学计算科技秒杀系统移动互联移动互联网移动应用移动开发移动端程序员程序开发程序设计程序语言穿搭竞价笔记第一性原理策略简历算法算法原理算法实战管理管理战略管理框架管理课篮球精力管理精品网课精益创业精读系统系统学系统开发系统架构素养素质约会纹理线上销售线性代数线程组件组件化组织管理终身学习经典经济经营统计统计学绩效绩效管理缓存编码编程编程与开发编程入门编程基础编程实践编程思想编程范式编程语言编译编译原理编译器网关网易网格网红网络协议网络安全网络层网络爬虫网络编程网赚美团美国美好美学美颜翻译考试考题聊天职业职业规划职场职场规划职问联盟链股权股票股票投资背单词背景脚本自动化自动化测试自我成长自然法自然语言自然语言处理色彩艺术苏轼英文英语英语私教课英语词汇苹果获客营销虚拟化虚拟机行研衡量表情包表格表演表达表达式裂变装饰规划规范视觉视觉笔记视觉语言视频剪辑视频平台角色解密计算机计算机体系结构计算机基础计算机系统计算机组成原理计算机网络计算机视觉订餐系统认知认识自己训练训练营记忆记忆力讲课许式伟论文论文解读设计设计哲学设计师设计模式访谈词根词缀词汇试卷试题诗词语法语言学说透敏捷诸葛亮读书课外阅读调研调色谷歌负载均衡财产财务财富财富管理货币贴图资产资产配置资本赋能赚钱赵成趋势跨境跨境电商跨平台跨部门沟通跳槽软件工程软件开发软件架构软件测试软件系统软件设计软件需求辛弃疾辛普森运维运营逆袭透视通信原理通信技术速写速卖通速记造型道经配色重组量化量化投资量学金融链路追踪销售阅读防火墙阳光阿尔法阿里阿里云阿里巴巴阿里文化陈天陈阳集体智慧集群零售需求需求分析需求管理需求评审面试面试技巧音乐音视频音视频开发音视频技术音频项目项目开发项目管理项目经理领域模型领导力风控风格风险管理飞翔飞雪无情食物摄影马哥驱动设计骇客骨架高并发高性能高效学习高效记忆魅力鸡汤鸿蒙黑客黑白

16 条回复 A文章作者 M管理员

xiaorenwuz 初级士官(二级士官)lv3

23年8月10日

伤心桥下春波绿，曾是惊鸿照影来。
xiaorenwuz 初级士官(二级士官)lv3

23年7月30日

如果圆规的两只脚都动，永远也画不出一个圆。
麦奇 中级士官(四级士官)lv5

23年6月1日

明月松间照，清泉石上流。
十七 中级士官(三级士官)lv4

23年5月6日

不敢打开信封啊。因为，打开了就结束了啊。
枫 上等兵lv1

23年4月18日

我要这天再遮不住我眼,要这地再埋不了我心.
nice 上等兵lv1

23年4月5日

很不错
jinrong 高级士官(五级士官)lv6

23年2月20日

希望继续更新更新
rfree520 中级士官(四级士官)lv5

23年2月19日

“像你这样的白痴是怎么活过来的？”“因为我很自信。
rfree520 中级士官(四级士官)lv5

23年2月9日

每个人都在自己的生命中频繁地抛弃着自己的过去。
rfree520 中级士官(四级士官)lv5

23年2月6日

齿轮也有齿轮的志气！
findmoon 列兵lv0

23年2月1日

你依然让我觉得美好且心动，但我已经没有力气和勇气再去拥抱。
zj 中级士官(四级士官)lv5

23年1月30日

生来一人，去时孤身，便是江澄其人
额vantis 列兵lv0

23年1月28日

因为不可能，所以才值得相信。
zj 中级士官(四级士官)lv5

23年1月26日

自责要短暂，不过要长久铭记。
spark001 上等兵lv1

23年1月17日

趁着年轻，好好犯病。
ht 少尉lv8

23年1月16日

这瓜多少钱一斤？

{{userData.name}}已认证

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

下载权限

查看演示

怎样能更多的下载资源？/如何获取积分？

游客用户购买后未获得下载权限？

资源失效怎么办？

怎么兑换资源？

文件解压出错/解压文件不全

怎么下载资源？

资源提取码在哪？

资源解压密码在哪？

为什么有些资源没有下载入口？

我有资源内容，怎样发布供稿呢？

怎么利用关键字搜索资源？

想寻找一个站点上没有的资源怎么办？

如何保存【百度网盘】群资源？

用户协议

热销商城

免责声明

在线留言

建议提交

申请友链

广告合作

推广中心

{{userData.name}}已认证

下载权限

查看演示

黑马 152小课合集

2021年尚硅谷Java后端【2021年11月结课】

黑马博学谷-JavaEE在线就业班2022年+中级进修课+精英进阶|价值14980元|重磅首发|完结无秘

黑马博学谷-前端V7.6+在职加薪|价值9980元|2022年|重磅首发|完结无秘

用户协议

热销商城

免责声明

在线留言

建议提交

申请友链

广告合作

推广中心