JUST DO IT
首页
归档
搜索
极客时间
太棒了! 目前共计 1,729 篇日志。 继续努力。
2023
结课测试 | 关于Python的这些知识，你都掌握了吗？
09-20
结束语 | 技术之外的几点成长建议
09-20
43 | Q&A：聊一聊职业发展和选择
09-20
加餐 | 带你上手SWIG：一份清晰好用的SWIG编程实践指南
09-20
42 | 细数技术研发的注意事项
09-20
41 | 硅谷一线互联网公司的工作体验
09-20
40 | 总结：Python中的数据结构与算法全景
09-20
39 | Django：搭建监控平台
09-20
38 | MySQL：日志和数据存储系统
09-20
37 | Kafka & ZMQ：自动化交易流水线
09-20
36 | Pandas & Numpy：策略与回测系统
09-20
35 | RESTful & Socket：行情数据对接和抓取
09-20
34 | RESTful & Socket：搭建交易执行层核心
09-20
33 | 带你初探量化世界
09-20
32 | 答疑（三）：如何选择合适的异常处理方式？
09-20
31 | pdb & cProfile：调试和性能分析的法宝
09-20
30 | 真的有必要写单元测试吗？
09-20
29 | 巧用上下文管理器和With语句精简代码
09-20
28 | 如何合理利用assert？
09-20
27 | 学会合理分解代码，提高代码可读性
09-20
26 | 活都来不及干了，还有空注意代码风格？！
09-20
25 | 答疑（二）：GIL与多线程是什么关系呢？
09-20
24 | 带你解析 Python 垃圾回收机制
09-20
23 | 你真的懂Python GIL（全局解释器锁）吗？
09-20
22 | 并发编程之Asyncio
09-20
21 | Python并发编程之Futures
09-20
20 | 揭秘 Python 协程
09-20
19 | 深入理解迭代器和生成器
09-20
18 | metaclass，是潘多拉魔盒还是阿拉丁神灯？
09-20
17 | 强大的装饰器
09-20
16 | 值传递，引用传递or其他，Python里参数是如何传递的？
09-20
15 | Python对象的比较、拷贝
09-20
14 | 答疑（一）：列表和元组的内部实现是怎样的？
09-20
13 | 搭建积木：Python 模块化
09-20
12 | 面向对象（下）：如何实现一个搜索引擎？
09-20
11 | 面向对象（上）：从生活中的类比说起
09-20
10 | 简约不简单的匿名函数
09-20
09 | 不可或缺的自定义函数
09-20
08 | 异常处理：如何提高程序的稳定性？
09-20
07 | 修炼基本功：条件与循环
09-20
06 | Python “黑箱”：输入与输出
09-20
05 | 深入浅出字符串
09-20
04 | 字典、集合，你真的了解吗？
09-20
03 | 列表和元组，到底用哪一个？
09-20
02 | Jupyter Notebook为什么是现代Python的必学技术？
09-20
01 | 如何逐步突破，成为Python高手？
09-20
开篇词 | 从工程的角度深入理解Python
09-20
结课测试 | 这些Java虚拟机的知识你都掌握了吗？
09-19
尾声 | 道阻且长，努力加餐
09-19
36 | SubstrateVM：AOT编译框架
09-19
35 | Truffle：语言实现框架
09-19
34 | Graal：用Java编译Java
09-19
33 | Java Agent与字节码注入
09-19
32 | JNI的运行机制
09-19
31 | Java虚拟机的监控及诊断工具（GUI篇）
09-19
30 | Java虚拟机的监控及诊断工具（命令行篇）
09-19
29 | 基准测试框架JMH（下）
09-19
28 | 基准测试框架JMH（上）
09-19
27 | 注解处理器
09-19
26 | 向量化
09-19
25 | 循环优化
09-19
24 | 字段访问相关优化
09-19
23 | 逃逸分析
09-19
22 | HotSpot虚拟机的intrinsic
09-19
21 | 方法内联（下）
09-19
20 | 方法内联（上）
09-19
19 | Java字节码（基础篇）
09-19
18 | 即时编译器的中间表达形式
09-19
17 | 即时编译（下）
09-19
16 | 即时编译（上）
09-19
15 | Java语法糖与Java编译器
09-19
14 | Java虚拟机是怎么实现synchronized的？
09-19
13 | Java内存模型
09-19
【工具篇】 常用工具介绍
09-19
12 | 垃圾回收（下）
09-19
11 | 垃圾回收（上）
09-19
10 | Java对象的内存布局
09-19
09 | JVM是怎么实现invokedynamic的？（下）
09-19
08 | JVM是怎么实现invokedynamic的？（上）
09-19
07 | JVM是如何实现反射的？
09-19
06 | JVM是如何处理异常的？
09-19
05 | JVM是如何执行方法调用的？（下）
09-19
04 | JVM是如何执行方法调用的？（上）
09-19
03 | Java虚拟机是如何加载Java类的?
09-19
02 | Java的基本类型
09-19
01 | Java代码是怎么运行的？
09-19
开篇词 | 为什么我们要学习Java虚拟机？
09-19
结课测试｜这些Linux性能知识你都掌握了吗？
09-09
结束语 | 愿你攻克性能难关
09-09
用户故事 | 运维和开发工程师们怎么说？
09-09
58 | 答疑（六）：容器冷启动如何性能分析？
09-09
57 | 套路篇：Linux 性能工具速查
09-09
56 | 套路篇：优化性能问题的一般方法
09-09
55 | 套路篇：分析性能问题的一般步骤
09-09
54 | 套路篇：应用监控的一般思路
09-09
53 | 套路篇：系统监控的综合思路
09-09
52 | 案例篇：服务吞吐量下降很厉害，怎么分析？
09-09
51 | 案例篇：动态追踪怎么用？（下）
09-09
50 | 案例篇：动态追踪怎么用？（上）
09-09
49 | 案例篇：内核线程 CPU 利用率太高，我该怎么办？
09-09
48 | 案例篇：服务器总是时不时丢包，我该怎么办？（下）
09-09
47 | 案例篇：服务器总是时不时丢包，我该怎么办？（上）
09-09
46 | 案例篇：为什么应用容器化后，启动慢了很多？
09-09
45 | 答疑（五）：网络收发过程中，缓冲区位置在哪里？
09-09
44 | 套路篇：网络性能优化的几个思路（下）
09-09
43 | 套路篇：网络性能优化的几个思路（上）
09-09
42 | 案例篇：如何优化 NAT 性能？（下）
09-09
41 | 案例篇：如何优化 NAT 性能？（上）
09-09
40 | 案例篇：网络请求延迟变大了，我该怎么办？
09-09
39 | 案例篇：怎么缓解 DDoS 攻击带来的性能下降问题？
09-09
38 | 案例篇：怎么使用 tcpdump 和 Wireshark 分析网络流量？
09-09
37 | 案例篇：DNS 解析时快时慢，我该怎么办？
09-09
36 | 套路篇：怎么评估系统的网络性能？
09-09
35 | 基础篇：C10K 和 C1000K 回顾
09-09
34 | 关于 Linux 网络，你必须知道这些（下）
09-09
33 | 关于 Linux 网络，你必须知道这些（上）
09-09
32 | 答疑（四）：阻塞、非阻塞 I/O 与同步、异步 I/O 的区别和联系
09-09
31 | 套路篇：磁盘 I/O 性能优化的几个思路
09-09
30 | 套路篇：如何迅速分析出系统I/O的瓶颈在哪里？
09-09
29 | 案例篇：Redis响应严重延迟，如何解决？
09-09
28 | 案例篇：一个SQL查询要15秒，这是怎么回事？
09-09
27 | 案例篇：为什么我的磁盘I/O延迟很高？
09-09
26 | 案例篇：如何找出狂打日志的“内鬼”？
09-09
25 | 基础篇：Linux 磁盘I/O是怎么工作的（下）
09-09
24 | 基础篇：Linux 磁盘I/O是怎么工作的（上）
09-09
23 | 基础篇：Linux 文件系统是怎么工作的？
09-09
22 | 答疑（三）：文件系统与磁盘的区别是什么？
09-09
21 | 套路篇：如何“快准狠”找到系统内存的问题？
09-09
20 | 案例篇：为什么系统的Swap变高了？（下）
09-09
19 | 案例篇：为什么系统的Swap变高了（上）
09-09
18 | 案例篇：内存泄漏了，我该如何定位和处理？
09-09
17 | 案例篇：如何利用系统缓存优化程序的运行效率？
09-09
16 | 基础篇：怎么理解内存中的Buffer和Cache？
09-09
15 | 基础篇：Linux内存是怎么工作的？
09-09
14 | 答疑（二）：如何用perf工具分析Java程序？
09-09
13 | 答疑（一）：无法模拟出 RES 中断的问题，怎么办？
09-09
12 | 套路篇：CPU 性能优化的几个思路
09-09
11 | 套路篇：如何迅速分析出系统CPU的瓶颈在哪里？
09-09
10 | 案例篇：系统的软中断CPU使用率升高，我该怎么办？
09-09
09 | 基础篇：怎么理解Linux软中断？
09-09
08 | 案例篇：系统中出现大量不可中断进程和僵尸进程怎么办？（下）
09-09
07 | 案例篇：系统中出现大量不可中断进程和僵尸进程怎么办？（上）
09-09
06 | 案例篇：系统的 CPU 使用率很高，但为啥却找不到高 CPU 的应用？
09-09
05 | 基础篇：某个应用的CPU使用率居然达到100%，我该怎么办？
09-09
04 | 基础篇：经常说的 CPU 上下文切换是什么意思？（下）
09-09
03 | 基础篇：经常说的 CPU 上下文切换是什么意思？（上）
09-09
02 | 基础篇：到底应该怎么理解“平均负载”？
09-09
01 | 如何学习Linux性能优化？
09-09
开篇词 | 别再让Linux性能问题成为你的绊脚石
09-09
结束语 | 聊一聊机遇、方向、能力、努力！
07-26
加餐十 | 如何接手一坨烂业务代码？如何在烂业务代码中成长？
07-26
加餐九 | 作为面试官或候选人，如何面试或回答设计模式问题？
07-26
加餐八 | 程序员怎么才能让自己走得更高、更远？
07-26
加餐七 | 基础学科的知识如何转化成实际的技术生产力？
07-26
加餐六 | 什么才是所谓的编程能力？如何考察一个人的编程能力？
07-26
加餐五 | 听一听小争哥对Google工程师文化的解读
07-26
加餐四 | 聊一聊Google那些让我快速成长的地方
07-26
加餐三 | 聊一聊Google是如何做Code Review的
07-26
春节特别加餐 | 王争：如何学习《设计模式之美》专栏？
07-26
加餐二 | 设计模式、重构、编程规范等相关书籍推荐
07-26
加餐一 | 用一篇文章带你了解专栏中用到的所有Java语法
07-26
100 | 如何将设计思想、原则、模式等理论知识应用到项目中？
07-26
99 | 总结回顾：在实际软件开发中常用的设计思想、原则和模式
07-26
98 | 项目实战三：设计实现一个支持自定义规则的灰度发布组件（实现）
07-26
97 | 项目实战三：设计实现一个支持自定义规则的灰度发布组件（设计）
07-26
96 | 项目实战三：设计实现一个支持自定义规则的灰度发布组件（分析）
07-26
95 | 项目实战二：设计实现一个通用的接口幂等框架（实现）
07-26
94 | 项目实战二：设计实现一个通用的接口幂等框架（设计）
07-26
93 | 项目实战二：设计实现一个通用的接口幂等框架（分析）
07-26
92 | 项目实战一：设计实现一个支持各种算法的限流框架（实现）
07-26
91 | 项目实战一：设计实现一个支持各种算法的限流框架（设计）
07-26
90 | 项目实战一：设计实现一个支持各种算法的限流框架（分析）
07-26
89 | 开源实战五（下）：总结MyBatis框架中用到的10种设计模式
07-26
88 | 开源实战五（中）：如何利用职责链与代理模式实现MyBatis Plugin？
07-26
87 | 开源实战五（上）：MyBatis如何权衡易用性、性能和灵活性？
07-26
86 | 开源实战四（下）：总结Spring框架用到的11种设计模式
07-26
85 | 开源实战四（中）：剖析Spring框架中用来支持扩展的两种设计模式
07-26
84 | 开源实战四（上）：剖析Spring框架中蕴含的经典设计思想或原则
07-26
83 | 开源实战三（下）：借Google Guava学习三大编程范式中的函数式编程
07-26
82 | 开源实战三（中）：剖析Google Guava中用到的几种设计模式
07-26
81 | 开源实战三（上）：借Google Guava学习发现和开发通用功能模块
07-26
80 | 开源实战二（下）：从Unix开源开发学习应对大型复杂项目开发
07-26
79 | 开源实战二（中）：从Unix开源开发学习应对大型复杂项目开发
07-26
78 | 开源实战二（上）：从Unix开源开发学习应对大型复杂项目开发
07-26
77 | 开源实战一（下）：通过剖析Java JDK源码学习灵活应用设计模式
07-26
76 | 开源实战一（上）：通过剖析Java JDK源码学习灵活应用设计模式
07-26
75 | 在实际的项目开发中，如何避免过度设计？又如何避免设计不足？
07-26
74 | 总结回顾23种经典设计模式的原理、背后的思想、应用场景等
07-26
73 | 中介模式：什么时候用中介模式？什么时候用观察者模式？
07-26
72 | 解释器模式：如何设计实现一个自定义接口告警规则功能？
07-26
71 | 命令模式：如何利用命令模式实现一个手游后端架构？
07-26
70 | 备忘录模式：对于大对象的备份和恢复，如何优化内存和时间的消耗？
07-26
69 | 访问者模式（下）：为什么支持双分派的语言不需要访问者模式？
07-26
68 | 访问者模式（上）：手把手带你还原访问者模式诞生的思维过程
07-26
67 | 迭代器模式（下）：如何设计实现一个支持“快照”功能的iterator？
07-26
66 | 迭代器模式（中）：遍历集合的同时，为什么不能增删集合元素？
07-26
65 | 迭代器模式（上）：相比直接遍历集合数据，使用迭代器有哪些优势？
07-26
64 | 状态模式：游戏、工作流引擎中常用的状态机是如何实现的？
07-26
63 | 职责链模式（下）：框架中常用的过滤器、拦截器是如何实现的？
07-26
62 | 职责链模式（上）：如何实现可灵活扩展算法的敏感信息过滤框架？
07-26
61 | 策略模式（下）：如何实现一个支持给不同大小文件排序的小程序？
07-26
60 | 策略模式（上）：如何避免冗长的if-else/switch分支判断代码？
07-26
59 | 模板模式（下）：模板模式与Callback回调函数有何区别和联系？
07-26
58 | 模板模式（上）：剖析模板模式在JDK、Servlet、JUnit等中的应用
07-26
57 | 观察者模式（下）：如何实现一个异步非阻塞的EventBus框架？
07-26
56 | 观察者模式（上）：详解各种应用场景下观察者模式的不同实现方式
07-26
55 | 享元模式（下）：剖析享元模式在Java Integer、String中的应用
07-26
54 | 享元模式（上）：如何利用享元模式优化文本编辑器的内存占用？
07-26
53 | 组合模式：如何设计实现支持递归遍历的文件系统目录树结构？
07-26
52 | 门面模式：如何设计合理的接口粒度以兼顾接口的易用性和通用性？
07-26
51 | 适配器模式：代理、适配器、桥接、装饰，这四个模式有何区别？
07-26
50 | 装饰器模式：通过剖析Java IO类库源码学习装饰器模式
07-26
49 | 桥接模式：如何实现支持不同类型和渠道的消息推送系统？
07-26
48 | 代理模式：代理在RPC、缓存、监控等场景中的应用
07-26
47 | 原型模式：如何最快速地clone一个HashMap散列表？
07-26
46 | 建造者模式：详解构造函数、set方法、建造者模式三种对象创建方式
07-26
45 | 工厂模式（下）：如何设计实现一个Dependency Injection框架？
07-26
44 | 工厂模式（上）：我为什么说没事不要随便用工厂模式创建对象？
07-26
43 | 单例模式（下）：如何设计实现一个集群环境下的分布式单例模式？
07-26
42 | 单例模式（中）：我为什么不推荐使用单例模式？又有何替代方案？
07-26
41 | 单例模式（上）：为什么说支持懒加载的双重检测不比饿汉式更优？
07-26
40 | 运用学过的设计原则和思想完善之前讲的性能计数器项目（下）
07-26
39 | 运用学过的设计原则和思想完善之前讲的性能计数器项目（上）
07-26
38 | 总结回顾面向对象、设计原则、编程规范、重构技巧等知识点
07-26
37 | 实战二（下）：重构ID生成器项目中各函数的异常处理代码
07-26
36 | 实战二（上）：程序出错该返回啥？NULL、异常、错误码、空对象？
07-26
35 | 实战一（下）：手把手带你将ID生成器代码从“能用”重构为“好用”
07-26
34 | 实战一（上）：通过一段ID生成器代码，学习如何发现代码质量问题
07-26
33 | 理论五：让你最快速地改善代码质量的20条编程规范（下）
07-26
32 | 理论五：让你最快速地改善代码质量的20条编程规范（中）
07-26
31 | 理论五：让你最快速地改善代码质量的20条编程规范（上）
07-26
30 | 理论四：如何通过封装、抽象、模块化、中间层等解耦代码？
07-26
29 | 理论三：什么是代码的可测试性？如何写出可测试性好的代码？
07-26
28 | 理论二：为了保证重构不出错，有哪些非常能落地的技术手段？
07-26
27 | 理论一：什么情况下要重构？到底重构什么？又该如何重构？
07-26
26 | 实战二（下）：如何实现一个支持各种统计规则的性能计数器？
07-26
25 | 实战二（上）：针对非业务的通用框架开发，如何做需求分析和设计？
07-26
24 | 实战一（下）：如何实现一个遵从设计原则的积分兑换系统？
07-26
23 | 实战一（上）：针对业务系统的开发，如何做需求分析和设计？
07-26
22 | 理论八：如何用迪米特法则（LOD）实现“高内聚、松耦合”？
07-26
21 | 理论七：重复的代码就一定违背DRY吗？如何提高代码的复用性？
07-26
20 | 理论六：我为何说KISS、YAGNI原则看似简单，却经常被用错？
07-26
19 | 理论五：控制反转、依赖反转、依赖注入，这三者有何区别和联系？
07-26
18 | 理论四：接口隔离原则有哪三种应用？原则中的“接口”该如何理解？
07-26
17 | 理论三：里式替换（LSP）跟多态有何区别？哪些代码违背了LSP？
07-26
16 | 理论二：如何做到“对扩展开放、修改关闭”？扩展和修改各指什么？
07-26
15 | 理论一：对于单一职责原则，如何判定某个类的职责是否够“单一”？
07-26
14 | 实战二（下）：如何利用面向对象设计和编程开发接口鉴权功能？
07-26
13 | 实战二（上）：如何对接口鉴权这样一个功能开发做面向对象分析？
07-26
12 | 实战一（下）：如何利用基于充血模型的DDD开发一个虚拟钱包系统？
07-26
11 | 实战一（上）：业务开发常用的基于贫血模型的MVC架构违背OOP吗？
07-26
10 | 理论七：为何说要多用组合少用继承？如何决定该用组合还是继承？
07-26
09 | 理论六：为什么基于接口而非实现编程？有必要为每个类都定义接口吗？
07-26
08 | 理论五：接口vs抽象类的区别？如何用普通的类模拟抽象类和接口？
07-26
07 | 理论四：哪些代码设计看似是面向对象，实际是面向过程的？
07-26
06 | 理论三：面向对象相比面向过程有哪些优势？面向过程真的过时了吗？
07-26
05 | 理论二：封装、抽象、继承、多态分别可以解决哪些编程问题？
07-26
04 | 理论一：当谈论面向对象的时候，我们到底在谈论什么？
07-26
03 | 面向对象、设计原则、设计模式、编程规范、重构，这五者有何关系？
07-26
02 | 从哪些维度评判代码质量的好坏？如何具备写出高质量代码的能力？
07-26
01 | 为什么说每个程序员都要尽早地学习并掌握设计模式相关知识？
07-26
开篇词 | 一对一的设计与编码集训，让你告别没有成长的烂代码！
07-26
“趣谈Linux操作系统”食用指南
07-26
结束语 | 永远别轻视任何技术，也永远别轻视自己
07-26
期末测试 | 这些操作系统问题，你真的掌握了吗？
07-26
66 | 知识串讲：用一个创业故事串起操作系统原理（五）
07-26
65 | 知识串讲：用一个创业故事串起操作系统原理（四）
07-26
64 | 知识串讲：用一个创业故事串起操作系统原理（三）
07-26
63 | 知识串讲：用一个创业故事串起操作系统原理（二）
07-26
62 | 知识串讲：用一个创业故事串起操作系统原理（一）
07-26
61 | 搭建操作系统实验环境（下）：授人以鱼不如授人以渔
07-26
60 | 搭建操作系统实验环境（上）：授人以鱼不如授人以渔
07-26
59 | 数据中心操作系统：上市敲钟
07-26
58 | cgroup技术：内部创业公司应该独立核算成本
07-26
57 | Namespace技术：内部创业公司应该独立运营
07-26
56 | 容器：大公司为保持创新，鼓励内部创业
07-26
55 | 网络虚拟化：如何成立独立的合作部？
07-26
54 | 存储虚拟化（下）：如何建立自己保管的单独档案库？
07-26
53 | 存储虚拟化（上）：如何建立自己保管的单独档案库？
07-26
52 | 计算虚拟化之内存：如何建立独立的办公室？
07-26
51 | 计算虚拟化之CPU（下）：如何复用集团的人力资源？
07-26
50 | 计算虚拟化之CPU（上）：如何复用集团的人力资源？
07-26
49 | 虚拟机：如何成立子公司，让公司变集团？
07-26
48 | 接收网络包（下）：如何搞明白合作伙伴让我们做什么？
07-26
47 | 接收网络包（上）：如何搞明白合作伙伴让我们做什么？
07-26
46 | 发送网络包（下）：如何表达我们想让合作伙伴做什么？
07-26
45 | 发送网络包（上）：如何表达我们想让合作伙伴做什么？
07-26
44 | Socket内核数据结构：如何成立特大项目合作部？
07-26
43 | Socket通信：遇上特大项目，要学会和其他公司合作
07-26
43 预习 | Socket通信之网络协议基本原理
07-26
42 | IPC（下）：不同项目组之间抢资源，如何协调？
07-26
41 | IPC（中）：不同项目组之间抢资源，如何协调？
07-26
40 | IPC（上）：不同项目组之间抢资源，如何协调？
07-26
39 | 管道：项目组A完成了，如何交接给项目组B？
07-26
38 | 信号（下）：项目组A完成了，如何及时通知项目组B？
07-26
37 | 信号（上）：项目组A完成了，如何及时通知项目组B？
07-26
36 | 进程间通信：遇到大项目需要项目组之间的合作才行
07-26
35 | 块设备（下）：如何建立代理商销售模式？
07-26
34 | 块设备（上）：如何建立代理商销售模式？
07-26
33 | 字符设备（下）：如何建立直销模式？
07-26
32 | 字符设备（上）：如何建立直销模式？
07-26
31 | 输入与输出：如何建立售前售后生态体系？
07-26
30 | 文件缓存：常用文档应该放在触手可得的地方
07-26
29 | 虚拟文件系统：文件多了就需要档案管理系统
07-26
28 | 硬盘文件系统：如何最合理地组织档案库的文档？
07-26
27 | 文件系统：项目成果要归档，我们就需要档案库
07-26
26 | 内核态内存映射：如何找到正确的会议室？
07-26
25 | 用户态内存映射：如何找到正确的会议室？
07-26
24 | 物理内存管理（下）：会议室管理员如何分配会议室？
07-26
23 | 物理内存管理（上）：会议室管理员如何分配会议室？
07-26
22 | 进程空间管理：项目组还可以自行布置会议室
07-26
21 | 内存管理（下）：为客户保密，项目组独享会议室封闭开发
07-26
20 | 内存管理（上）：为客户保密，规划进程内存空间布局
07-26
19 | 线程的创建：如何执行一个新子项目？
07-26
18 | 进程的创建：如何发起一个新项目？
07-26
17 | 调度（下）：抢占式调度是如何发生的？
07-26
16 | 调度（中）：主动调度是如何发生的？
07-26
15 | 调度（上）：如何制定项目管理流程？
07-26
14 | 进程数据结构（下）：项目多了就需要项目管理系统
07-26
13 | 进程数据结构（中）：项目多了就需要项目管理系统
07-26
12 | 进程数据结构（上）：项目多了就需要项目管理系统
07-26
11 | 线程：如何让复杂的项目并行执行？
07-26
10 | 进程：公司接这么多项目，如何管？
07-26
09 | 系统调用：公司成立好了就要开始接项目
07-26
08 | 内核初始化：生意做大了就得成立公司
07-26
07 | 从BIOS到bootloader：创业伊始，有活儿老板自己上
07-26
06 | x86架构：有了开放的架构，才能打造开放的营商环境
07-26
05 | 学会几个系统调用：咱们公司能接哪些类型的项目？
07-26
04 | 快速上手几个Linux命令：每家公司都有自己的黑话
07-26
03 | 你可以把Linux内核当成一家软件外包公司的老板
07-26
02 | 学习路径：爬过这六个陡坡，你就能对Linux了如指掌
07-26
01 | 入学测验：你究竟对Linux操作系统了解多少？
07-26
开篇词 | 为什么要学习Linux操作系统？
07-26
27｜从Midjourney开始，探索AI产品的用户体验
07-08
26｜Visual ChatGPT是如何做到边聊边画的？
07-08
25｜ControlNet：让你的图拥有一个“骨架”
07-08
24｜Stable Diffusion：最热门的开源AI画图工具
07-08
23｜OpenClip：让我们搞清楚图片说了些什么
07-08
22｜再探HuggingFace：一键部署自己的大模型
07-08
21｜DID和PaddleGAN：表情生动的数字人播报员
07-08
20｜TTS与语音合成：让你的机器人拥有声音
07-08
19｜Whisper+ChatGPT：请AI代你听播客
07-08
18｜流式生成与模型微调，打造极致的对话体验
07-08
17 ｜ 让AI做决策，LangChain里的“中介”和“特工”
07-08
16｜Langchain里的“记忆力”，让AI只记住有用的事儿
07-08
15｜深入使用LLMChain，给AI连上Google和计算器
07-08
14｜链式调用，用LangChain简化多步提示语
07-08
13 ｜让AI帮你写测试，体验多步提示语
07-08
12｜让AI帮你写个小插件，轻松处理Excel文件
07-08
11｜省下钱买显卡，如何利用开源模型节约成本？
07-08
10｜AI连接外部资料库，让Llama Index带你阅读一本书
07-08
09｜语义检索，利用Embedding优化你的搜索功能
07-08
08｜文本改写和内容审核，别让你的机器人说错话
07-08
07｜文本聚类与摘要，让AI帮你做个总结
07-08
06｜ChatGPT来了，让我们快速做个AI应用
07-08
05｜善用Embedding，我们来给文本分分类
07-08
04｜新时代模型性能大比拼，GPT-3到底胜在哪里？
07-08
03｜巧用提示语，说说话就能做个聊天机器人
07-08
02｜无需任何机器学习，如何利用大语言模型做情感分析？
07-08
01｜重新出发，让我们学会和AI说话
07-08
导读｜从今天开始，让AI成为你的贴身助理
07-08
开篇词｜GPT来了，跑步迎接AI爆发的时代
07-08
期末测试 | 来赴一场满分之约吧～
03-29
结束语｜下一步，我该如何在公司落地 GitOps？
03-29
40｜命令式和声明式，谁才是驱动云原生的“引擎”？
03-29
39｜GitOps 最佳实践，ArgoCD 凭什么脱颖而出？
03-29
38｜GitOps 为什么成为云原生交付的事实标准？
03-29
37｜我该从哪些方向了解云原生领域？
03-29
36｜作为开发者，如何更好地了解 CNCF？
03-29
35｜秒级开发体验，如何实现容器热加载和一键调试？
03-29
34｜GitOps 开发循环慢，时间都去哪了？
03-29
33｜告警：如何搭建基于 HTTP 状态告警？
03-29
32｜监控：如何快速搭建业务 HTTP 健康状态监控？
03-29
31｜日志：如何搭建轻量云原生业务日志系统？
03-29
30｜应用健康：如何迅速判断业务状态和可用性？
03-29
29｜安全提升：如何解决 GitOps 的秘钥存储问题？
03-29
28｜安全提升：GitOps 在哪些环节需要关注安全问题？
03-29
27｜开发互不干扰，如何实现自动多环境管理？
03-29
26｜生产稳定的秘密武器：如何实施自动化渐进式交付？
03-29
25｜生产稳定的秘密武器：如何实施金丝雀发布？
03-29
24｜生产稳定的秘密武器：如何实施蓝绿发布？
03-29
23｜如何监听镜像版本变化触发 GitOps？
03-29
22｜如何使用 ArgoCD 快速打造生产可用的 GitOps 工作流？
03-29
21｜应用定义：如何使用 Helm 定义应用？
03-29
20｜应用定义：如何使用 Kustomize 定义应用？
03-29
19｜自托管构建：如何使用 Harbor 搭建企业级镜像仓库？
03-29
18｜自托管构建：如何使用 Tekton 构建镜像？
03-29
17｜自动构建：如何使用 GitLab CI 构建镜像？
03-29
16｜自动构建：如何使用 GitHub Action 构建镜像？
03-29
15｜容器化：如何选择最适合业务的基础镜像？
03-29
14｜容器化：如何将镜像体积缩减 90%？
03-29
13｜容器化：如何为不同语言快速构建多平台镜像？
03-29
12｜如何自动检查业务真实的健康状态？
03-29
11｜K8s 极简实战（六）：如何保障业务资源需求和自动弹性扩容？
03-29
10 | K8s 极简实战（五）：如何将集群的业务服务暴露外网访问？
03-29
09｜如何迁移应用配置？
03-29
08｜K8s 极简实战（三）：如何解决服务发现问题？
03-29
07｜K8s 极简实战（二）：如何为业务选择最适合的工作负载类型？
03-29
06 | 如何使用命名空间隔离团队及应用环境？
03-29
05｜K8s 极简实战：示例应用介绍
03-29
04｜如何借助GitOps实现应用秒级自动发布和回滚？
03-29
03 | 业务永不宕机，K8s如何实现自动扩容和自愈？
03-29
02 | 如何将容器镜像部署到K8s？
03-29
01｜如何将业务代码构建为容器镜像？
03-29
开篇词｜30-60K，转型云原生架构师和SRE需要哪些能力？
03-29
期末测试丨快来测测你对专栏内容掌握到何种程度了
03-29
结束语丨期待未来的你，成为优秀的软件架构师
03-29
加餐 | 软件设计文档示例模板
03-29
答疑丨工作中的交往和沟通，都有哪些小技巧呢？
03-29
38丨技术管理之道：你真的要转管理吗？
03-29
37丨技术沟通之道：如何解决问题？
03-29
36丨技术落地之道：你真的知道自己要解决的问题是什么吗？
03-29
35 | 技术进阶之道：你和这个星球最顶级的程序员差几个等级？
03-29
34 | 技术修炼之道：同样工作十几年，为什么有的人成为大厂架构师，有的人失业？
03-29
答疑丨互联网需要解决的技术问题是什么？
03-29
33 | 区块链技术架构：区块链到底能做什么？
03-29
32 | AI与物联网架构：从智能引擎到物联网平台
03-29
31 | 大数据架构：大数据技术架构的思想和原理是什么？
03-29
30 | 安全性架构：为什么说用户密码泄漏是程序员的锅？
03-29
29 | 高可用架构：我们为什么感觉不到淘宝应用升级时的停机？
03-29
28 | 高性能架构：除了代码，你还可以在哪些地方优化性能？
03-29
27 | 微服务架构：微服务究竟是灵丹还是毒药？
03-29
26 | 搜索引擎架构：如何瞬间完成海量数据检索？
03-29
25 | 数据存储架构：如何改善系统的数据存储能力？
03-29
24 | 负载均衡架构：如何用10行代码实现一个负载均衡服务？
03-29
23 | 异步架构：如何避免互相依赖的系统间耦合？
03-29
22 | 缓存架构：如何减少不必要的计算？
03-29
21丨分布式架构：如何应对高并发的用户请求
03-29
答疑丨对于设计模式而言，场景到底有多重要？
03-29
20 | 领域驱动设计：35岁的程序员应该写什么样的代码？
03-29
19 | 组件设计原则：组件的边界在哪里？
03-29
18 | 反应式编程框架设计：如何使程序调用不阻塞等待，立即响应？
03-29
17 | 设计模式应用：编程框架中的设计模式
03-29
16 | 设计模式基础：不会灵活应用设计模式，你就没有掌握面向对象编程
03-29
15丨软件设计的接口隔离原则：如何对类的调用者隐藏类的公有方法？
03-29
14 | 软件设计的单一职责原则：为什么说一个类文件打开最好不要超过一屏？
03-29
13丨软件设计的里氏替换原则：正方形可以继承长方形吗？
03-29
12 | 软件设计的依赖倒置原则：如何不依赖代码却可以复用它的功能？
03-29
11丨软件设计的开闭原则：如何不修改代码却能实现需求变更？
03-29
10 | 软件设计的目的：糟糕的程序员比优秀的程序员差在哪里？
03-29
09丨软件设计实践：如何使用UML完成一个设计文档？
03-29
08丨软件设计的方法论：软件为什么要建模？
03-29
答疑丨Java Web程序的运行时环境到底是怎样的？
03-29
07丨编程语言原理：面向对象编程是编程的终极形态吗？
03-29
06丨数据库原理：为什么PrepareStatement性能更好更安全？
03-29
05丨文件系统原理：如何用1分钟遍历一个100TB的文件？
03-29
04丨网络编程原理：一个字符的互联网之旅
03-29
03丨Java虚拟机原理：JVM为什么被称为机器（machine）？
03-29
02丨数据结构原理：Hash表的时间复杂度为什么是O(1)？
03-29
01丨程序运行原理：程序是如何运行又是如何崩溃的？
03-29
开篇词 | 掌握软件开发技术的第一性原理
03-29
期末测试题丨快来测试一下你对性能掌握到何种程度了吧！
03-29
结束语丨见过林林总总的乱象，才知未来的无限可能
03-29
32丨当Postgres磁盘读引起I/O高的时候，应该怎么办？
03-29
31丨案例：当磁盘参数导致I/O高的时候，应该怎么办？
03-29
30丨案例：为什么参数化数据会导致TPS突然下降？
03-29
29丨案例：如何应对因网络参数导致的TPS呈锯齿状？
03-29
28丨案例：带宽消耗以及Swap（下）
03-29
27丨案例：带宽消耗以及Swap（上）
03-29
26丨案例：手把手带你理解TPS趋势分析
03-29
25丨SkyWalking：性能监控工具之链路级监控及常用计数器解析
03-29
24丨Kafka：性能监控工具之队列级监控及常用计数器解析
03-29
23丨MySQL：数据库级监控及常用计数器解析（下）
03-29
22丨MySQL：数据库级监控及常用计数器解析（上）
03-29
21丨Tomcat：中间件监控及常用计数器解析
03-29
20丨Java & C ++：代码级监控及常用计数器解析（下）
03-29
19丨Java & C ++：代码级监控及常用计数器解析（上）
03-29
18丨CentOS：操作系统级监控及常用计数器解析（下）
03-29
17丨CentOS：操作系统级监控及常用计数器解析（上）
03-29
16丨案例：性能监控工具之Grafana+Prometheus+Exporters
03-29
春节策划丨快来挑战一下自己的分析逻辑吧！
03-29
春节策划丨性能评估和性能分析试题，等你挑战！
03-29
15丨性能测试场景：如何进行监控设计？
03-29
14丨性能测试场景：如何理解业务模型？
03-29
13丨性能测试场景：如何进行场景设计？
03-29
12丨性能场景：做参数化之前，我们需要考虑什么？
03-29
11丨性能脚本：用案例和图示帮你理解HTTP协议
03-29
10丨案例：在JMeter中如何设置参数化数据？
03-29
09丨关联和断言：一动一静，核心都是在取数据
03-29
08丨案例： 手把手教你编写最简单的性能脚本
03-29
07丨性能测试工具：如何录制脚本？
03-29
06丨倾囊相授：我毕生所学的性能分析思路都在这里了
03-29
05丨指标关系：你知道并发用户数应该怎么算吗？
03-29
04丨JMeter和LoadRunner：要知道工具仅仅只是工具
03-29
03丨性能综述：怎么理解TPS、QPS、RT、吞吐量这些性能指标？
03-29
02丨性能综述：TPS和响应时间之间是什么关系？
03-29
01丨性能综述：性能测试的概念到底是什么？
03-29
开篇词丨“老板，之前咱TPS是100，我优化完是10000”
03-29
结课测试 | 高并发系统设计的相关知识，你都掌握了吗？
03-29
春节特别策划 | 我们如何准备抵抗流量峰值？
03-29
春节特别策划 | 高并发下如何发现和排查问题？
03-29
结课问卷获奖用户名单
03-29
结束语 | 学不可以已
03-29
40 | 信息流设计（二）：通用信息流系统的拉模式要如何做？
03-29
39 | 信息流设计（一）：通用信息流系统的推模式要如何做？
03-29
38 | 计数系统设计（二）：50万QPS下如何设计未读数系统？
03-29
37 | 计数系统设计（一）：面对海量数据的计数器要如何做？
03-29
36 | 面试现场第三期：你要如何准备一场技术面试呢？
03-29
35 | 流量控制：高并发系统中我们如何操纵流量？
03-29
34 | 降级熔断：如何屏蔽非核心系统故障的影响？
03-29
33 | 配置管理：成千上万的配置项要如何管理？
03-29
32 | 压力测试：怎样设计全链路压力测试平台？
03-29
31 | 应用性能管理：用户的使用体验应该如何监控？
03-29
30 | 给系统加上眼睛：服务端监控要怎么做？
03-29
29 | Service Mesh：如何屏蔽服务化系统的服务治理细节？
03-29
28 | 多机房部署：跨地域的分布式系统如何做？
03-29
27 | API网关：系统的门面要如何做呢？
03-29
26 | 负载均衡：怎样提升系统的横向扩展能力？
03-29
25 | 分布式Trace：横跨几十个分布式组件的慢请求要如何排查？
03-29
24 | 注册中心：分布式系统如何寻址？
03-29
23 | RPC框架：10万QPS下如何实现毫秒级的服务调用？
03-29
22 | 微服务架构：微服务化后系统架构要如何改造？
03-29
21 | 系统架构：每秒1万次请求的系统要做服务化拆分吗？
03-29
期中测试 | 10道高并发系统设计题目自测
03-29
用户故事 | 从“心”出发，我还有无数个可能
03-29
20 | 面试现场第二期：当问到项目经历时，面试官究竟想要了解什么？
03-29
19 | 消息队列：如何降低消息队列系统中消息的延迟？
03-29
18 | 消息投递：如何保证消息仅仅被消费一次？
03-29
17 | 消息队列：秒杀时如何处理每秒上万次的下单请求？
03-29
加餐 | 数据的迁移应该如何做？
03-29
16 | CDN：静态资源如何加速？
03-29
15 | 缓存的使用姿势（三）：缓存穿透了怎么办？
03-29
14 | 缓存的使用姿势（二）：缓存如何做到高可用？
03-29
13 | 缓存的使用姿势（一）：如何选择缓存的读写策略？
03-29
12 | 缓存：数据库成为瓶颈后，动态数据的查询要如何加速？
03-29
11 | NoSQL：在高并发场景下，数据库和NoSQL如何做到互补？
03-29
10 | 发号器：如何保证分库分表后ID的全局唯一性？
03-29
09 | 数据库优化方案（二）：写入数据量增加时，如何实现分库分表？
03-29
08 | 数据库优化方案（一）：查询请求增加时，如何做主从分离？
03-29
07 | 池化技术：如何减少频繁创建数据库连接的性能损耗？
03-29
06 | 面试现场第一期：当问到组件实现原理时，面试官是在刁难你吗？
03-29
05 | 系统设计目标（三）：如何让系统易于扩展？
03-29
04 | 系统设计目标（二）：系统怎样做到高可用？
03-29
03 | 系统设计目标（一）：如何提升系统性能？
03-29
02 | 架构分层：我们为什么一定要这么做？
03-29
01 | 高并发系统：它的通用设计方法是什么？
03-29
开篇词 | 为什么你要学习高并发系统设计？
03-29
结课测试 | 这些Go语言的知识你都掌握了吗？
03-29
新年彩蛋 | 完整版思考题答案
03-29
尾声 | 愿你披荆斩棘，所向无敌
03-29
49 | 程序性能分析基础（下）
03-29
48 | 程序性能分析基础（上）
03-29
47 | 基于HTTP协议的网络服务
03-29
46 | 访问网络服务
03-29
45 | 使用os包中的API （下）
03-29
44 | 使用os包中的API （上）
03-29
43 | bufio包中的数据类型（下）
03-29
42 | bufio包中的数据类型 （上）
03-29
41 | io包中的接口和工具 （下）
03-29
40 | io包中的接口和工具 （上）
03-29
39 | bytes包与字节串操作（下）
03-29
38 | bytes包与字节串操作（上）
03-29
37 | strings包与字符串操作
03-29
36 | unicode与字符编码
03-29
35 | 并发安全字典sync.Map (下)
03-29
34 | 并发安全字典sync.Map （上）
03-29
33 | 临时对象池sync.Pool
03-29
32 | context.Context类型
03-29
31 | sync.WaitGroup和sync.Once
03-29
30 | 原子操作（下）
03-29
29 | 原子操作（上）
03-29
28 | 条件变量sync.Cond （下）
03-29
27 | 条件变量sync.Cond （上）
03-29
26 | sync.Mutex与sync.RWMutex
03-29
25 | 更多的测试手法
03-29
24 | 测试的基本规则和流程（下）
03-29
23 | 测试的基本规则和流程 （上）
03-29
22 | panic函数、recover函数以及defer语句（下）
03-29
21 | panic函数、recover函数以及defer语句 （上）
03-29
20 | 错误处理 （下）
03-29
19 | 错误处理（上）
03-29
18 | if语句、for语句和switch语句
03-29
17 | go语句及其执行规则（下）
03-29
16 | go语句及其执行规则（上）
03-29
15 | 关于指针的有限操作
03-29
14 | 接口类型的合理运用
03-29
13 | 结构体及其方法的使用法门
03-29
12 | 使用函数的正确姿势
03-29
11 | 通道的高级玩法
03-29
10 | 通道的基本操作
03-29
09 | 字典的操作和约束
03-29
08 | container包中的那些容器
03-29
07 | 数组和切片
03-29
06 | 程序实体的那些事儿 （下）
03-29
05 | 程序实体的那些事儿（中）
03-29
04 | 程序实体的那些事儿（上）
03-29
03 | 库源码文件
03-29
02 | 命令源码文件
03-29
01 | 工作区和GOPATH
03-29
导读 | 学习专栏的正确姿势
03-29
导读 | 写给0基础入门的Go语言学习者
03-29
开篇词 | 跟着学，你也能成为Go语言高手
03-29
结课测试｜这些金融架构的问题，你都掌握了么？
01-16
结束语 | 金融之道，与你同行，虽远尤欣
01-16
春节策划第3期 | 如何运用架构知识解读春运买票和手游案例？
01-16
春节策划第2期 | 读书如抽丝，为你推荐一些我读过的好书
01-16
春节策划第1期 | 分布式金融系统知识，你掌握了多少？
01-16
答疑集锦（三） | 思考题解析与数据库底层实现
01-16
21 | 容灾（下）：如何通过混沌工程提高系统稳定性？
01-16
20 | 容灾（上）如何实现正确的跨机房实时容灾？
01-16
19 | 正确性案例（下）：如何在运行时进行数据系统的动态分库？
01-16
18 | 正确性案例（中）：常见分布式数据方案的设计原理是什么？
01-16
17 | 正确性案例（上）：如何实现分布式的事件溯源架构？
01-16
16 | 分布式一致性（下）：怎么理解最简单的分布式一致性算法？
01-16
15 | 分布式正确性的存在性（上）：什么情况下不存在分布式共识算法？
01-16
14 | 正确性分级（下）：多机有容灾有哪几种不同的一致性？
01-16
13 | 正确性分级（中）：多机无容灾有哪几种不同的一致性实现？
01-16
12 | 正确性分级（上）：单机无备份有哪几种不同的一致性？
01-16
答疑集锦（二） | 思考题解析与账务系统优化
01-16
11 | 系统优化：如何让金融系统运行得更快？
01-16
10 | 数据存储的合理性：金融业务可以不用关系型数据库吗？
01-16
09 | 数据传输的质量：金融业务对数据传输有什么要求？
01-16
08 | 计算结果的正确性：怎么保证计算结果是正确的？
01-16
07 | 计算过程的正确性：如何设计正确的数据处理架构？
01-16
06 | 计算输入的正确性：怎么选择正确时间的数据？
01-16
答疑集锦（一） | 思考题解析与外汇架构知识拓展
01-16
05 | 领域驱动设计（下）：如何设计统一的金融业务模型？
01-16
04 | 领域驱动设计（上）：如何设计金融软件顶层架构？
01-16
03 | 产品大观：不同金融业务都有哪些技术实现要点？
01-16
02 | 原理解读：如何理解第三方支付的业务逻辑和系统组件？
01-16
01 | 业务初探：扫了二维码之后发生了什么？
01-16
开篇词 | 如何成为金融级人才？
01-16
期末测试｜来赴一场满分之约！
01-16
结束语｜在技术的世界里享受思维的乐趣
01-16
40｜垃圾回收：现代语言是如何自动管理回收内存的？
01-16
39｜Geohash：点外卖时我们是如何查找到附近餐厅的？
01-16
38｜倒排索引：搜索引擎是如何做全文检索的？
01-16
37｜Thrift编码方法：为什么RPC往往不采用JSON作为网络传输格式？
01-16
36｜分布式事务：如何理解两阶段提交？
01-16
35｜洗牌算法：随机的哲学，如何用程序来洗一副牌？
01-16
即学即练｜工程实战篇：复习卡一键直达
01-16
即学即练｜分布式篇：复习卡一键直达
01-16
即学即练｜计算机网络篇：复习卡 & 算法题特训
01-16
即学即练｜操作系统篇：复习卡 & 算法题特训
01-16
即学即练｜基础算法思想篇：复习卡 & 算法题特训
01-16
即学即练｜基础数据结构篇：复习卡 & 算法题特训
01-16
特别策划｜面试：BAT面试三关准备方法大揭秘
01-16
34｜前缀树：Web框架中如何实现路由匹配？
01-16
33｜限流算法：如何防止系统过载？
01-16
32｜时间轮：Kafka是如何实现定时任务的？
01-16
31｜跳表：Redis是如何存储有序集合的？
01-16
30｜布隆过滤器：如何解决Redis缓存穿透问题？
01-16
29｜位图：如何用更少空间对大量数据进行去重和排序？
01-16
28｜MVCC：如何突破数据库并发读写性能瓶颈？
01-16
27｜LSM Tree：LevelDB的索引是如何建立的？
01-16
26｜B+ Tree：PostgreSQL 的索引是如何建立的？
01-16
25｜一致性哈希：如何在集群上合理分配流量？
01-16
24｜UUID：如何高效生成全局的唯一ID？
01-16
23｜Raft：分布式系统间如何达成共识？
01-16
22｜PageRank：谷歌是如何计算网页排名的
01-16
21｜分而治之：MapReduce如何解决大规模分布式计算问题
01-16
20｜滑动窗口：TCP是如何进行流量控制和拥塞控制的？
01-16
19｜选路算法：距离矢量算法为什么会产生无穷计算问题？
01-16
18｜选路算法：链路状态算法是如何分发全局信息的
01-16
17｜选路算法：Dijkstra是如何解决最短路问题的？
01-16
16｜日志型文件系统：写入文件的时候断电了会发生什么？
01-16
15｜LRU：在虚拟内存中页面是如何置换的？
01-16
14｜调度算法：操作系统中的进程是如何调度的？
01-16
13｜哈夫曼树：HTTP2.0是如何更快传输协议头的？
01-16
12｜拓扑排序：Webpack是如何确定构建顺序的？
01-16
11｜字符串匹配：如何实现最快的grep工具
01-16
10｜搜索算法： 一起来写一个简单的爬虫？
01-16
09｜二分：如何高效查询Kafka中的消息？
01-16
08｜外部排序：如何为TB级数据排序？
01-16
07｜堆：如何实现一个高效的优先队列？
01-16
06｜TreeMap：红黑树真的有那么难吗？
01-16
05｜HashMap：一个优秀的散列表是怎么来的？
01-16
04｜栈：函数调用的秘密究竟是什么？
01-16
03｜双端队列：并行计算中的工作窃取算法如何实现？
01-16
02｜双向链表：list如何实现高效地插入与删除？
01-16
01｜动态数组：按需分配的vector为什么要二倍扩容？
01-16
先导篇｜诶，这个 git diff 好像不是很直观？
01-16
开篇词｜真实世界的算法，和你想的不一样
01-16
加餐｜谈谈Kong Ingress Controller
01-15
结束语｜是终点，更是起点
01-15
期末测试｜来赴一场满分之约！
01-15
33｜视频：高级篇实操总结
01-15
32｜实战演练：玩转Kubernetes（3）
01-15
31｜网络通信：CNI是怎么回事？又是怎么工作的？
01-15
30｜系统监控：如何使用Metrics Server和Prometheus？
01-15
29｜集群管理：如何用名字空间分隔系统资源？
01-15
28｜应用保障：如何让Pod运行得更健康？
01-15
27｜滚动更新：如何做到平滑的应用升级降级？
01-15
26｜StatefulSet：怎么管理有状态的应用？
01-15
25｜PersistentVolume + NFS：怎么使用网络共享存储？
01-15
24｜PersistentVolume：怎么解决数据持久化的难题？
01-15
加餐｜docker-compose：单机环境下的容器编排工具
01-15
23｜视频：中级篇实操总结
01-15
22｜实战演练：玩转Kubernetes（2）
01-15
21｜Ingress：集群进出流量的总管
01-15
20｜Service：微服务架构的应对之道
01-15
19｜Daemonset：忠实可靠的看门狗
01-15
18｜Deployment：让应用永不宕机
01-15
17｜更真实的云原生：实际搭建多节点的Kubernetes集群
01-15
16｜视频：初级篇实操总结
01-15
15｜实战演练：玩转Kubernetes（1）
01-15
14｜ConfigMap/Secret：怎样配置、定制我的应用
01-15
13｜Job/CronJob：为什么不直接用Pod来处理业务？
01-15
12｜Pod：如何理解这个Kubernetes里最核心的概念？
01-15
11｜YAML：Kubernetes世界里的通用语
01-15
加餐｜Kubernetes“弃用Docker”是怎么回事？
01-15
10｜自动化的运维管理：探究Kubernetes工作机制的奥秘
01-15
09｜走近云原生：如何在本机搭建小巧完备的Kubernetes环境
01-15
08｜视频：入门篇实操总结
01-15
07｜实战演练：玩转Docker
01-15
06｜打破次元壁：容器该如何与外界互联互通
01-15
05｜镜像仓库：该怎样用好Docker Hub这个宝藏
01-15
04｜创建容器镜像：如何编写正确、高效的Dockerfile
01-15
03｜容器化的应用：会了这些你就是Docker高手
01-15
02｜被隔离的进程：一起来看看容器的本质
01-15
01｜初识容器：万事开头难
01-15
课前准备｜动手实践才是最好的学习方式
01-15
开篇词｜迎难而上，做云原生时代的弄潮儿
01-15
期末考试 |《全链路压测实战30讲》满分试卷，等你来挑战！
01-15
结束语 | 做能落地的全链路压测项目
01-15
35 | 压测报告：怎样写出一份让老板满意的报告？
01-15
34 | 容量规划：如何精准地对生产系统做容量预估？
01-15
33 | 异常场景：如何模拟线上不同组件的异常场景？
01-15
32 | 稳定性场景：怎样搞定线上稳定性场景？
01-15
31 | 容量场景：决定线上容量场景的关键因素是什么？
01-15
30 | 预压测：如何基于小流量快速验证容量压测效果？
01-15
29 | 基准场景：一个案例，带你搞懂基准场景的关键要点
01-15
28 | 定向监控：怎样快速发现业务异常？
01-15
27 | 全局监控（下）：如何快速落地全局监控？
01-15
26 | 全局监控（上）：如何快速落地全局监控？
01-15
25 | 环境搭建：我们的系统是怎么搭建起来的？
01-15
24 | 压测平台：如何改造分布式调度平台？
01-15
23 | 压测平台：如何改造对象存储和性能监控？
01-15
22 | 压测平台：如何解决 GoReplay 动态数据关联？
01-15
21 | 压测平台：高效搭建 GoReplay 压测平台
01-15
20 | Mock：如何屏蔽第三方接口的影响？
01-15
19｜日志隔离：如何落地日志隔离？
01-15
18 | 流量隔离：RabbitMQ 消息隔离是怎么做的？
01-15
17 | 流量隔离：MongoDB 数据库隔离是怎么做的？
01-15
16 | 流量隔离：Redis 缓存隔离是怎么做的？
01-15
15 | 流量隔离：MySQL数据库隔离是怎么做的？
01-15
14 | 标记透传：如何基于微服务技术进行标记透传？
01-15
13 | 标记透传：微服务系统如何做标记透传方案选型？
01-15
12 | 链路追踪：如何对一个具体的项目进行追踪改造？
01-15
11 | 链路追踪：如何选择一款适合自己项目的工具？
01-15
10 | 场景执行：压测执行过程中的关键步骤是什么？
01-15
09 | 压测模型：如何建立一套完整的全链路压测模型？
01-15
08 | 基础设施：全链路压测的环境有什么特点？
01-15
07 | 全栈监控：如何设计全栈监控策略？
01-15
06 | 流量构建：流量平台如何选型？
01-15
05 | 铺底数据：真实的压测数据应该做成什么样子？
01-15
04 | 核心链路：如何梳理符合真实业务场景的核心链路？
01-15
03 | 压测方案：你是否忽略了一个重量级文档？
01-15
02 | RESAR 全链路流程：如何搞定所有容量场景？
01-15
01 | 全链路压测：为什么很多测试人员迷信它？
01-15
开篇词 | 打破认知神话，做接地气的全链路压测
01-15
新书 |《跃迁：从技术到管理的硅谷路径》
01-15
尾声：成长不是顿悟，而是练习
01-15
36 | 如何对更多的工作说“不”
01-15
35 | 理解并建立自己的工作弹性
01-15
34 | 如何从错误中成长？
01-15
33 | 技术人的犯错成本
01-15
32 | 硅谷人如何做 Code Review
01-15
31 | 工程师、产品经理、数据工程师是如何一起工作的？
01-15
30 | 编程马拉松
01-15
29 | 说说硅谷互联网公司的开发流程
01-15
28 | 如何激发团队人员的责任心
01-15
27 | 小议Java语言
01-15
26 | 如何做自己的职场规划？
01-15
25 | 兼容并包的领导方式
01-15
24 | 编程语言漫谈
01-15
23 | 如何处理工作中的人际关系？
01-15
22 | 不要做微观的管理者
01-15
21 | 每个工程师都应该了解的：中美在支付技术和大环境下的差异
01-15
20 | 项目管理中的三个技巧
01-15
19 | 硅谷面试：那些你应该知道的事儿
01-15
18 | 每个工程师都应该了解的：API 的设计和实现
01-15
17 | 管理者不用亲力亲为：关键是什么？
01-15
16 | 技术人如何建立个人影响力?
01-15
15 | 每个工程师都应该了解的：系统拆分
01-15
14 | 硅谷人到底忙不忙？
01-15
13 | 管理者在进行工作分配时，会考虑哪些问题？
01-15
12 | 每个工程师都应该了解的：数据库知识
01-15
11 | 管理和被管理：期望值差异
01-15
10 | 项目延期了，作为负责人该怎么办？
01-15
09 | 每个工程师都应该了解的：大数据时代的算法
01-15
08 | 说说硅谷公司中的一对一沟通
01-15
07 | 当别人给我们提意见时，该如何应对？
01-15
06 | 每个工程师都应该了解的：聊聊幂等
01-15
05 | 当我们给别人提意见时，要注意些什么？
01-15
04 | 如何帮助团队成员成长
01-15
03 | 每个工程师都应该了解的：A/B测试
01-15
02 | Bug引发事故，该不该追究责任？
01-15
01 | 职场分身术：从给答案到做引导
01-15
开篇词 | 从工程师到管理者，我的思考与实践
01-15
期末考试｜《Go语言项目开发实战》满分试卷，等你来挑战！
01-12
结束语 | 如何让自己的 Go 研发之路走得更远？
01-12
直播加餐｜如何从小白进阶成 Go 语言专家？
01-12
特别放送 | 分布式作业系统设计和实现
01-12
特别放送 | Go Modules实战
01-12
特别放送 | IAM排障指南
01-12
特别放送 | Go Modules依赖包管理全讲
01-12
特别放送 | 给你一份Go项目中最常用的Makefile核心语法
01-12
特别放送 | 给你一份清晰、可直接套用的Go编码规范
01-12
51 | 基于 GitHub Actions 的 CI 实战
01-12
50 | 服务编排（下）：基于Helm的服务编排部署实战
01-12
49 | 服务编排（上）：Helm服务编排基础知识
01-12
48 | IAM 容器化部署实战
01-12
47 | 如何编写Kubernetes资源定义文件？
01-12
46 | 如何制作Docker镜像？
01-12
45｜基于Kubernetes的云原生架构设计
01-12
44｜技术演进（下）：软件架构和应用生命周期技术演进之路
01-12
43｜技术演进（上）：虚拟化技术演进之路
01-12
42 | 软件部署实战（下）：IAM系统安全加固、水平扩缩容实战
01-12
41 | 软件部署实战（中）：IAM 系统生产环境部署实战
01-12
40 | 软件部署实战（上）：部署方案及负载均衡、高可用组件介绍
01-12
39｜性能分析（下）：API Server性能测试和调优实战
01-12
38｜性能分析（上）：如何分析 Go 语言代码的性能？
01-12
37 | 代码测试（下）：Go 语言其他测试类型及 IAM 测试介绍
01-12
36 | 代码测试（上）：如何编写 Go 语言单元测试和性能测试用例？
01-12
35 | 效率神器：如何设计和实现一个命令行客户端工具？
01-12
34 | SDK 设计（下）：IAM项目Go SDK设计和实现
01-12
33 | SDK 设计（上）：如何设计出一个优秀的 Go SDK？
01-12
32 | 数据处理：如何高效处理应用程序产生的数据？
01-12
31 | 数据流：通过iam-authz-server设计，看数据流服务的设计
01-12
30 | ORM：CURD 神器 GORM 包介绍及实战
01-12
29｜控制流（下）：iam-apiserver服务核心功能实现讲解
01-12
28 | 控制流（上）：通过iam-apiserver设计，看Web服务的构建
01-12
27 | 权限模型：5大权限模型是如何进行资源授权的？
01-12
26 | IAM项目是如何设计和实现访问认证功能的？
01-12
25 | 认证机制：应用程序如何进行访问认证？
01-12
24 | Web 服务：Web 服务核心功能有哪些，如何实现？
01-12
23 | 应用构建实战：如何构建一个优秀的企业应用框架？
01-12
22 | 应用构建三剑客：Pflag、Viper、Cobra 核心功能介绍
01-12
21 | 日志处理（下）：手把手教你从 0 编写一个日志包
01-12
20 | 日志处理（上）：如何设计日志包并记录日志？
01-12
19 | 错误处理（下）：如何设计错误包？
01-12
18 | 错误处理（上）：如何设计一套科学的错误码？
01-12
17 | API 文档：如何生成 Swagger API 文档 ？
01-12
16 | 代码检查：如何进行静态代码检查？
01-12
15 | 研发流程实战：IAM项目是如何进行研发流程管理的？
01-12
14 | 项目管理：如何编写高质量的Makefile？
01-12
13 | API 风格（下）：RPC API介绍
01-12
12 | API 风格（上）：如何设计RESTful API？
01-12
11 | 设计模式：Go常用设计模式概述
01-12
10 | 设计方法：怎么写出优雅的 Go 项目？
01-12
09 | 研发流程设计（下）：如何管理应用的生命周期？
01-12
08 | 研发流程设计（上）：如何设计 Go 项目的开发流程？
01-12
07 | 工作流设计：如何设计合理的多人开发模式？
01-12
06 | 目录结构设计：如何组织一个可维护、可扩展的代码目录？
01-12
05 | 规范设计（下）：commit 信息风格迥异、难以阅读，如何规范？
01-12
04 | 规范设计（上）：项目开发杂乱无章，如何规范？
01-12
03 | 项目部署：如何快速部署 IAM 系统？
01-12
02 | 环境准备：如何安装和配置一个基本的 Go 开发环境？
01-12
01 | IAM系统概述：我们要实现什么样的 Go 项目？
01-12
开篇词 | 从 0 开始搭建一个企业级 Go 应用
01-12
2022
结课测试 | 这些HTTP协议知识，你真的掌握了吗？
08-22
结束语 | 做兴趣使然的Hero
08-22
罗剑锋老师出新课了？
08-22
44 | 先睹为快：HTTP/3实验版本长什么样子？
08-22
43 | 如何进行Docker实验环境搭建？
08-22
42 | DHE/ECDHE算法的原理
08-22
41 | Linux/Mac实验环境搭建与URI查询参数
08-22
40 | HTTP性能优化面面观（下）
08-22
39 | HTTP性能优化面面观（上）
08-22
38 | WebSocket：沙盒里的TCP
08-22
37 | CDN：加速我们的网络服务
08-22
36 | WAF：保护我们的网络服务
08-22
35 | OpenResty：更灵活的Web服务器
08-22
34 | Nginx：高性能的Web服务器
08-22
33 | 我应该迁移到HTTP/2吗？
08-22
32 | 未来之路：HTTP/3展望
08-22
31 | 时代之风（下）：HTTP/2内核剖析
08-22
30 | 时代之风（上）：HTTP/2特性概览
08-22
29 | 我应该迁移到HTTPS吗？
08-22
28 | 连接太慢该怎么办：HTTPS的优化
08-22
27 | 更好更快的握手：TLS1.3特性解析
08-22
26 | 信任始于握手：TLS1.2连接过程解析
08-22
25 | 固若金汤的根本（下）：数字签名与证书
08-22
24 | 固若金汤的根本（上）：对称加密与非对称加密
08-22
23 | HTTPS是什么？SSL/TLS又是什么？
08-22
22 | 冷链周转：HTTP的缓存代理
08-22
21 | 良心中间商：HTTP的代理服务
08-22
20 | 生鲜速递：HTTP的缓存控制
08-22
19 | 让我知道你是谁：HTTP的Cookie机制
08-22
18 | 四通八达：HTTP的重定向和跳转
08-22
17 | 排队也要讲效率：HTTP的连接管理
08-22
16 | 把大象装进冰箱：HTTP传输大文件的方法
08-22
15 | 海纳百川：HTTP的实体数据
08-22
14 | HTTP有哪些优点？又有哪些缺点？
08-22
13 | HTTP有哪些特点？
08-22
12 | 响应状态码该怎么用？
08-22
11 | 你能写出正确的网址吗？
08-22
10 | 应该如何理解请求方法？
08-22
09 | HTTP报文是什么样子的？
08-22
08 | 键入网址再按下回车，后面究竟发生了什么？
08-22
07 | 自己动手，搭建HTTP实验环境
08-22
06 | 域名里有哪些门道？
08-22
05 | 常说的“四层”和“七层”到底是什么？“五层”“六层”哪去了？
08-22
04 | HTTP世界全览（下）：与HTTP相关的各种协议
08-22
03 | HTTP世界全览（上）：与HTTP相关的各种概念
08-22
02 | HTTP是什么？HTTP又不是什么？
08-22
01 | 时势与英雄：HTTP的前世今生
08-22
开篇词｜To Be a HTTP Hero
08-22
06 | switch表达式：怎么简化多情景操作？
06-13
用户故事 | 与新特性开发者对话
06-13
用户故事 | 保持好奇心，积极拥抱变化
06-13
期末测试｜来赴一场满分之约！
06-13
结束语 | Java的未来，依然是星辰大海
06-13
18 | 模块系统：怎么模块化你的应用程序？
06-13
17 | 模块系统：为什么Java需要模块化？
06-13
16 | 改进的废弃，怎么避免使用废弃的特性？
06-13
15 | 现代密码：你用的加密算法过时了吗？
06-13
14 | 禁止空指针，该怎么避免崩溃的空指针？
06-13
13 | 外部函数接口，能不能取代Java本地接口？
06-13
12 | 外部内存接口：零拷贝的障碍还有多少？
06-13
11 | 矢量运算：Java的机器学习要来了吗？
06-13
10 | Flow，是异步编程的终极选择吗？
06-13
09 | 异常恢复，付出的代价能不能少一点？
06-13
08 | 抛出异常，是不是错误处理的第一选择？
06-13
07 | switch匹配：能不能适配不同的类型？
06-13
05 | 类型匹配：怎么切除臃肿的强制转换？
06-13
04 | 封闭类：怎么刹住失控的扩展性？
06-13
03 | 档案类：怎么精简地表达不可变数据？
06-13
02 | 文字块：怎么编写所见即所得的字符串？
06-13
01 | JShell：怎么快速验证简单的小问题？
06-13
开篇词 | 拥抱Java新特性，像设计者一样工作和思考
06-13
结束语 | 站在聚光灯下
05-05
35 | 分布式事务：使用 Nacos+Seata 实现 TCC 补偿模式
05-05
34 | 分布式事务：使用 Nacos+Seata 实现AT模式
05-05
33 | 分布式事务：搭建 Seata 服务器
05-05
32 | Alibaba Seata 框架：什么是分布式事务？
05-05
31 | 消息驱动：如何通过 RabbitMQ 插件实现延迟消息？
05-05
30 | 消息驱动：如何高效处理 Stream 中的异常？
05-05
29 | 消息驱动：如何集成 Stream 实现消息驱动？
05-05
28 | 消息驱动：谁说消息队列只能削峰填谷？
05-05
27 | 微服务网关：如何借助 Nacos 实现动态路由规则？
05-05
26 | 微服务网关：如何设置请求转发、跨域和限流规则？
05-05
25 | 微服务网关：Gateway 中的路由和谓词有何应用？
05-05
24 | 为什么微服务架构少不了微服务网关？
05-05
23 | 调用链追踪：如何通过 ELK 实现日志检索？
05-05
22 | 调用链追踪：集成 Sleuth 和 Zipkin，实现链路打标
05-05
21 | Sleuth 体系架构：为什么微服务架构需要链路追踪？
05-05
加餐：说透微服务 | 什么是主链路规划？
05-05
20 | Sentinel 实战：如何接入 Nacos 实现规则持久化？
05-05
19 | Sentinel 实战：如何为项目添加异常降级方案？
05-05
18 | Sentinel 实战：如何实施流量整形与限流策略？
05-05
17 | Sentinel 体系结构：什么是服务容错（降级熔断、流量整形）?
05-05
16 | 如何集成 Nacos Config 实现配置项动态刷新？
05-05
15 | 配置中心在微服务中发挥着怎样的作用？
05-05
14 | OpenFeign 实战：OpenFeign 组件有哪些高级玩法？
05-05
13 | OpenFeign 实战：如何实现服务间调用功能？
05-05
12 | OpenFeign：服务间调用组件 OpenFeign 是怎么“隔空取物”的？
05-05
11 | Loadbalancer 实战：通过自定义负载均衡策略实现金丝雀测试
05-05
10 | 集成 Nacos：如何通过服务发现机制向服务提供者发起调用？
05-05
09 | 集成 Nacos：如何将服务提供者注册到 Nacos 服务器？
05-05
08 | 服务治理：Nacos集群环境搭建
05-05
07 | Nacos体系架构：什么是服务治理？
05-05
06 | 牛刀小试：如何搭建优惠券计算服务和用户服务？
05-05
05 | 牛刀小试：如何搭建优惠券模板服务？
05-05
04 | 十八般兵器：如何搭建项目所需的开发环境？
05-05
03 | 初窥门径：我们要搭建一个怎样的微服务实战项目？
05-05
02 | 微服务全家桶：走进 Spring Cloud 的世界
05-05
01 | 是什么推动了单体应用到微服务架构的演进？
05-05
开篇词 | 跟着学，你也能成为微服务高手
05-05
结束语 | 不忘初心
04-23
结课测试 | “Kotlin编程第一课”100分试卷等你来挑战！
04-23
35 | 用Kotlin写一个GitHub Trending App
04-23
34 | Kotlin与Jetpack简直是天生一对！
04-23
33 | Java Android开发者还会有未来吗？
04-23
32 | 图解Flow：原来你是只纸老虎？
04-23
31 | 图解Channel：如何理解它的CSP通信模型？
04-23
30 | CoroutineScope是如何管理协程的？
04-23
29 | Dispatchers是如何工作的？
04-23
28 | launch的背后到底发生了什么？
04-23
加餐五 | 深入理解协程基础元素
04-23
27 | 图解挂起函数：原来你就是个状态机？
04-23
26 | 协程源码的地图：如何读源码才不会迷失？
04-23
25 | 集合操作符：你也会“看完就忘”吗？
04-23
答疑（一）| Java和Kotlin到底谁好谁坏？
04-23
24 | 实战：让KtHttp支持Flow
04-23
23 | 异常：try-catch居然会不起作用？坑！
04-23
22 | 并发：协程不需要处理同步吗？
04-23
21 | select：到底是在选择什么？
04-23
20 | Flow：为什么说Flow是“冷”的？
04-23
19 | Channel：为什么说Channel是“热”的？
04-23
题目解答 | 期中考试版本参考实现
04-23
期中考试 | 用Kotlin实现图片处理程序
04-23
18 | 实战：让KtHttp支持挂起函数
04-23
17 | Context：万物皆为Context？
04-23
16 | Job：协程也有生命周期吗？
04-23
15 | 挂起函数：Kotlin协程的核心
04-23
14 | 如何启动协程？
04-23
13 | 什么是“协程思维模型”？
04-23
春节刷题计划（四）| 一题三解，搞定分式加减法
04-23
春节刷题计划（三）| 一题双解，搞定求解方程
04-23
春节刷题计划（二）| 一题三解，搞定版本号判断
04-23
春节刷题计划（一）| 当Kotlin遇上LeetCode
04-23
加餐四 | 什么是“空安全思维”？
04-23
加餐三 | 什么是“不变性思维”？
04-23
加餐二 | 什么是“表达式思维”？
04-23
12 | 实战：用Kotlin实现一个网络请求框架KtHttp
04-23
11 | 注解与反射：进阶必备技能
04-23
10 | 泛型：逆变or协变，傻傻分不清？
04-23
09 | 委托：你为何总是被低估？
04-23
加餐一 | 初识Kotlin函数式编程
04-23
08 | 实战：用Kotlin写一个英语词频统计程序
04-23
07 | 高阶函数：为什么说函数是Kotlin的“一等公民”？
04-23
06 | 扩展：你的能力边界到底在哪里？
04-23
05 | object关键字：你到底有多少种用法？
04-23
04 | 实战：构建一个Kotlin版本的四则运算计算器
04-23
03 | Kotlin原理：编译器在幕后干了哪些“好事”？
04-23
02 | 面向对象：理解Kotlin设计者的良苦用心
04-23
01 | Kotlin基础语法：正式开启学习之旅
04-23
开篇词 | 入门Kotlin有多容易，精通Kotlin就有多难
04-23
加餐06 | BCC：入门eBPF的前端工具
04-04
加餐05 | eBPF：怎么更加深入地查看内核中的函数？
04-04
加餐04 | 理解ftrace（2）：怎么理解ftrace背后的技术tracepoint和kprobe？
04-04
加餐03 | 理解ftrace（1）：怎么应用ftrace查看长延时内核函数？
04-04
加餐02 | 理解perf：怎么用perf聚焦热点函数？
04-04
加餐01 | 案例分析：怎么解决海量IPVS规则带来的网络延时抖动问题？
04-04
加餐福利 | 课后思考题答案合集
04-04
用户故事 | 莫名：相信坚持的力量，终会厚积薄发
04-04
结课测试｜这些容器技术的问题，你都掌握了么？
04-04
结束语 | 跳出舒适区，突破思考的惰性
04-04
20 | 容器安全（2）：在容器中，我不以root用户来运行程序可以吗？
04-04
19 | 容器安全（1）：我的容器真的需要privileged权限吗?
04-04
18 | 容器网络配置（3）：容器中的网络乱序包怎么这么高？
04-04
17｜容器网络配置（2）：容器网络延时要比宿主机上的高吗?
04-04
16 | 容器网络配置（1）：容器网络不通了要怎么调试?
04-04
15 | 容器网络：我修改了/proc/sys/net下的参数，为什么在容器中不起效？
04-04
14 | 容器中的内存与I/O：容器写文件的延时为什么波动很大？
04-04
13 | 容器磁盘限速：我的容器里磁盘读写为什么不稳定?
04-04
12 | 容器文件Quota：容器为什么把宿主机的磁盘写满了？
04-04
11 | 容器文件系统：我在容器中读写文件怎么变慢了？
04-04
10 | Swap：容器可以使用Swap空间吗？
04-04
09 | Page Cache：为什么我的容器内存使用量总是在临界点?
04-04
08 | 容器内存：我的容器为什么被杀了？
04-04
07 | Load Average：加了CPU Cgroup限制，为什么我的容器还是很慢？
04-04
06 | 容器CPU（2）：如何正确地拿到容器CPU的开销？
04-04
05｜容器CPU（1）：怎么限制容器的CPU使用？
04-04
04 | 理解进程（3）：为什么我在容器中的进程被强制杀死了？
04-04
03｜理解进程（2）：为什么我的容器里有这么多僵尸进程？
04-04
02 | 理解进程（1）：为什么我在容器中不能kill 1号进程？
04-04
01 | 认识容器：容器的基本操作和实现原理
04-04
开篇词 | 一个态度两个步骤，成为容器实战高手
04-04
期末测试 | 有关Java性能调优，你掌握了多少呢？
03-06
结束语 | 栉风沐雨，砥砺前行！
03-06
44 | 记一次双十一抢购性能瓶颈调优
03-06
43 | 如何使用缓存优化系统性能？
03-06
42 | 电商系统的分布式事务调优
03-06
41 | 如何设计更优的分布式锁？
03-06
40 | 答疑课堂：MySQL中InnoDB的知识点串讲
03-06
39 | 数据库参数设置优化，失之毫厘差之千里
03-06
38 | 电商系统表设计优化案例分析
03-06
37 | 什么时候需要分表分库？
03-06
36 | 记一次线上SQL死锁事故：如何避免死锁？
03-06
35 | MySQL调优之索引：索引的失效与优化
03-06
34 | MySQL调优之事务：高并发场景下的数据库事务调优
03-06
33 | MySQL调优之SQL语句：如何写出高性能SQL语句？
03-06
32 | 答疑课堂：模块五思考题集锦
03-06
31 | 装饰器模式：如何优化电商系统中复杂的商品价格策略？
03-06
30 | 生产者消费者模式：电商库存设计优化
03-06
29 | 如何使用设计模式优化并发编程？
03-06
28 | 原型模式与享元模式：提升系统性能的利器
03-06
27 | 单例模式：如何创建单一对象优化系统性能？
03-06
26 | 答疑课堂：模块四热点问题解答
03-06
25 | 内存持续上升，我该如何排查问题？
03-06
24 | 如何优化JVM内存分配？
03-06
23 | 如何优化垃圾回收机制？
03-06
22 | 深入JVM即时编译器JIT，优化Java编译
03-06
21 | 磨刀不误砍柴工：欲知JVM调优先了解JVM内存模型
03-06
加餐 | 什么是数据的强、弱一致性？
03-06
20 | 答疑课堂：模块三热点问题解答
03-06
19 | 如何用协程来优化多线程业务？
03-06
18 | 如何设置线程池大小？
03-06
17 | 并发容器的使用：识别不同场景下最优容器
03-06
16 | 多线程调优（下）：如何优化多线程上下文切换？
03-06
15 | 多线程调优（上）：哪些操作导致了上下文切换？
03-06
14 | 多线程之锁优化（下）：使用乐观锁优化并行操作
03-06
13 | 多线程之锁优化（中）：深入了解Lock同步锁的优化方法
03-06
12 | 多线程之锁优化（上）：深入了解Synchronized同步锁的优化方法
03-06
11 | 答疑课堂：深入了解NIO的优化实现原理
03-06
10 | 网络通信优化之通信协议：如何优化RPC网络通信？
03-06
09 | 网络通信优化之序列化：避免使用Java序列化
03-06
08 | 网络通信优化之I/O模型：如何解决高并发下I/O瓶颈？
03-06
07 | 深入浅出HashMap的设计与优化
03-06
06 | Stream如何提高遍历集合效率？
03-06
加餐 | 推荐几款常用的性能测试工具
03-06
05 | ArrayList还是LinkedList？使用不当性能差千倍
03-06
04 | 慎重使用正则表达式
03-06
03 | 字符串性能优化不容小觑，百M内存轻松存储几十G数据
03-06
02 | 如何制定性能调优策略？
03-06
01 | 如何制定性能调优标准？
03-06
开篇词 | 怎样才能做好性能调优？
03-06
期末测试 | 这些Kafka核心要点，你都掌握了吗？
02-28
结束语 | 以梦为马，莫负韶华！
02-28
用户故事 | 黄云：行百里者半九十
02-28
加餐 | 搭建开发环境、阅读源码方法、经典学习资料大揭秘
02-28
42 | Kafka Streams在金融领域的应用
02-28
41 | Kafka Streams DSL开发实例
02-28
40 | Kafka Streams与其他流处理平台的差异在哪里？
02-28
39 | 从0搭建基于Kafka的企业级实时日志流处理平台
02-28
38 | 调优Kafka，你做到了吗？
02-28
37 | 主流的Kafka监控框架
02-28
36 | 你应该怎么监控Kafka？
02-28
35 | 跨集群备份解决方案MirrorMaker
02-28
34 | 云环境下的授权该怎么做？
02-28
33 | Kafka认证机制用哪家？
02-28
32 | KafkaAdminClient：Kafka的运维利器
02-28
31 | 常见工具脚本大汇总
02-28
30 | 怎么重设消费者组位移？
02-28
29 | Kafka动态配置了解下？
02-28
28 | 主题管理知多少?
02-28
27 | 关于高水位和Leader Epoch的讨论
02-28
26 | 你一定不能错过的Kafka控制器
02-28
25 | 消费者组重平衡全流程解析
02-28
24 | 请求是怎么被处理的？
02-28
23 | Kafka副本机制详解
02-28
22 | 消费者组消费进度监控都怎么实现？
02-28
21 | Java 消费者是如何管理TCP连接的?
02-28
20 | 多线程开发消费者实例
02-28
19 | CommitFailedException异常怎么处理？
02-28
18 | Kafka中位移提交那些事儿
02-28
17 | 消费者组重平衡能避免吗？
02-28
16 | 揭开神秘的“位移主题”面纱
02-28
15 | 消费者组到底是什么？
02-28
14 | 幂等生产者和事务生产者是一回事吗？
02-28
13 | Java生产者是如何管理TCP连接的？
02-28
12 | 客户端都有哪些不常见但是很高级的功能？
02-28
11 | 无消息丢失配置怎么实现？
02-28
10 | 生产者压缩算法面面观
02-28
09 | 生产者消息分区机制原理剖析
02-28
08 | 最最最重要的集群参数配置（下）
02-28
07 | 最最最重要的集群参数配置（上）
02-28
06 | Kafka线上集群部署方案怎么做？
02-28
05 | 聊聊Kafka的版本号
02-28
04 | 我应该选择哪种Kafka？
02-28
03 | Kafka只是消息引擎系统吗？
02-28
02 | 一篇文章带你快速搞定Kafka术语
02-28
01 | 消息引擎系统ABC
02-28
开篇词 | 为什么要学习Kafka？
02-28
第二季回归丨这次我们一起实战后端存储
02-20
结束语 | 程序员如何构建知识体系？
02-20
期末测试 | 消息队列100分试卷等你来挑战！
02-20
期中测试丨10个消息队列热点问题自测
02-20
35 | 答疑解惑（三）：主流消息队列都是如何存储消息的？
02-20
34 | 动手实现一个简单的RPC框架（四）：服务端
02-20
33 | 动手实现一个简单的RPC框架（三）：客户端
02-20
32 | 动手实现一个简单的RPC框架（二）：通信与序列化
02-20
31 | 动手实现一个简单的RPC框架（一）：原理和程序的结构
02-20
30 | 流计算与消息（二）：在流计算中使用Kafka链接计算任务
02-20
29 | 流计算与消息（一）：通过Flink理解流计算的原理
02-20
28 | 答疑解惑（二）：我的100元哪儿去了？
02-20
27 | Pulsar的存储计算分离设计：全新的消息队列设计思路
02-20
26 | MQTT协议：如何支持海量的在线IoT设备?
02-20
25 | RocketMQ与Kafka中如何实现事务？
02-20
24 | Kafka的协调服务ZooKeeper：实现分布式系统的“瑞士军刀”
02-20
23 | RocketMQ客户端如何在集群中找到正确的节点？
02-20
22 | Kafka和RocketMQ的消息复制实现的差异点在哪？
02-20
21 | Kafka Consumer源码分析：消息消费的实现过程
02-20
20 | RocketMQ Producer源码分析：消息生产的实现过程
02-20
19 | 数据压缩：时间换空间的游戏
02-20
18 | 如何用硬件同步原语（CAS）替代锁？
02-20
17 | 如何正确使用锁保护共享数据，协调异步线程？
02-20
16 | 缓存策略：如何使用缓存来减少磁盘IO？
02-20
15 | Kafka如何实现高性能IO？
02-20
加餐 | JMQ的Broker是如何异步处理消息的？
02-20
14 | 内存管理：如何避免内存溢出和频繁的垃圾回收？
02-20
13 | 传输协议：应用程序之间对话的语言
02-20
12 | 序列化与反序列化：如何通过网络传输结构化的数据？
02-20
11 | 如何实现高性能的异步网络传输？
02-20
10 | 如何使用异步设计提升系统性能？
02-20
09 | 学习开源代码该如何入手？
02-20
08 | 答疑解惑（一） : 网关如何接收服务端的秒杀结果？
02-20
07 | 消息积压了该如何处理？
02-20
06 | 如何处理消费过程中的重复消息？
02-20
05 | 如何确保消息不会丢失?
02-20
04 | 如何利用事务消息实现分布式事务？
02-20
03 | 消息模型：主题和队列有什么区别？
02-20
02 | 该如何选择消息队列？
02-20
01 | 为什么需要消息队列？
02-20
预习 | 怎样更好地学习这门课？
02-20
开篇词 | 优秀的程序员，你的技术栈中不能只有“增删改查”
02-20
MySQL是怎样运行的.pdf
02-18
期末测试｜对于性能优化，你掌握了多少呢？
02-12
毕业问卷获奖用户名单
02-12
来领奖啦！你填写毕业问卷了吗？
02-12
结束语 | 从业 IT 20年后，我将最看重什么？
02-12
加餐7｜深入剖析HTTP/3协议
02-12
加餐6｜分布式系统的本质是什么？
02-12
加餐5 | 如何理解分布式系统？
02-12
大咖助场4｜傅健：那些年，影响我们达到性能巅峰的常见绊脚石（下）
02-12
大咖助场3｜傅健：那些年，影响我们达到性能巅峰的常见绊脚石（上）
02-12
加餐4｜百万并发下Nginx的优化之道
02-12
大咖助场2｜庄振运：与程序员相关的SSD性能知识
02-12
大咖助场1 | 李玥：高并发场景下如何优化微服务的性能?
02-12
加餐3 | 大厂面试到底在考些什么？
02-12
30 | 如何权衡关系数据库与NoSQL数据库？
02-12
29 | 流式计算：如何通过集群实现实时计算？
02-12
28 | MapReduce：如何通过集群实现离线计算？
02-12
27 | 消息队列：如何基于异步消息提升性能？
02-12
26 | 应用层多播：如何快速地分发内容？
02-12
25 | 过期缓存：如何防止缓存被流量打穿？
02-12
24 | 一致性哈希：如何高效地均衡负载？
02-12
23 | 负载均衡：选择Nginx还是OpenResty？
02-12
22 | NWR算法：如何修改读写模型以提升性能？
02-12
21 | AKF立方体：怎样通过可扩展性来提高性能？
02-12
20 | CAP理论：怎样舍弃一致性去换取性能？
02-12
19 | 如何通过监控找到性能瓶颈？
02-12
加餐2 ｜答疑精选：这些问题你都清楚吗？
02-12
加餐1｜特别福利：陶辉视频课精选
02-12
期中考试｜行至半程，你的收获如何呢？
02-12
18 | 如何通过gRPC实现高效远程过程调用？
02-12
17 | Protobuf是如何进一步提高编码效率的？
02-12
16 | HTTP/2是怎样提升性能的？
02-12
15 | 如何提升HTTP/1.1性能？
02-12
14 | 优化TLS/SSL性能该从何下手？
02-12
13 | 实战：单机如何实现管理百万主机的心跳服务？
02-12
12 | 如何调整TCP拥塞控制的性能？
02-12
11 | 如何修改TCP缓冲区才能兼顾并发数量与传输速度？
02-12
10 | 如何提升TCP四次挥手的性能？
02-12
09 | 如何提升TCP三次握手的性能？
02-12
08 | 事件驱动：C10M是如何实现的？
02-12
07 | 性能好，效率高的一对多通讯该如何实现？
02-12
06 | 锁：如何根据业务场景选择合适的锁？
02-12
05 | 协程：如何快速地实现高并发服务？
02-12
04 | 零拷贝：如何高效地传输文件？
02-12
03 | 索引：如何用哈希表管理亿级对象？
02-12
02 | 内存池：如何提升内存分配的效率？
02-12
01 | CPU缓存：怎样写代码能够让CPU执行得更快？
02-12
开篇词 | 万变不离其宗，性能优化也有章可循
02-12
结束语 | 从学习Redis到向Redis学习
02-09
期末测试 | 这些Redis核心知识，你都掌握了吗？
02-09
加餐（七） | 从微博的Redis实践中，我们可以学到哪些经验？
02-09
加餐（六）| Redis的使用规范小建议
02-09
加餐（五） | Redis有哪些好用的运维工具？
02-09
加餐（四） | Redis客户端如何与服务器端交换命令和数据？
02-09
加餐（三）| 用户Kaito：我希望成为在压力中成长的人
02-09
加餐（二）| 用户Kaito：我是如何学习Redis的？
02-09
加餐（一）| 经典的Redis学习资料有哪些？
02-09
41 | 第35～40讲课后思考题答案及常见问题答疑
02-09
40 | Redis的下一步：基于NVM内存的实践
02-09
39 | Redis 6.0的新特性：多线程、客户端缓存与安全
02-09
期中测试题答案 | 这些问题，你都答对了吗？
02-09
期中测试题 | 一套习题，测出你的掌握程度
02-09
38 | 通信开销：限制Redis Cluster规模的关键因素
02-09
37 | 数据分布优化：如何应对数据倾斜？
02-09
36 | Redis支撑秒杀场景的关键技术和实践都有哪些？
02-09
35 | Codis VS Redis Cluster：我该选择哪一个集群方案？
02-09
34 | 第23~33讲课后思考题答案及常见问题答疑
02-09
33 | 脑裂：一次奇怪的数据丢失
02-09
32 | Redis主从同步与故障切换，有哪些坑？
02-09
31 | 事务机制：Redis能实现ACID属性吗？
02-09
30 | 如何使用Redis实现分布式锁？
02-09
29 | 无锁的原子操作：Redis如何应对并发访问？
02-09
28 | Pika：如何基于SSD实现大容量Redis？
02-09
27 | 缓存被污染了，该怎么办？
02-09
26 | 缓存异常（下）：如何解决缓存雪崩、击穿、穿透难题？
02-09
25 | 缓存异常（上）：如何解决缓存和数据库的数据不一致问题？
02-09
24 | 替换策略：缓存满了怎么办？
02-09
23 | 旁路缓存：Redis是如何工作的？
02-09
22 | 第11～21讲课后思考题答案及常见问题答疑
02-09
21 | 缓冲区：一个可能引发“惨案”的地方
02-09
20 | 删除数据后，为什么内存占用率还是很高？
02-09
19 | 波动的响应延迟：如何应对变慢的Redis？（下）
02-09
18 | 波动的响应延迟：如何应对变慢的Redis？（上）
02-09
17 | 为什么CPU结构也会影响Redis的性能？
02-09
16 | 异步机制：如何避免单线程模型的阻塞？
02-09
15 | 消息队列的考验：Redis有哪些解决方案？
02-09
14 | 如何在Redis中保存时间序列数据？
02-09
13 | GEO是什么？还可以定义新的数据类型吗？
02-09
12 | 有一亿个keys要统计，应该用哪种集合？
02-09
11 | “万金油”的String，为什么不好用了？
02-09
10 | 第1～9讲课后思考题答案及常见问题答疑
02-09
09 | 切片集群：数据增多了，是该加内存还是加实例？
02-09
08 | 哨兵集群：哨兵挂了，主从库还能切换吗？
02-09
07 | 哨兵机制：主库挂了，如何不间断服务？
02-09
06 | 数据同步：主从库如何实现数据一致？
02-09
05 | 内存快照：宕机后，Redis如何实现快速恢复？
02-09
04 | AOF日志：宕机了，Redis如何避免数据丢失？
02-09
03 | 高性能IO模型：为什么单线程Redis能那么快？
02-09
02 | 数据结构：快速的Redis有哪些慢操作？
02-09
01 | 基本架构：一个键值数据库包含什么？
02-09
开篇词 | 这样学Redis，才能技高一筹
02-09
架构实战营 百度网盘
01-12
2021
结课测试｜这些架构技能你都掌握了吗？
12-26
结束语 | 坚持，成就你的技术梦想
12-26
加餐｜业务架构实战营开营了
12-26
加餐｜扒一扒中台皇帝的外衣
12-26
加餐｜单服务器高性能模式性能对比
12-26
第二季回归 | 照着做，你也能顺利晋升！
12-26
致「从0开始学架构」专栏订阅用户
12-26
新书首发 | 《从零开始学架构》
12-26
架构师必读书单 | “华仔，放学别走！” 第5期
12-26
架构师成长之路 | “华仔，放学别走！” 第4期
12-26
如何高效地学习开源项目 | “华仔，放学别走！” 第3期
12-26
架构专栏特别放送 | “华仔，放学别走！” 第2期
12-26
架构专栏特别放送 | “华仔，放学别走！”第1期
12-26
50 | 架构实战：架构设计文档模板
12-26
49 | 谈谈App架构的演进
12-26
48 | 再谈开源项目：如何选择、使用以及二次开发？
12-26
47 | 架构重构内功心法第三式：运筹帷幄
12-26
46 | 架构重构内功心法第二式：合纵连横
12-26
45 | 架构重构内功心法第一式：有的放矢
12-26
44 | 互联网架构模板：“平台”技术
12-26
43 | 互联网架构模板：“用户层”和“业务层”技术
12-26
42 | 互联网架构模板：“网络层”技术
12-26
41 | 互联网架构模板：“开发层”和“服务层”技术
12-26
40 | 互联网架构模板：“存储层”技术
12-26
39 | 互联网技术演进的模式
12-26
38 | 架构师应该如何判断技术演进的方向？
12-26
37 | 微内核架构详解
12-26
36 | 微服务架构最佳实践 - 基础设施篇
12-26
35 | 微服务架构最佳实践 - 方法篇
12-26
34 | 深入理解微服务架构：银弹 or 焦油坑？
12-26
33 | 传统的可扩展架构模式：分层架构和SOA
12-26
32 | 可扩展架构的基本思想和模式
12-26
31 | 如何应对接口级的故障？
12-26
30 | 异地多活设计4步走
12-26
29 | 异地多活设计4大技巧
12-26
28 | 业务高可用的保障：异地多活架构
12-26
27 | 如何设计计算高可用架构？
12-26
26 | 高可用存储架构：集群和分区
12-26
25 | 高可用存储架构：双机架构
12-26
24 | FMEA方法，排除架构可用性隐患的利器
12-26
23 | 想成为架构师，你必须掌握的CAP细节
12-26
22 | 想成为架构师，你必须知道CAP理论
12-26
21 | 高性能负载均衡：算法
12-26
20 | 高性能负载均衡：分类及架构
12-26
19 | 单服务器高性能模式：Reactor与Proactor
12-26
18 | 单服务器高性能模式：PPC与TPC
12-26
17 | 高性能缓存架构
12-26
16 | 高性能NoSQL
12-26
15 | 高性能数据库集群：分库分表
12-26
14 | 高性能数据库集群：读写分离
12-26
13 | 架构设计流程：详细方案设计
12-26
12 | 架构设计流程：评估和选择备选方案
12-26
11 | 架构设计流程：设计备选方案
12-26
10 | 架构设计流程：识别复杂度
12-26
09 | 架构设计原则案例
12-26
08 | 架构设计三原则
12-26
07 | 复杂度来源：低成本、安全、规模
12-26
06 | 复杂度来源：可扩展性
12-26
05 | 复杂度来源：高可用
12-26
04 | 复杂度来源：高性能
12-26
03 | 架构设计的目的
12-26
02 | 架构设计的历史背景
12-26
01 | 架构到底是指什么？
12-26
开篇词 | 照着做，你也能成为架构师！
12-26
用户故事 | 李兆龙：博观而约取，厚积而薄发
11-04
结课测试｜这些分布式数据库的问题，你都掌握了吗？
11-04
结束语 | 享受职业带给你的快乐
11-04
30 | 实践篇大串讲：重难点回顾+思考题答疑+知识全景图
11-04
29 | 产品图鉴：哪些分布式数据库值得看？
11-04
28 | 选型案例：银行是怎么选择分布式数据库的？
11-04
27 | 产品测试：除了性能跑分，还能测个啥？
11-04
26 | 容器化：分布式数据库要不要上云，你想好了吗？
11-04
25 | 容灾与备份：如何设计逃生通道保证业务连续性？
11-04
24 | 全球化部署：如何打造近在咫尺且永不宕机的数据库？
11-04
23 | 数据库查询串讲：重难点回顾+思考题答疑+知识全景图
11-04
22｜RUM猜想：想要读写快还是存储省？又是三选二
11-04
21 | 查询执行引擎：如何让聚合计算加速？
11-04
20 | 关联查询：如何提升多表Join能力？
11-04
19 | 查询性能优化：计算与存储分离架构下有哪些优化思路？
11-04
18 | HTAP是不是赢者通吃的游戏？
11-04
17 | 为什么不建议你使用自增主键？
11-04
16 | 为什么不建议你使用存储过程？
11-04
15 | 分布式事务串讲：重难点回顾+思考题答疑+知识全景图
11-04
14 | 隔离性：实现悲观协议，除了锁还有别的办法吗？
11-04
13 | 隔离性：为什么使用乐观协议的分布式数据库越来越少?
11-04
12 | 隔离性：看不见的读写冲突，要怎么处理？
11-04
11｜隔离性：读写冲突时，快照是最好的办法吗？
11-04
10 | 原子性：如何打破事务高延迟的魔咒？
11-04
09｜原子性：2PC还是原子性协议的王者吗？
11-04
08 | 基础篇大串讲：重难点回顾+思考题答疑+知识全景图
11-04
07 | 数据复制：为什么有时候Paxos不是最佳选择？
11-04
06 | 分片机制：为什么说Range是更好的分片策略？
11-04
05 | 全局时钟：物理时钟和逻辑时钟你Pick谁？
11-04
04 | 架构风格：NewSQL和PGXC到底有啥不一样？
11-04
03｜强一致性：别再用BASE做借口，来看看什么是真正的事务一致性
11-04
02｜强一致性：那么多数据一致性模型，究竟有啥不一样？
11-04
01｜什么是分布式数据库？
11-04
开篇词｜为什么要学习分布式数据库？
11-04
结课测试 | 这些网络协议你都掌握了吗？
09-12
结束语 | 放弃完美主义，执行力就是限时限量认真完成
09-12
第2季回归 | 这次我们来“趣谈Linux操作系统”
09-12
加餐2 | “趣谈网络协议”专栏食用指南
09-12
加餐1 | 创作故事：我是如何创作“趣谈网络协议”专栏的？
09-12
协议专栏特别福利 | 答疑解惑第五期
09-12
协议专栏特别福利 | 答疑解惑第四期
09-12
协议专栏特别福利 | 答疑解惑第三期
09-12
协议专栏特别福利 | 答疑解惑第二期
09-12
协议专栏特别福利 | 答疑解惑第一期
09-12
第40讲 | 搭建一个网络实验环境：授人以鱼不如授人以渔
09-12
第39讲 | 知识串讲：用双十一的故事串起碎片的网络协议（下）
09-12
第38讲 | 知识串讲：用双十一的故事串起碎片的网络协议（中）
09-12
第37讲 | 知识串讲：用双十一的故事串起碎片的网络协议（上）
09-12
第36讲 | 跨语言类RPC协议：交流之前，双方先来个专业术语表
09-12
第35讲 | 二进制类RPC协议：还是叫NBA吧，总说全称多费劲
09-12
第34讲 | 基于JSON的RESTful接口协议：我不关心过程，请给我结果
09-12
第33讲 | 基于XML的SOAP协议：不要说NBA，请说美国职业篮球联赛
09-12
第32讲 | RPC协议综述：远在天边，近在眼前
09-12
第31讲 | 容器网络之Calico：为高效说出善意的谎言
09-12
第30讲 | 容器网络之Flannel：每人一亩三分地
09-12
第29讲 | 容器网络：来去自由的日子，不买公寓去合租
09-12
第28讲 | 云中网络的隔离GRE、VXLAN：虽然住一个小区，也要保护隐私
09-12
第27讲 | 云中的网络QoS：邻居疯狂下电影，我该怎么办？
09-12
第26讲 | 云中的网络安全：虽然不是土豪，也需要基本安全和保障
09-12
第25讲 | 软件定义网络：共享基础设施的小区物业管理办法
09-12
第24讲 | 云中网络：自己拿地成本高，购买公寓更灵活
09-12
第23讲 | 移动网络：去巴塞罗那，手机也上不了脸书
09-12
第22讲 | VPN：朝中有人好做官
09-12
第21讲 | 数据中心：我是开发商，自己拿地盖别墅
09-12
第20讲 | CDN：你去小卖部取过快递么？
09-12
第19讲 | HttpDNS：网络世界的地址簿也会指错路
09-12
第18讲 | DNS协议：网络世界的地址簿
09-12
第17讲 | P2P协议：我下小电影，99%急死你
09-12
第16讲 | 流媒体协议：如何在直播里看到美女帅哥？
09-12
第15讲 | HTTPS协议：点外卖的过程原来这么复杂
09-12
第14讲 | HTTP协议：看个新闻原来这么麻烦
09-12
第13讲 | 套接字Socket：Talk is cheap, show me the code
09-12
第12讲 | TCP协议（下）：西行必定多妖孽，恒心智慧消磨难
09-12
第11讲 | TCP协议（上）：因性恶而复杂，先恶后善反轻松
09-12
第10讲 | UDP协议：因性善而简单，难免碰到“城会玩”
09-12
第9讲 | 路由协议：西出网关无故人，敢问路在何方
09-12
第8讲 | 世界这么大，我想出网关：欧洲十国游与玄奘西行
09-12
第7讲 | ICMP与ping：投石问路的侦察兵
09-12
第6讲 | 交换机与VLAN：办公室太复杂，我要回学校
09-12
第5讲 | 从物理层到MAC层：如何在宿舍里自己组网玩联机游戏？
09-12
第4讲 | DHCP与PXE：IP是怎么来的，又是怎么没的？
09-12
第3讲 | ifconfig：最熟悉又陌生的命令行
09-12
第2讲 | 网络分层的真实含义是什么？
09-12
第1讲 | 为什么要学习网络协议？
09-12
开篇词 | 想成为技术牛人？先搞定网络协议！
09-12
结束语 | Kubernetes：赢开发者赢天下
08-25
特别放送 | 基于 Kubernetes 的云原生应用管理，到底应该怎么做？
08-25
特别放送 | 2019 年，容器技术生态会发生些什么？
08-25
52 | 答疑：在问题中解决问题，在思考中产生思考
08-25
51 | 谈谈Kubernetes开源社区和未来走向
08-25
50 | 让日志无处可逃：容器日志收集与管理
08-25
49 | Custom Metrics: 让Auto Scaling不再“食之无味”
08-25
48 | Prometheus、Metrics Server与Kubernetes监控体系
08-25
47 | 绝不仅仅是安全：Kata Containers 与 gVisor
08-25
46 | 解读 CRI 与 容器运行时
08-25
45 | 幕后英雄：SIG-Node与CRI
08-25
44 | Kubernetes GPU管理与Device Plugin机制
08-25
43 | Kubernetes默认调度器的优先级与抢占机制
08-25
42 | Kubernetes默认调度器调度策略解析
08-25
41 | 十字路口上的Kubernetes默认调度器
08-25
40 | Kubernetes的资源模型与资源管理
08-25
39 | 谈谈Service与Ingress
08-25
38 | 从外界连通Service与Service调试“三板斧”
08-25
37 | 找到容器不容易：Service、DNS与服务发现
08-25
36 | 为什么说Kubernetes只有soft multi-tenancy？
08-25
35 | 解读Kubernetes三层网络方案
08-25
34 | Kubernetes网络模型与CNI网络插件
08-25
33 | 深入解析容器跨主机网络
08-25
32 | 浅谈容器网络
08-25
31 | 容器存储实践：CSI插件编写指南
08-25
30 | 编写自己的存储插件：FlexVolume与CSI
08-25
29 | PV、PVC体系是不是多此一举？从本地持久化卷谈起
08-25
28 | PV、PVC、StorageClass，这些到底在说啥？
08-25
27 | 聪明的微创新：Operator工作原理解读
08-25
26 | 基于角色的权限控制：RBAC
08-25
25 | 深入解析声明式API（二）：编写自定义控制器
08-25
24 | 深入解析声明式API（一）：API对象的奥秘
08-25
23 | 声明式API与Kubernetes编程范式
08-25
22 | 撬动离线业务：Job与CronJob
08-25
21 | 容器化守护进程的意义：DaemonSet
08-25
20 | 深入理解StatefulSet（三）：有状态应用实践
08-25
19 | 深入理解StatefulSet（二）：存储状态
08-25
18 | 深入理解StatefulSet（一）：拓扑状态
08-25
17 | 经典PaaS的记忆：作业副本与水平扩展
08-25
16 | 编排其实很简单：谈谈“控制器”模型
08-25
15 | 深入解析Pod对象（二）：使用进阶
08-25
14 | 深入解析Pod对象（一）：基本概念
08-25
13 | 为什么我们需要Pod？
08-25
12 | 牛刀小试：我的第一个容器化应用
08-25
11 | 从0到1：搭建一个完整的Kubernetes集群
08-25
10 | Kubernetes一键部署利器：kubeadm
08-25
09 | 从容器到容器云：谈谈Kubernetes的本质
08-25
08 | 白话容器基础（四）：重新认识Docker容器
08-25
07 | 白话容器基础（三）：深入理解容器镜像
08-25
06 | 白话容器基础（二）：隔离与限制
08-25
05 | 白话容器基础（一）：从进程说开去
08-25
04 | 预习篇 · 小鲸鱼大事记（四）：尘埃落定
08-25
03 | 预习篇 · 小鲸鱼大事记（三）：群雄并起
08-25
02 | 预习篇 · 小鲸鱼大事记（二）：崭露头角
08-25
01 | 预习篇 · 小鲸鱼大事记（一）：初出茅庐
08-25
开篇词 | 打通“容器技术”的任督二脉
08-25
45 | CSP模型：Golang的主力队员
08-14
44 | 协程：更轻量级的线程
08-14
43 | 软件事务内存：借鉴数据库的并发经验
08-14
42 | Actor模型：面向对象原生的并发模型
08-14
41 | 案例分析（四）：高性能数据库连接池HiKariCP
08-14
40 | 案例分析（三）：高性能队列Disruptor
08-14
39 | 案例分析（二）：高性能网络应用框架Netty
08-14
38 | 案例分析（一）：高性能限流器Guava RateLimiter
08-14
37 | 设计模式模块热点问题答疑
08-14
36 | 生产者-消费者模式：用流水线思想提高效率
08-14
35 | 两阶段终止模式：如何优雅地终止线程？
08-14
34 | Worker Thread模式：如何避免重复创建线程？
08-14
33 | Thread-Per-Message模式：最简单实用的分工方法
08-14
32 | Balking模式：再谈线程安全的单例模式
08-14
31 | Guarded Suspension模式：等待唤醒机制的规范实现
08-14
30 | 线程本地存储模式：没有共享，就没有伤害
08-14
29 | Copy-on-Write模式：不是延时策略的COW
08-14
28 | Immutability模式：如何利用不变性解决并发问题？
08-14
27 | 并发工具类模块热点问题答疑
08-14
26 | Fork/Join：单机版的MapReduce
08-14
25 | CompletionService：如何批量执行异步任务？
08-14
24 | CompletableFuture：异步编程没那么难
08-14
23 | Future：如何用多线程实现最优的“烧水泡茶”程序？
08-14
22 | Executor与线程池：如何创建正确的线程池？
08-14
21 | 原子类：无锁工具类的典范
08-14
20 | 并发容器：都有哪些“坑”需要我们填？
08-14
19 | CountDownLatch和CyclicBarrier：如何让多线程步调一致？
08-14
18 | StampedLock：有没有比读写锁更快的锁？
08-14
17 | ReadWriteLock：如何快速实现一个完备的缓存？
08-14
16 | Semaphore：如何快速实现一个限流器？
08-14
15 | Lock和Condition（下）：Dubbo如何用管程实现异步转同步？
08-14
14 | Lock和Condition（上）：隐藏在并发包中的管程