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(上):隐藏在并发包中的管程