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

课程介绍(A001078)：

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

2022年12月已更新！！

2022年九月已更新！！

2022年八月已更新！！

2022年七月已更新！！

2022年六月已更新！！

2022年五月已更新！！

2022年四月已更新！！

2022年三月已更新！！

2022年1月已更新！！

（专栏+视频课262门课）

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

1672365249 mxcp 1672336439028 1670846758 38fd8cdcd521066 — 极客时间-专栏+视频svip会员|持续更新|重磅首发|2022年12月已更新 3

文件目录：

极客时间-专栏+视频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的未来，依然是星辰大海

│ │ │