IT编程互联网技术合集：97套精品课程打包(421G) 精品合集

本套课程技术一站式提高课程：IT编程技术合集97套，主要有课程Android工程师进阶、Go微服务实战、SpringCloud原理与实战、大数据技术基础、人人都能学会的数据分析、前端性能优化方法与实战等等，具体课查看页面目录，文件大小共计421G，。

课程文件目录：V-3642：拉勾教育-合集 [421G]

目录数
│  
├─拉勾：12步通关求职面试
│      [374] 开篇词：了解面试“潜规则”，从海选中脱颖而出.mp4
│      [375] 第 01 讲：设计一份吸引面试官的简历.mp4
│      [376] 第 02 讲：读懂职位 JD，精准投递简历.mp4
│      [377] 第 03 讲：把握投递简历的黄金时间段.mp4
│      [378] 第 04 讲：做好充分的准备去面试.mp4
│      [379] 第 05 讲：把握面试时的关键点.mp4
│      [380] 第 06 讲：捕捉 HR 微表情，做出应对策略.mp4
│      [381] 第 07 讲：巧妙推销自己的 3 个技巧.mp4
│      [382] 第 08 讲：认清自身实力，明确求职方向.mp4
│      [383] 第 09 讲：判断公司背景，做出合理选择.mp4
│      [384] 第 10 讲：了解行业薪资，清晰找准定位.mp4
│      [385] 第 11 讲：目标明确，阐明沟通.mp4
│      [386] 第 12 讲：工作交接流程 & 福利衔接.mp4
│      文档.zip
│      
├─拉勾：14 讲提升职场竞争力
│      01 - 流程意识 ：如何成为善用流程的高手？.md
│      02 - 数据至上 ：如何用数据增强你的职场说服力.md
│      03 - 复盘技巧 ：深度复盘的三个步骤.md
│      04 - 拆解方法 ：如何破解工作难题无从下手的尴尬.md
│      05 - 优先思维：手中百件事，如何评估事情的优先级？.md
│      06 - 语言表达：教你清晰表达，高效沟通.md
│      07 - 书面表达：让周报、汇报、纪要成为你的职场必杀技.md
│      08 - 职场学习：不要让吃老本的心态毁了自己.md
│      09 - 工作技能：如何避免自己成为一个职场螺丝钉？.md
│      10 - 行业视野：为啥你的领导就是比你厉害？.md
│      11 - 商业思维：那些业务一把手想的都是啥？.md
│      12 - 关系建立：什么样的人际关系才是对工作有价值的？.md
│      13 - 关系经营：如何让别人在关键时刻支持你？.md
│      14 - 沟通说服：如何沟通才能让别人真心实意地帮你？.md
│      开篇词 - 职场是一场多维度的竞争.md
│      结束语 - 让晋升在个人修行中自然完成.md
│      
├─拉勾：21讲吃透实时流计算
│  │  [6417] 开篇词  攻克实时流计算难点，掌握大数据未来！.mp4
│  │  [6418] 01  实时流计算的通用架构.mp4
│  │  [6419] 02  异步和高并发：为什么 NIO 是异步和高并发编程的基础？.mp4
│  │  [6420] 03  反向压力：如何避免异步系统中的 OOM 问题？.mp4
│  │  [6421] 04  流与异步：为什么说掌握流计算先要理解异步编程？.mp4
│  │  [6422] 05  有向无环图（DAG）：如何描述、分解流计算过程？.mp4
│  │  [6423] 06  CompletableFuture：如何理解 Java 8 新引入的异步编程类？.mp4
│  │  [6424] 07  死锁：为什么流计算应用突然卡住，不处理数据了.mp4
│  │  [6425] 08  性能调优：如何优化流计算应用？.mp4
│  │  [6426] 09  流数据操作：最基本的流计算功能.mp4
│  │  [6427] 10  时间维度聚合计算：如何在长时间窗口上实时计算聚合值？.mp4
│  │  [6428] 11  关联图谱分析：如何用 Lambda 架构实现实时的社交网络分析？.mp4
│  │  [6429] 12  事件序列分析：大家都在说的 CEP 是怎么一回事？.mp4
│  │  [6430] 13  模型学习和预测：如何检查流数据异常？.mp4
│  │  [6431] 14  状态管理：为什么说流计算是有“状态”的？.mp4
│  │  [6432] 15  扩展为集群：如何实现分布式状态存储？.mp4
│  │  [6433] 16  Apache Storm：最早的开源流计算框架.mp4
│  │  [6434] 17  Spark Streaming：从批处理走向流处理.mp4
│  │  [6435] 18  Apache Samza：最简洁的开源流计算框架.mp4
│  │  [6436] 19  Apache Flink：最惊艳的开源流计算框架.mp4
│  │  [6437] 20  场景案例：如何用 Flink 实现实时风控引擎？.mp4
│  │  [6438] 21  场景案例：如何用 Flink SQL CDC 实现实时数据同步？.mp4
│  │  [6439] 彩蛋 1  竟然还有分布式的 JVM？.mp4
│  │  [6440] 彩蛋 2  穷途末路的选择：Lambda 架构.mp4
│  │  [6441] 结束语  Java 程序员的成长之路和从业方向.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：22 讲通关 Go 语言
│  │  [5226] 开篇词  Go 为开发者的需求设计，带你实现高效工作.mp4
│  │  [5227] 01  基础入门：编写你的第一个 Go 语言程序.mp4
│  │  [5228] 02  数据类型：你必须掌握的数据类型有哪些？.mp4
│  │  [5229] 03  控制结构：if、for、witch 逻辑语句的那些事儿.mp4
│  │  [5230] 04  集合类型：如何正确使用 array、lice 和 map？.mp4
│  │  [5231] 05  函数和方法：Go 语言中的函数和方法到底有什么不同？.mp4
│  │  [5232] 06  truct 和 interface：结构体与接口都实现了哪些功能？.mp4
│  │  [5233] 07  错误处理：如何通过 error、deferred、panic 等处理错误？.mp4
│  │  [5234] 08  并发基础：Goroutine 和 Channel 的声明与使用.mp4
│  │  [5235] 09  同步原语：ync 包让你对并发控制得心应手.mp4
│  │  [5236] 10  Context：你必须掌握的多线程并发控制神器.mp4
│  │  [5237] 11  并发模式：Go 语言中即学即用的高效并发模式.mp4
│  │  [5238] 12  指针详解：在什么情况下应该使用指针？.mp4
│  │  [5239] 13  参数传递：值、引用及指针之间的区别？.mp4
│  │  [5240] 14  内存分配：new 还是 make？什么情况下该用谁？.mp4
│  │  [5241] 15  运行时反射：字符串和结构体之间如何转换？.mp4
│  │  [5244] 16  非类型安全：让你既爱又恨的 unafe.mp4
│  │  [5245] 17  SliceHeader：lice 如何高效处理数据？.mp4
│  │  [5246] 18  质量保证：Go 语言如何通过测试保证质量？.mp4
│  │  [5247] 19  性能优化：Go 语言如何进行代码检查和优化？.mp4
│  │  [5248] 20  协作开发：模块化管理为什么能够提升研发效能？.mp4
│  │  [5249] 21  网络编程：Go 语言如何玩转 RESTful API 服务？.mp4
│  │  [5250] 22  网络编程：Go 语言如何通过 RPC 实现跨平台服务？.mp4
│  │  [5251] 结束语  你的 Go 语言成长之路.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：23讲搞定后台架构实战
│  │  [6124] 开篇词  跳出单点思维模式，才能真正理解架构设计.mp4
│  │  [6125] 01  为什么不同类型的业务后台架构模式是通用的？.mp4
│  │  [6126] 02  如何利用“拆分”降低架构复杂度？.mp4
│  │  [6127] 加餐? 技术人如何准备晋升答辩？.mp4
│  │  [6128] 03  如何使用简洁的架构实现高性能读服务？.mp4
│  │  [6129] 04  如何利用全量缓存打造毫秒级的读服务？.mp4
│  │  [6130] 05  如何做到异构数据的同步一致性？.mp4
│  │  [6131] 06  如何应对热点数据的查询？.mp4
│  │  [6132] 07  如何基于流量回放实现读服务的自动化测试回归？.mp4
│  │  [6133] 08 ?如何使用分库分表支持海量数据的写入？.mp4
│  │  [6134] 09 ?如何打造无状态的存储实现随时切库的写入服务？.mp4
│  │  [6135] 10 ?如何利用依赖管控来提升写服务的性能和可用性？.mp4
│  │  [6136] 11 ?分库分表化后如何满足多维度查询？.mp4
│  │  [6137] 12 ?如何利用数据库实现并发扣减？.mp4
│  │  [6138] 13 ?如何利用缓存实现万级并发扣减？.mp4
│  │  [6139] 14  如何利用缓存+数据库构建高可靠的扣减方案？.mp4
│  │  [6140] 15  数据库与缓存的扩展升级与扣减返还.mp4
│  │  [6141] 16  秒杀场景：热点扣减如何保证命中的存储分片不挂？.mp4
│  │  [6142] 17  如何设计一锤子买卖的?SDK?？.mp4
│  │  [6143] 18 ?如何设计微服务才能防止宕机？.mp4
│  │  [6144] 19 如何做好微服务间依赖的治理和分布式事务？.mp4
│  │  [6145] 20  如何通过监控快速发现问题？.mp4
│  │  [6146] 21  如何进行高保真压测和服务扩容？.mp4
│  │  [6147] 22??重构：系统升级，如何实现不停服的数据迁移和用户切量？.mp4
│  │  [6148] 23  重构：烟囱式、平台化、中台化的架构同与异.mp4
│  │  [6149] 结束语??抓住本质，是成为技术专家的不二法则.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：24讲吃透分布式数据库
│  │  [6296] 开篇词  吃透分布式数据库，提升职场竞争力.mp4
│  │  [6297] 01  导论：什么是分布式数据库？聊聊它的前世今生.mp4
│  │  [6298] 02  SQL v NoSQL：一次搞清楚五花八门的“SQL”.mp4
│  │  [6299] 03  数据分片：如何存储超大规模的数据？.mp4
│  │  [6300] 04  数据复制：如何保证数据在分布式场景下的高可用？.mp4
│  │  [6301] 05  一致性与 CAP 模型：为什么需要分布式一致性？.mp4
│  │  [6302] 06  实践：设计一个最简单的分布式数据库.mp4
│  │  [6303] 07  概要：什么是存储引擎，为什么需要了解它？.mp4
│  │  [6304] 08  分布式索引：如何在集群中快速定位数据？.mp4
│  │  [6305] 09  日志型存储：为什么选择它作为底层存储？.mp4
│  │  [6306] 10  事务处理与恢复（上）：数据库崩溃后如何保证数据不丢失？.mp4
│  │  [6307] 11  事务处理与恢复（下）：如何控制并发事务？.mp4
│  │  [6308] 13  概要：分布式系统都要解决哪些问题？.mp4
│  │  [6309] 14  错误侦测：如何保证分布式系统稳定？.mp4
│  │  [6310] 15  领导选举：如何在分布式系统内安全地协调操作？.mp4
│  │  [6311] 16  再谈一致性：除了 CAP 之外的一致性模型还有哪些？.mp4
│  │  [6312] 17  数据可靠传播：反熵理论如何帮助数据库可靠工作？.mp4
│  │  [6313] 18  分布式事务（上）：除了 XA，还有哪些原子提交算法吗？.mp4
│  │  [6314] 19  分布式事务（下）：Spanner 与 Calvin 的巅峰对决.mp4
│  │  [6315] 20  共识算法：一次性说清楚 Paxo、Raft 等算法的区别.mp4
│  │  [6316] 22  发展与局限：传统数据库在分布式领域的探索.mp4
│  │  [6317] 23  数据库中间件：传统数据库向分布式数据库的过渡.mp4
│  │  [6318] 24  现状解读：分布式数据库的最新发展情况.mp4
│  │  [6321] 加餐1  概念解析：云原生、HTAP、图与内存数据库.mp4
│  │  [6542] 12  引擎拓展：解读当前流行的分布式存储引擎.mp4
│  │  [6935] 21  知识串讲：如何取得性能和可扩展性的平衡？.mp4
│  │  [7130] 加餐2  数据库选型：我们该用什么分布式数据库？.mp4
│  │  [7131] 结束语  分布式数据库，未来可期.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：300分钟吃透分布式缓存
│  │  [160] 第01讲：业务数据访问性能太低怎么办？.mp4
│  │  [161] 第02讲：如何根据业务来选择缓存模式和组件？.mp4
│  │  [162] 第03讲：设计缓存架构时需要考量哪些因素？.mp4
│  │  [163] 第04讲：缓存失效、穿透和雪崩问题怎么处理？.mp4
│  │  [164] 第05讲：缓存数据不一致和并发竞争怎么处理？.mp4
│  │  [165] 第06讲：Hot Key和Big Key引发的问题怎么应对？.mp4
│  │  [166] 第07讲：MC为何是应用最广泛的缓存组件？.mp4
│  │  [167] 第08讲：MC系统架构是如何布局的？.mp4
│  │  [168] 第09讲：MC是如何使用多线程和状态机来处理请求命令的？.mp4
│  │  [169] 第10讲：MC是怎么定位key的.mp4
│  │  [170] 第11讲：MC如何淘汰冷key和失效key.mp4
│  │  [171] 第12讲：为何MC能长期维持高性能读写？.mp4
│  │  [172] 第13讲：如何完整学习MC协议及优化client访问？.mp4
│  │  [173] 第14讲：大数据时代，MC如何应对新的常见问题？.mp4
│  │  [174] 第15讲：如何深入理解、应用及扩展 Twemproxy？.mp4
│  │  [175] 第16讲：常用的缓存组件Redi是如何运行的？.mp4
│  │  [176] 第17讲：如何理解、选择并使用Redi的核心数据类型？.mp4
│  │  [177] 第18讲：Redi协议的请求和响应有哪些“套路”可循？.mp4
│  │  [199] 第19讲：Redi系统架构中各个处理模块是干什么的？.mp4
│  │  [200] 第20讲：Redi如何处理文件事件和时间事件？.mp4
│  │  [201] 第21讲：Redi读取请求数据后，如何进行协议解析和处理.mp4
│  │  [202] 第22讲：怎么认识和应用Redi内部数据结构？.mp4
│  │  [203] 第23讲：Redi是如何淘汰key的？.mp4
│  │  [204] 第24讲：Redi崩溃后，如何进行数据恢复的？.mp4
│  │  [205] 第25讲： Redi是如何处理容易超时的系统调用的？.mp4
│  │  [206] 第26讲：如何大幅成倍提升Redi处理性能？.mp4
│  │  [207] 第27讲：Redi是如何进行主从复制的？.mp4
│  │  [208] 第28讲：如何构建一个高性能、易扩展的Redi集群？.mp4
│  │  [209] 第29讲：从容应对亿级QPS访问，Redi还缺少什么？.mp4
│  │  [210] 第30讲：面对海量数据，为什么无法设计出完美的分布式缓存体系？.mp4
│  │  [211] 第31讲：如何设计足够可靠的分布式缓存体系，以满足大中型移动互联网系统的需要？.mp4
│  │  [212] 第32讲：一个典型的分布式缓存系统是什么样的？.mp4
│  │  [213] 第33讲：如何为秒杀系统设计缓存体系？.mp4
│  │  [214] 第34讲：如何为海量计数场景设计缓存体系？.mp4
│  │  [215] 第35讲：如何为社交feed场景设计缓存体系？.mp4
│  │  [59] 开篇寄语：缓存，你真的用对了吗？.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：300分钟搞定数据结构与算法
│  │  [28] 开篇寄语：算法功底决定Offer质量.mp4
│  │  [29] 第01讲：常用数据结构.mp4
│  │  [30] 第02讲：高级数据结构.mp4
│  │  [31] 第03讲：排序.mp4
│  │  [32] 第04讲：递归与回溯.mp4
│  │  [33] 第05讲：深度与广度优先搜索.mp4
│  │  [34] 第06讲：动态规划.mp4
│  │  [35] 第07讲：二分搜索与贪婪.mp4
│  │  [36] 第08讲：高频真题解析 I.mp4
│  │  [37] 第09讲：高频真题解析 II.mp4
│  │  [38] 第10讲：高频真题解析 III（上).mp4
│  │  [39] 第11讲：高频真题解析 IV.mp4
│  │  [40] 彩蛋：算法面试冲刺.mp4
│  │  [86] 第10讲：高频真题解析 III（下).mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：300分钟搞懂 Spring Cloud
│  │  [100] 第12讲：Spring Cloud综合案例.mp4
│  │  [101] 彩蛋：第二代微服务架构Spring Cloud Alibaba.mp4
│  │  [88] 服务治理为何选择Spring Cloud.mp4
│  │  [89] 第01讲：夯实基础-Spring Boot.mp4
│  │  [90] 第02讲：服务治理-Eureka.mp4
│  │  [91] 第03讲：客户端负载均衡-Ribbon.mp4
│  │  [92] 第04讲：服务容错保护-Hytrix.mp4
│  │  [93] 第05讲：声明式服务调用-Feign.mp4
│  │  [94] 第06讲：API网关服务-Zuul.mp4
│  │  [95] 第07讲：分布式配置中心-Apollo.mp4
│  │  [96] 第08讲：分布式链路跟踪.mp4
│  │  [97] 第09讲：微服务安全认证.mp4
│  │  [98] 第10讲：灰度发布实战.mp4
│  │  [99] 第11讲：Spring Cloud常见问题及解决方案.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：31 讲带你搞懂 SkyWalking
│  │  [1720] 开篇词：从剖析 SkyWalking 源码到吃透 APM 核心知识.mp4
│  │  [1721] 第01讲：同九义，为何 SkyWalking 一枝独秀？.mp4
│  │  [1722] 第02讲：链路追踪利器，快速上手 SkyWalking.mp4
│  │  [1723] 第03讲：掌握 Java Agent 真的可以为所欲为？.mp4
│  │  [1724] 第04讲：实战掌握 Byte Buddy，体验代码生成的顺畅.mp4
│  │  [1725] 第05讲：OpenTracing 简介，先有标准后有天.mp4
│  │  [1726] 第06讲：为何各大开源框架专宠 SPI 技术？.mp4
│  │  [1727] 第07讲：Java High Level Client，读写 ES 利器.mp4
│  │  [1728] 第08讲：搭建 SkyWalking 源码环境，开启征途.mp4
│  │  [1729] 第09讲：SkyWalking Agent 启动流程剖析，领略微内核架构之美.mp4
│  │  [1730] 第10讲：深入剖析 Agent 插件原理，无侵入性埋点.mp4
│  │  [1731] 第11讲：BootService 核心实现解析，Agent 的“地基”原来是这样的.mp4
│  │  [1732] 第12讲：剖析 Trace 在 SkyWalking 中的落地实现方案（上）.mp4
│  │  [1733] 第14讲：收集、发送 Trace 核心原理，Agent 与 OAP 的大动脉.mp4
│  │  [1734] 第15讲：Tomcat 插件原理精析，看 SkyWalking 如何增强这只 Cat（上）.mp4
│  │  [1735] 第17讲：Dubbo 插件核心剖析，Trace 是这样跨服务传播的.mp4
│  │  [1736] 第18讲：带你揭开 toolkit-activation 工具箱的秘密.mp4
│  │  [1737] 第19讲：OAP 初始化流程精讲，一眼看透 SkyWalking OAP 骨架.mp4
│  │  [1738] 第20讲：深入剖析 Configuration 插件，实现可插拔接入多种配置中心.mp4
│  │  [1739] 第21讲：Cluter 插件剖析，你想要的集群模式它都有.mp4
│  │  [1740] 第22讲：深入剖析 regiter-receiver-plugin 插件（上）.mp4
│  │  [1741] 第23讲：深入剖析 regiter-receiver-plugin 插件（下）.mp4
│  │  [1742] 第24讲：jvm-receiver 插件探秘 ，不仅有 Trace 还可以有监控.mp4
│  │  [1743] 第25讲：trace-receiver 插件拆解，Trace 蕴含的宝贵信息（上）.mp4
│  │  [1744] 第26讲：trace-receiver 插件拆解，Trace 蕴含的宝贵信息（下）.mp4
│  │  [1745] 第27讲：实战入门 GraphQL，如何将 REST API 换成 GraphQL.mp4
│  │  [1746] 第28讲：深入 query-graphql 插件，SW Rocketbot 背后的英雄（上）.mp4
│  │  [1747] 第30讲：erver-alarm 插件核心剖析，如何避免收到告警信息.mp4
│  │  [1748] 第31讲：OAL 语言，原来定义创造一门新语言如此轻松（上）.mp4
│  │  [1749] 第33讲：优化 Trace 上报性能，让你的 OAP 集群轻松抗住百万流量.mp4
│  │  [1750] 第34讲：实现线程级别监控，轻松搞定 Thread Dump.mp4
│  │  [1751] 结束语：回顾 SkyWalking 架构并展望未来.mp4
│  │  [2033] 第13讲：剖析 Trace 在 SkyWalking 中的落地实现方案（下）.mp4
│  │  [2946] 加餐1：DataCarrier 实现详解.mp4
│  │  [3102] 第16讲：Tomcat 插件原理精析，看 SkyWalking 如何增强这只 Cat（下）.mp4
│  │  [3369] 加餐2：请求接待员 —— Server 那些事.mp4
│  │  [3430] 加餐3：SkyWalking OAP 存储体系剖析.mp4
│  │  [3679] 加餐4：trace-receiver 插件番外篇——慢查询的处理.mp4
│  │  [3764] 第29讲：深入 query-graphql 插件，SW Rocketbot 背后的英雄（下）.mp4
│  │  [4155] 第32讲：OAL 语言，原来定义创造一门新语言如此轻松（下）.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：32个Java面试必考点
│  │  [10] 第07讲（下）：必会框架 - RPC与ORM.mp4
│  │  [11] 第08讲：高并发架构基石 - 缓存.mp4
│  │  [12] 第09讲（上）：消息队列Kafka架构与原理.mp4
│  │  [13] 第09讲（下）：MySQL调优与最佳实践.mp4
│  │  [14] 第10讲：架构的演进之路与前沿技术.mp4
│  │  [15] 彩蛋：技术人行走职场的建议.mp4
│  │  [1] 开篇：建立年薪50万的能力框架.mp4
│  │  [2] 第01讲：技术人职业发展路径.mp4
│  │  [3] 第02讲（上）：操作系统与计算机网络.mp4
│  │  [4] 第02讲（下）：Java语言特性与设计模式.mp4
│  │  [5] 第03讲：深入浅出JVM.mp4
│  │  [6] 第04讲：并发与多线程.mp4
│  │  [7] 第05讲：数据结构与算法.mp4
│  │  [8] 第06讲：常用工具集.mp4
│  │  [9] 第07讲（上）：必会框架 - Spring全家桶.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：42讲轻松通关 Flink
│  │  [2035] 开篇词：实时计算领域最锋利的武器 Flink.mp4
│  │  [2036] 第01讲：Flink 的应用场景和架构模型.mp4
│  │  [2037] 第02讲：Flink 入门程序 WordCount 和 SQL 实现.mp4
│  │  [2038] 第03讲：Flink 的编程模型与其他框架比较.mp4
│  │  [2039] 第04讲：Flink 常用的 DataSet 和 DataStream API.mp4
│  │  [2040] 第05讲：Flink SQL & Table 编程和案例.mp4
│  │  [2041] 第06讲：Flink 集群安装部署和 HA 配置.mp4
│  │  [2042] 第07讲：Flink 常见核心概念分析.mp4
│  │  [2043] 第08讲：Flink 窗口、时间和水印.mp4
│  │  [2044] 第09讲：Flink 状态与容错.mp4
│  │  [2045] 第10讲：Flink Side OutPut 分流.mp4
│  │  [2046] 第11讲：Flink CEP 复杂事件处理.mp4
│  │  [2047] 第12讲：Flink 常用的 Source 和 Connector.mp4
│  │  [2048] 第13讲：如何实现生产环境中的 Flink 高可用配置.mp4
│  │  [2049] 第14讲：Flink Exactly-once 实现原理解析.mp4
│  │  [2050] 第15讲：如何排查生产环境中的反压问题.mp4
│  │  [2051] 第16讲：如何处理生产环境中的数据倾斜问题.mp4
│  │  [2052] 第17讲：生产环境中的并行度和资源设置.mp4
│  │  [2053] 第18讲：如何进行生产环境作业监控.mp4
│  │  [2054] 第19讲：Flink 如何做维表关联.mp4
│  │  [2055] 第20讲：Flink 高级应用之海量数据高效去重.mp4
│  │  [2056] 第21讲：Flink 在实时计算平台和实时数据仓库中的作用.mp4
│  │  [2057] 第22讲：项目背景和整体架构设计.mp4
│  │  [2058] 第23讲：Mock Kafka 消息并发送.mp4
│  │  [2059] 第24讲：Flink 消费 Kafka 数据业务开发.mp4
│  │  [2060] 第25讲：Flink 中 watermark 的定义和使用.mp4
│  │  [2061] 第26讲：Flink 中的聚合函数和累加器的设计和使用.mp4
│  │  [2062] 第27讲：Flink Redi Sink 实现.mp4
│  │  [2063] 第28讲：TopN 热门商品功能实现.mp4
│  │  [2064] 第29讲：项目背景和实时处理系统架构设计.mp4
│  │  [2065] 第30讲：Flume 和 Kafka 整合和部署.mp4
│  │  [2066] 第31讲：Kafka 模拟数据生成和发送.mp4
│  │  [2067] 第32讲：Flink 和 Kafka 整合时间窗口设计.mp4
│  │  [2068] 第33讲：Flink 计算 PV、UV 代码实现.mp4
│  │  [2069] 第34讲：Flink 和 Redi 整合以及 Redi Sink 实现.mp4
│  │  [2070] 第35讲：项目背景和 Flink CEP 简介.mp4
│  │  [2071] 第36讲：自定义消息事件.mp4
│  │  [2072] 第37讲：自定义 Pattern 和报警规则.mp4
│  │  [2073] 第38讲：Flink 调用 CEP 实现报警功能.mp4
│  │  [2074] 第39讲：Flink 面试-基础篇.mp4
│  │  [2075] 第40讲：Flink 面试-进阶篇.mp4
│  │  [2076] 第41讲：Flink 面试-源码篇.mp4
│  │  [2077] 第42讲：Flink 面试-方案设计篇.mp4
│  │  [4602] 结束语：疾风亦有归途.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：52讲轻松搞定网络爬虫
│  │  [1661] 开篇词：如何高效学好网络爬虫.mp4
│  │  [1662] 第01讲：必知必会，掌握 HTTP 基本原理.mp4
│  │  [1663] 第02讲：夯实根基，Web 网页基础.mp4
│  │  [1664] 第03讲：原理探究，了解爬虫的基本原理.mp4
│  │  [1665] 第04讲：基础探究，Seion 与 Cookie.mp4
│  │  [1666] 第05讲：多路加速，了解多线程基本原理.mp4
│  │  [1667] 第06讲：多路加速，了解多进程基本原理.mp4
│  │  [1668] 第07讲：入门首选，Requet 库的基本使用.mp4
│  │  [1669] 第08讲：解析无所不能的正则表达式.mp4
│  │  [1670] 第09讲：爬虫解析利器 PyQuery 的使用.mp4
│  │  [1671] 第10讲：高效存储 MongoDB 的用法.mp4
│  │  [1672] 第11讲：Reqeut + PyQuery + PyMongo 基本案例实战.mp4
│  │  [1673] 第12讲：Ajax 的原理和解析.mp4
│  │  [1674] 第13讲：Ajax 爬取案例实战.mp4
│  │  [1675] 第14讲：Selenium 的基本使用.mp4
│  │  [1676] 第15讲：Selenium 爬取实战.mp4
│  │  [1677] 第16讲：异步爬虫的原理和解析.mp4
│  │  [1678] 第17讲：aiohttp 异步爬虫实战.mp4
│  │  [1679] 第18讲：爬虫神器 Pyppeteer 的使用.mp4
│  │  [1680] 第19讲：Pyppeteer 爬取实战.mp4
│  │  [1681] 第20讲：代理的基本原理和用法.mp4
│  │  [1682] 第21讲：提高利用效率，代理池的搭建和使用.mp4
│  │  [1683] 第22讲：验证码反爬虫的基本原理.mp4
│  │  [1684] 第23讲：利用资源，学会用打码平台处理验证码.mp4
│  │  [1685] 第24讲：更智能的深度学习处理验证码.mp4
│  │  [1686] 第25讲：你有权限吗？解析模拟登录基本原理.mp4
│  │  [1687] 第26讲：模拟登录爬取实战案例.mp4
│  │  [1688] 第27讲：令人抓狂的 JavaScript 混淆技术.mp4
│  │  [1689] 第28讲：JavaScript 逆向爬取实战（上）.mp4
│  │  [1690] 第30讲：App 爬虫是怎么着情况？.mp4
│  │  [1691] 第31讲：抓包利器 Charle 的使用.mp4
│  │  [1692] 第32讲：实时处理利器 mitmproxy 的使用.mp4
│  │  [1693] 第33讲：可见即可爬，Appium 的使用.mp4
│  │  [1694] 第34讲：更好用的自动化工具 airtet 的使用.mp4
│  │  [1695] 第35讲：无所不能的 Xpoed 的使用.mp4
│  │  [1696] 第36讲：App 逆向的常见技巧.mp4
│  │  [1697] 第37讲：智能化解析是怎样的技术？.mp4
│  │  [1698] 第38讲：智能化解析解析工具使用.mp4
│  │  [1699] 第39讲：页面智能解析算法原理解析.mp4
│  │  [1700] 第40讲：跟我来一起实现智能化解析算法吧.mp4
│  │  [1701] 第41讲：无人不知的 Scrapy 爬虫框架的介绍.mp4
│  │  [1702] 第42讲：初窥门路 Scrapy 的基本使用.mp4
│  │  [1703] 第43讲：灵活好用的 Spider 的用法.mp4
│  │  [1704] 第44讲：功能强大的 Middleware 的用法.mp4
│  │  [1705] 第45讲：哪都能存，Item Pipeline 的用法.mp4
│  │  [1706] 第46讲：遇到动态页面怎么办？详解渲染页面爬取.mp4
│  │  [1707] 第47讲：大幅提速，分布式爬虫理念.mp4
│  │  [1708] 第48讲：分布式利器 Scrapy-Redi 原理.mp4
│  │  [1709] 第49讲：实战上手，Scrapy-Redi 分布式实现.mp4
│  │  [1710] 第50讲：Scrapy 部署不用愁，Scrapyd 的原理和使用.mp4
│  │  [1712] 第51讲：容器化技术也得会，Scrapy 对接 Docker.mp4
│  │  [1713] 第52讲：Scrapy 对接 Kubernete 并实现定时爬取.mp4
│  │  [3108] 第29讲：JavaScript 逆向爬取实战（下）.mp4
│  │  [4506] 结束语：从爬虫小白到高手的必经之路.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：Android 工程师进阶 34 讲
│  │  [1854] 开篇词：跳出舒适区，走在行业前端.mp4
│  │  [1855] 第01讲：程序运行时，内存到底是如何进行分配的？.mp4
│  │  [1856] 第02讲：GC 回收机制与分代回收策略.mp4
│  │  [1857] 第03讲：字节码层面分析 cla 类文件结构.mp4
│  │  [1858] 第04讲：编译插桩操纵字节码，实现不可能完成的任务.mp4
│  │  [1859] 第05讲：深入理解 ClaLoader 的加载机制.mp4
│  │  [1860] 第06讲：Cla 对象在执行引擎中的初始化过程.mp4
│  │  [1861] 第07讲：Java 内存模型与线程.mp4
│  │  [1862] 第08讲：既生 Synchronized，何生 ReentrantLock.mp4
│  │  [1863] 第09讲：Java 线程优化 偏向锁，轻量级锁、重量级锁.mp4
│  │  [1864] 第10讲：深入理解 AQS 和 CAS 原理.mp4
│  │  [1865] 第11讲：线程池之刨根问底.mp4
│  │  [1866] 第12讲：DVM 以及 ART 是如何对 JVM 进行优化的？.mp4
│  │  [1867] 第13讲：Android 是如何通过 Activity 进行交互的？.mp4
│  │  [1868] 第14讲：彻底掌握 Android touch 事件分发时序.mp4
│  │  [1869] 第15讲：Android 如何自定义 View？.mp4
│  │  [1870] 第16讲：为什么 RecyclerView 可以完美替代 Litview？.mp4
│  │  [1871] 第17讲：Android OkHttp 全面详解.mp4
│  │  [1872] 第18讲：Android Bitmap 全面详解.mp4
│  │  [1873] 第19讲：tartActivity 启动过程分析.mp4
│  │  [1874] 第20讲：底层剖析 Window 、Activity、 View 三者关系.mp4
│  │  [1875] 第21讲：Android 如何通过 View 进行渲染？.mp4
│  │  [1876] 第22讲：Android App 的安装过程.mp4
│  │  [1877] 第23讲：15?分钟彻底掌握?Handler.mp4
│  │  [1878] 第24讲：APK 如何做到包体积优化？.mp4
│  │  [1879] 第25讲：Android 崩溃的那些事儿.mp4
│  │  [1880] 第26讲：面对内存泄漏，如何进行优化？.mp4
│  │  [1881] 第27讲：面对 UI 卡顿，如何入手分析解决问题？.mp4
│  │  [1882] 第28讲：Android Gradle 构建问题解析.mp4
│  │  [1883] 第29讲：MVP 中 preenter 生命周期的管理.mp4
│  │  [1884] 第30讲：如何设计一个比较合理的 LogUtil 类？.mp4
│  │  [1885] 第31讲：Android 屏幕适配的处理技巧都有哪些？.mp4
│  │  [1886] 第32讲：解析动态权限适配遇到的问题.mp4
│  │  [1887] 第33讲：对于网络编程，你做过哪些优化？.mp4
│  │  [1888] 第34讲：混合开发真的适合你吗？.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：DDD 微服务落地实战
│  │  [5324] 开篇词  让我们把 DDD 的思想真正落地.mp4
│  │  [5325] 01  DDD ：杜绝软件退化的利器.mp4
│  │  [5326] 02  以电商支付功能为例演练 DDD.mp4
│  │  [5327] 03  DDD 是如何落地到数据库设计的？.mp4
│  │  [5328] 04  领域模型是如何指导程序设计的？.mp4
│  │  [5329] 05  聚合、仓库与工厂：傻傻分不清楚.mp4
│  │  [5330] 06  限界上下文：冲破微服务设计困局的利器.mp4
│  │  [5331] 07  在线订餐场景中是如何开事件风暴会议的？.mp4
│  │  [5332] 08  DDD 是如何解决微服务拆分难题的？.mp4
│  │  [5333] 09  DDD 是如何落地微服务设计实现的？.mp4
│  │  [5334] 11  解决技术改造困局的钥匙：整洁架构.mp4
│  │  [5335] 12  如何设计支持快速交付的技术中台战略？.mp4
│  │  [5336] 13    如何实现支持快速交付的技术中台设计？.mp4
│  │  [5337] 14  如何设计支持 DDD 的技术中台？.mp4
│  │  [5338] 16  基于 DDD 的代码设计演示（含 DDD 的技术中台设计）.mp4
│  │  [5339] 17  基于 DDD 的微服务设计演示（含支持微服务的 DDD 技术中台设计）.mp4
│  │  [5340] 19  远程智慧医疗平台（微服务+人工智能）的设计过程.mp4
│  │  [5341] 20  智能温控系统（嵌入式+物联网）的 DDD 设计过程.mp4
│  │  [5342] 结束语  DDD 为你打开通向光明未来的大门.mp4
│  │  [5961] 10  微服务落地的技术实践.mp4
│  │  [6021] 15  如何设计支持微服务的技术中台？.mp4
│  │  [6200] 18  基于事件溯源的设计开发.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：DevOps 落地笔记
│  │  [5743] 开篇词  落地 DevOp，你需要一个全局视角.mp4
│  │  [5744] 01  追本溯源：DevOp 的发展历史回顾.mp4
│  │  [5745] 02  影响地图：产品规划和需求分析的利器.mp4
│  │  [5746] 03  用户故事：对用户需求达成共识的关键.mp4
│  │  [5747] 04  看板方法：成员工作内容清楚明白方法.mp4
│  │  [5748] 05  非功能需求：如何有效关注非功能需求.mp4
│  │  [5749] 06  代码预检查：提高入库代码质量的神兵利器.mp4
│  │  [5750] 07  案例分析：如何有效管理第三方组件.mp4
│  │  [5751] 08  技术债务：勤借勤还，再借不难.mp4
│  │  [5752] 09  配置管理：实现一包到底的必胜手段.mp4
│  │  [5753] 10  环境管理：交付测试环境的迅猛方法.mp4
│  │  [5754] 11  持续集成：软件持续集成，发布信手拈来.mp4
│  │  [5755] 12  API 管理：微服务时代的必备工具.mp4
│  │  [5756] 13  自动化测试：提高测试效率的不二之选.mp4
│  │  [5757] 14  部署流水线：打造一站式部署的关键平台.mp4
│  │  [5758] 15  混沌工程，通过问题注入提高系统可靠性.mp4
│  │  [5759] 16  案例分析：百度效率云是如何做代码审查的.mp4
│  │  [5760] 17  度量指标：寻找真正的好指标？.mp4
│  │  [5761] 18  团队能力：团队能力=交付能力.mp4
│  │  [5762] 19  响应速度：天下武功，唯快不破.mp4
│  │  [5763] 20  软件质量：决定系统成功的关键.mp4
│  │  [5764] 21  业务价值：软件发布的最终目的.mp4
│  │  [5765] 结束语  DevOp，下一站在哪里？.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：Dubbo源码解读与实战
│  │  [4256] 开篇词  深入掌握 Dubbo 原理与实现，提升你的职场竞争力.mp4
│  │  [4257] 01  Dubbo 源码环境搭建：千里之行，始于足下.mp4
│  │  [4258] 02  Dubbo 的配置总线：抓住 URL，就理解了半个 Dubbo.mp4
│  │  [4259] 03  Dubbo SPI 精析，接口实现两极反转（上）.mp4
│  │  [4260] 05  海量定时任务，一个时间轮搞定.mp4
│  │  [4261] 06  ZooKeeper 与 Curator，求你别用 ZkClient 了（上）.mp4
│  │  [4262] 08  代理模式与常见实现.mp4
│  │  [4263] 09  Netty 入门，用它做网络编程都说好（上）.mp4
│  │  [4264] 11  简易版 RPC 框架实现（上）.mp4
│  │  [4265] 13  本地缓存：降低 ZooKeeper 压力的一个常用手段.mp4
│  │  [4266] 14  重试机制是网络操作的基本保证.mp4
│  │  [4267] 15  ZooKeeper 注册中心实现，官方推荐注册中心实践.mp4
│  │  [4268] 16  Dubbo Serialize 层：多种序列化算法，总有一款适合你.mp4
│  │  [4269] 17  Dubbo Remoting 层核心接口分析：这居然是一套兼容所有 NIO 框架的设计？.mp4
│  │  [4270] 18  Buffer 缓冲区：我们不生产数据，我们只是数据的搬运工.mp4
│  │  [4271] 19  Tranporter 层核心实现：编解码与线程模型一文打尽（上）.mp4
│  │  [4272] 20  Tranporter 层核心实现：编解码与线程模型一文打尽（下）.mp4
│  │  [4273] 23  核心接口介绍，RPC 层骨架梳理.mp4
│  │  [4274] 24  从 Protocol 起手，看服务暴露和服务引用的全流程（上）.mp4
│  │  [4275] 28  复杂问题简单化，代理帮你隐藏了多少底层细节？.mp4
│  │  [4276] 29  加餐：HTTP 协议 + JSON-RPC，Dubbo 跨语言就是如此简单.mp4
│  │  [4277] 31  加餐：深潜 Directory 实现，探秘服务目录玄机.mp4
│  │  [4278] 32  路由机制：请求到底怎么走，它说了算（上）.mp4
│  │  [4279] 33  路由机制：请求到底怎么走，它说了算（下）.mp4
│  │  [4280] 43  服务自省设计方案：新版本新方案.mp4
│  │  [4281] 44  元数据方案深度剖析，如何避免注册中心数据量膨胀？.mp4
│  │  [4282] 45  加餐：深入服务自省方案中的服务发布订阅（上）.mp4
│  │  [4345] 04  Dubbo SPI 精析，接口实现两极反转（下）.mp4
│  │  [4467] 07  ZooKeeper 与 Curator，求你别用 ZkClient 了（下）.mp4
│  │  [4568] 10  Netty 入门，用它做网络编程都说好（下）.mp4
│  │  [4603] 12  简易版 RPC 框架实现（下）.mp4
│  │  [4819] 21  Exchange 层剖析：彻底搞懂 Requet-Repone 模型（上）.mp4
│  │  [4828] 22  Exchange 层剖析：彻底搞懂 Requet-Repone 模型（下）.mp4
│  │  [4880] 25  从 Protocol 起手，看服务暴露和服务引用的全流程（下）.mp4
│  │  [4971] 26  加餐：直击 Dubbo “心脏”，带你一起探秘 Invoker（上）.mp4
│  │  [4972] 27  加餐：直击 Dubbo “心脏”，带你一起探秘 Invoker（下）.mp4
│  │  [4973] 结束语  认真学习，缩小差距.mp4
│  │  [5194] 30  Filter 接口，扩展 Dubbo 框架的常用手段指北.mp4
│  │  [5272] 34  加餐：初探 Dubbo 动态配置的那些事儿.mp4
│  │  [5363] 35  负载均衡：公平公正物尽其用的负载均衡策略，这里都有（上）.mp4
│  │  [5742] 36  负载均衡：公平公正物尽其用的负载均衡策略，这里都有（下）.mp4
│  │  [5834] 37  集群容错：一个好汉三个帮（上）.mp4
│  │  [5835] 38  集群容错：一个好汉三个帮（下）.mp4
│  │  [5895] 39  加餐：多个返回值不用怕，Merger 合并器来帮忙.mp4
│  │  [5896] 40  加餐：模拟远程调用，Mock 机制帮你搞定.mp4
│  │  [5963] 41  加餐：一键通关服务发布全流程.mp4
│  │  [5964] 42  加餐：服务引用流程全解析.mp4
│  │  [6100] 46  加餐：深入服务自省方案中的服务发布订阅（下）.mp4
│  │  [6101] 47  配置中心设计与实现：集中化配置 and 本地化配置，我都要（上）.mp4
│  │  [6102] 48  配置中心设计与实现：集中化配置 and 本地化配置，我都要（下）.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：etcd 原理与实践
│  │  [6394] 开篇词  学习优秀开源项目，提升分布式开发与架构能力.mp4
│  │  [6395] 01  核心概念：etcd 到底是一款什么样的组件？.mp4
│  │  [6396] 02  安装部署：手把手教你玩转 etcd 搭建.mp4
│  │  [6397] 03  etcdctl：客户端操作 etcd 服务端的工具.mp4
│  │  [6398] 04  etcd 网关与 gRPC-Gateway 分别是什么？.mp4
│  │  [6399] 05  gRPC 代理模式：实现可伸缩的 etcd API.mp4
│  │  [6400] 06  集群配置：如何动态重配置 etcd 集群？.mp4
│  │  [6401] 07  集群调优：如何使 etcd 集群处于最佳状态？.mp4
│  │  [6402] 08  纵览全局：etcd 的架构是什么样的？.mp4
│  │  [6403] 09  通信接口：客户端 API 实践与核心方法.mp4
│  │  [6404] 10  etcd 存储：如何实现键值对的读写操作？.mp4
│  │  [6405] 11  etcd-raft 模块如何实现分布式一致性？.mp4
│  │  [6406] 12  多版本控制：etcd 如何实现 MVCC ？.mp4
│  │  [6407] 13  etcd 中如何实现分布式事务？.mp4
│  │  [6408] 14  etcd watch：etcd 如何实现 watch 机制？.mp4
│  │  [6409] 15  etcd leae：etcd 如何实现租约？.mp4
│  │  [6410] 16  启动 etcd 过程中发生了什么？.mp4
│  │  [6411] 17  服务端如何处理客户端的一次请求？.mp4
│  │  [6412] 18  如何基于 etcd 实现分布式锁？.mp4
│  │  [6413] 19  基于 etcd 实现微服务的注册与发现.mp4
│  │  [6414] 20  如何在微服务框架中集成 etcd ？.mp4
│  │  [6415] 21  etcd 在 Kubernete 中如何保证容器的调度？.mp4
│  │  [6416] 结束语  etcd 在服务端架构中的展望.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：Flutter快学快用24讲
│  │  [3516] 开篇词  通往大前端的一把关键钥匙 Flutter.mp4
│  │  [3517] 导读  大前端趋势所向：这么多跨端技术，为什么选择 Flutter？.mp4
│  │  [3518] 01  Flutter Dart 语法：从 JavaScript 角度学习 Dart.mp4
│  │  [3519] 02   事件循环：Flutter 中代码是如何执行和运行的.mp4
│  │  [3520] 03  Hello Flutter：三步法掌握 Flutter，开始你的第一个应用.mp4
│  │  [3521] 04  代码规范：实践开发 Flutter 编程代码规范工具.mp4
│  │  [3522] 05  生命周期：掌握 Flutter 生命周期以及应用场景.mp4
│  │  [3523] 06  有无状态组件：如何巧妙地应用 Flutter 有无状态组件.mp4
│  │  [3524] 07  状态管理：Flutter 状态管理及对比选型.mp4
│  │  [3525] 08  单元测试：Flutter 应用单元测试，提升代码质量.mp4
│  │  [3526] 09  项目脚手架：一个命令构建 Flutter 项目.mp4
│  │  [3527] 10  路由设计：Flutter 中是如何实现 Scheme 跳转的.mp4
│  │  [3528] 11  多样式导航栏：掌握所有 Flutter 导航栏的设计.mp4
│  │  [3529] 12  列表样式：实践 Flutter 中内容多样式展示方式.mp4
│  │  [3530] 13  刷新加载：下拉刷新上拉加载，在 Flutter 中的实现.mp4
│  │  [3531] 14  红点组件：如何将红点设计做成 Flutter 组件.mp4
│  │  [3532] 15  服务通信：Flutter 中常见的网络协议.mp4
│  │  [3533] 16  布局设计：如何将 Flutter 布局设计沉淀为理论规范.mp4
│  │  [3534] 17  打包发布：Flutter 应用，你离线上运营只差最后一步.mp4
│  │  [3535] 18  项目实战：实践 Flutter 交友功能.mp4
│  │  [3536] 19  安全保障：Flutter 工具化实现线上安全与稳定.mp4
│  │  [3537] 20  原生通信：应用原生平台交互扩充 Flutter 基础能力.mp4
│  │  [3538] 21  性能优化：掌握 Flutter 的性能分析和监控.mp4
│  │  [3539] 22  自渲染模式：从 Flutter 的渲染原理，进一步掌握性能优化策略.mp4
│  │  [3540] 23  架构原理：为什么 Flutter 性能更佳.mp4
│  │  [4514] 结束语  对技术的发展要有所远见.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：Go 微服务实战 38 讲
│  │  [3798] 开篇词  掌握 Go 和微服务，跟进未来服务端开发的主流趋势.mp4
│  │  [3799] 01  为什么说云原生重构了互联网产品开发模式？.mp4
│  │  [3800] 02  云原生基础架构的组成以及云原生应用的特征.mp4
│  │  [3801] 03  微服务架构是如何演进的？.mp4
│  │  [3802] 04  DDD 领域场景分析的战略模式.mp4
│  │  [3803] 05  为什么说 Service Meh 是下一代微服务架构？.mp4
│  │  [3804] 06  Go 语言开发快速回顾：语法、数据结构和流程控制.mp4
│  │  [3805] 07  如何使用 Go 更好地开发并发程序？.mp4
│  │  [3806] 08  如何基于 Go-kit 开发 Web 应用：从接口层到业务层再到数据层.mp4
│  │  [3807] 09  案例：货运平台应用的微服务划分.mp4
│  │  [3808] 10  案例：微服务 Docker 容器化部署和 Kubernete 容器编排.mp4
│  │  [3809] 11  案例：如何结合 Jenkin 完成持续化集成和自动化测试？.mp4
│  │  [3810] 12  服务注册与发现如何满足服务治理？.mp4
│  │  [3811] 13  案例：如何基于 Conul 给微服务添加服务注册与发现？.mp4
│  │  [3812] 14  案例：如何在 Go-kit 和 Service Meh 中进行服务注册与发现？.mp4
│  │  [3813] 15  微服务间如何进行远程方法调用？.mp4
│  │  [3814] 16  Go RPC 如何实现服务间通信？.mp4
│  │  [3815] 17  gRPC 和 Apache Thrift 之间如何进行选型？.mp4
│  │  [3816] 18  案例：Go-kit 如何集成 gRPC？.mp4
│  │  [3817] 22  如何保障分布式系统的高可用性？（上）.mp4
│  │  [3818] 23  如何保障分布式系统的高可用性？（下）.mp4
│  │  [3819] 24  如何实现熔断机制？.mp4
│  │  [3820] 25  如何实现接口限流和降级？.mp4
│  │  [3821] 26  案例：如何通过 Service Meh 实现熔断和限流？.mp4
│  │  [3822] 27  负载均衡如何提高系统可用性？.mp4
│  │  [3823] 28  案例：如何在 Go 微服务中实现负载均衡？.mp4
│  │  [3824] 29  统一认证与授权如何保障服务安全？.mp4
│  │  [3825] 30  如何设计基于 OAuth2 和 JWT 的认证与授权服务体系.mp4
│  │  [3826] 31  案例：如何自定义授权服务器？.mp4
│  │  [3827] 32  案例：如何保证微服务实例资源安全？.mp4
│  │  [3828] 33  如何追踪分布式系统调用链路的问题？.mp4
│  │  [3829] 34  OpenTracing 规范介绍与分布式链路追踪组件选型.mp4
│  │  [3830] 35  案例：如何在微服务中集成 Zipkin 组件？.mp4
│  │  [3831] 36  如何使用 ELK 进行日志采集以及统一处理？.mp4
│  │  [3832] 37  如何处理 Go 错误异常与并发陷阱？.mp4
│  │  [3833] 38  案例：如何使用 Prometheu 和 Grafana 监控预警服务集群？.mp4
│  │  [3834] 结束语  云原生不是服务端架构的终点.mp4
│  │  [3839] 19  微服务网关如何作为服务端统一入口点？.mp4
│  │  [3840] 20  如何进行网关选型？.mp4
│  │  [3841] 21  案例：如何使用 Kong 进行网关业务化定制？.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：iOS开发进阶
│  │  [6653] 开篇词  iOS 架构与开发工程化，让你成为 10x 程序员.mp4
│  │  [6654] 01  开发环境：如何使用 Ruby 工具链统一开发环境？.mp4
│  │  [6655] 02  依赖管理：如何使用 CocoaPod 统一依赖库的管理？.mp4
│  │  [6656] 03  配置准备：如何搭建多环境支持，为 App 开发作准备.mp4
│  │  [6657] 04  编码规范：如何使用 SwiftLint 统一编码规范？.mp4
│  │  [6658] 05  自动化准备：如何使用 Fatlane 管理自动化操作？.mp4
│  │  [6659] 06  代码管理：如何使用 Git 与 GitHub 统一代码管理流程？.mp4
│  │  [6660] 07  设计规范：如何统一设计规范，提高沟通效率？.mp4
│  │  [6661] 08  设计组件：DeignKit 组件桥接设计与开发规范.mp4
│  │  [6662] 09  开关组件：如何使用功能开关，支持产品快速迭代.mp4
│  │  [6663] 10  支撑组件：如何实现隐藏菜单，快速测试与验证？.mp4
│  │  [6664] 11  功能组件：如何使用路由，支持多页面导航？.mp4
│  │  [6665] 12  功能组件：如何设置多语言支持，为全球化做准备？.mp4
│  │  [6666] 13  功能组件：如何设置动态字体，提升视力辅助功能？.mp4
│  │  [6667] 14  功能组件：如何使用语义色，支持深色模式？.mp4
│  │  [6668] 15  跨平台架构：如何设计 BFF 架构系统？.mp4
│  │  [6669] 16  架构模式：为什么要选择 MVVM 模式？.mp4
│  │  [6670] 17  响应式编程：如何保证程序状态自动更新？.mp4
│  │  [6672] 18  网络层架构：如何设计网络访问与 JSON 数据解析？.mp4
│  │  [6674] 19  数据层架构：如何使用仓库模式设计数据存储层？.mp4
│  │  [6675] 20  View Model 架构：如何准备 UI 层的数据？.mp4
│  │  [6676] 21  UI 层架构：如何开发统一并且灵活的 UI？.mp4
│  │  [6677] 22  功能实战：如何使用现有架构添加点赞功能？.mp4
│  │  [6678] 23  TDD 与单元测试：如何保证功能模块的高质量？.mp4
│  │  [6679] 24  解决打包痛点：如何统一管理 Certificate 和 Profile？.mp4
│  │  [6680] 25  自动化构建：解决大量重复性人力工作神器.mp4
│  │  [6681] 26  持续集成：如何实现无需人手的快速交付？.mp4
│  │  [6682] 27  统计分析：如何架构灵活的统计分析服务，助力产品增长？.mp4
│  │  [6683] 28  崩溃报告：如何借助崩溃报告解决线上的 Bug？.mp4
│  │  [6684] 29  远程开关：如何远程遥控上线 App 的产品行为？.mp4
│  │  [6685] 30  AB 测试：如何用 AB 测试协助产品抉择？.mp4
│  │  [6686] 31  App Icon 制作：如何使用 Figma 快速制作 App Icon？.mp4
│  │  [6687] 32  UI 替换：如何使用 SwiftUI 快速替换原有 UI？.mp4
│  │  [6688] 结束语  眼见千遍，不如手过一遍.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：Java 并发编程 78 讲
│  │  [238] 开篇词： 由点及面，搭建你的 Java 并发知识网.mp4
│  │  [239] 第01讲：为何说只有 1 种实现线程的方法？.mp4
│  │  [240] 第02讲：如何正确停止线程？为什么 volatile 标记位的停止方法是错误的？.mp4
│  │  [241] 第03讲：线程是如何在 6 种状态之间转换的？.mp4
│  │  [242] 第04讲：waitnotifynotifyAll 方法的使用注意事项？.mp4
│  │  [243] 第05讲：有哪几种实现生产者消费者模式的方法？.mp4
│  │  [244] 第06讲：一共有哪 3 类线程安全问题？.mp4
│  │  [245] 第07讲：哪些场景需要额外注意线程安全问题？.mp4
│  │  [246] 第08讲：为什么多线程会带来性能问题？.mp4
│  │  [247] 第09讲：使用线程池比手动创建线程好在哪里？.mp4
│  │  [248] 第10讲：线程池的各个参数的含义？.mp4
│  │  [249] 第11讲：线程池有哪 4 种拒绝策略？.mp4
│  │  [250] 第12讲：有哪 6 种常见的线程池？什么是 Java8 的 ForkJoinPool？.mp4
│  │  [251] 第13讲：线程池常用的阻塞队列有哪些？.mp4
│  │  [252] 第14讲：为什么不应该自动创建线程池？.mp4
│  │  [253] 第15讲：合适的线程数量是多少？CPU 核心数和线程数的关系？.mp4
│  │  [254] 第16讲：如何根据实际需要，定制自己的线程池？.mp4
│  │  [255] 第17讲：如何正确关闭线程池？hutdown 和 hutdownNow 的区别？.mp4
│  │  [256] 第18讲：线程池实现“线程复用”的原理？.mp4
│  │  [257] 第19讲：你知道哪几种锁？分别有什么特点？.mp4
│  │  [258] 第20讲：悲观锁和乐观锁的本质是什么？.mp4
│  │  [259] 第21讲：如何看到 ynchronized 背后的“monitor 锁”？.mp4
│  │  [260] 第22讲：ynchronized 和 Lock 孰优孰劣，如何选择？.mp4
│  │  [261] 第23讲：Lock 有哪几个常用方法？分别有什么用？.mp4
│  │  [262] 第24讲：讲一讲公平锁和非公平锁，为什么要“非公平”？.mp4
│  │  [263] 第29讲：HahMap 为什么是线程不安全的？.mp4
│  │  [264] 第30讲：ConcurrentHahMap 在 Java7 和 8 有何不同？.mp4
│  │  [265] 第25讲：读写锁 ReadWriteLock 获取锁有哪些规则？.mp4
│  │  [266] 第26讲：读锁应该插队吗？什么是读写锁的升降级？.mp4
│  │  [267] 第27讲：什么是自旋锁？自旋的好处和后果是什么呢？.mp4
│  │  [268] 第28讲：JVM 对锁进行了哪些优化？.mp4
│  │  [269] 第31讲：为什么 Map 桶中超过 8 个才转为红黑树？.mp4
│  │  [270] 第32讲：同样是线程安全，ConcurrentHahMap 和 Hahtable 的区别？.mp4
│  │  [271] 第33讲：CopyOnWriteArrayLit 有什么特点？.mp4
│  │  [272] 第34讲：什么是阻塞队列？.mp4
│  │  [273] 第35讲：阻塞队列包含哪些常用的方法？add、offer、put 等方法的区别？.mp4
│  │  [274] 第36讲：有哪几种常见的阻塞队列？.mp4
│  │  [275] 第37讲：阻塞和非阻塞队列的并发安全原理是什么？.mp4
│  │  [276] 第38讲：如何选择适合自己的阻塞队列？.mp4
│  │  [277] 第39讲：原子类是如何利用 CAS 保证线程安全的？.mp4
│  │  [278] 第40讲：AtomicInteger 在高并发下性能不好，如何解决？为什么？.mp4
│  │  [279] 第41讲：原子类和 volatile 有什么异同？.mp4
│  │  [280] 第42讲：AtomicInteger 和 ynchronized 的异同点？.mp4
│  │  [281] 第43讲：Java 8 中 Adder 和 Accumulator 有什么区别？.mp4
│  │  [282] 第44讲：ThreadLocal 适合用在哪些实际生产的场景中？.mp4
│  │  [283] 第45讲：ThreadLocal 是用来解决共享资源的多线程访问的问题吗？.mp4
│  │  [284] 第46讲：多个 ThreadLocal 在 Thread 中的 threadlocal 里是怎么存储的？.mp4
│  │  [287] 第50讲：使用 Future 有哪些注意点？Future 产生新的线程了吗？.mp4
│  │  [289] 第51讲：如何利用 CompletableFuture 实现“旅游平台”问题？.mp4
│  │  [290] 第52讲：信号量能被 FixedThreadPool 替代吗？.mp4
│  │  [291] 第53讲：CountDownLatch 是如何安排线程执行顺序的？.mp4
│  │  [293] 第55讲：Condition、object.wait() 和 notify() 的关系？.mp4
│  │  [294] 第56讲：讲一讲什么是 Java 内存模型？.mp4
│  │  [295] 第57讲：什么是指令重排序？为什么要重排序？.mp4
│  │  [296] 第58讲：Java 中的原子操作有哪些注意事项？.mp4
│  │  [297] 第59讲：什么是“内存可见性”问题？.mp4
│  │  [298] 第60讲：主内存和工作内存的关系？.mp4
│  │  [299] 第61讲：什么是 happen-before 规则？.mp4
│  │  [300] 第62讲：volatile 的作用是什么？与 ynchronized 有什么异同？.mp4
│  │  [301] 第63讲：单例模式的双重检查锁模式为什么必须加 volatile？.mp4
│  │  [302] 第64讲：你知道什么是 CAS 吗？.mp4
│  │  [303] 第65讲：CAS 和乐观锁的关系，什么时候会用到 CAS？.mp4
│  │  [304] 第66讲：CAS 有什么缺点？.mp4
│  │  [305] 第67讲：如何写一个必然死锁的例子？.mp4
│  │  [306] 第68讲：发生死锁必须满足哪 4 个条件？.mp4
│  │  [307] 第69讲：如何用命令行和代码定位死锁？.mp4
│  │  [308] 第70讲：有哪些解决死锁问题的策略？.mp4
│  │  [309] 第71讲：讲一讲经典的哲学家就餐问题.mp4
│  │  [310] 第72讲：final 的三种用法是什么？.mp4
│  │  [311] 第73讲：为什么加了 final 却依然无法拥有“不变性”？.mp4
│  │  [312] 第74讲：为什么 String 被设计为是不可变的？.mp4
│  │  [313] 第75讲：为什么需要 AQS？AQS 的作用和重要性是什么？.mp4
│  │  [314] 第76讲：AQS 的内部原理是什么样的？.mp4
│  │  [315] 第77讲：AQS 在 CountDownLatch 等类中的应用原理是什么？.mp4
│  │  [316] 第78讲：一份独家的 Java 并发工具图谱.mp4
│  │  [8723] 参考文献、版权声明、致谢.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：Java 性能优化实战 21 讲
│  │  [4177] 开篇词  Java 性能优化，是进阶高级架构师的炼金石.mp4
│  │  [4178] 01  理论分析：性能优化，有哪些衡量指标？需要注意什么？.mp4
│  │  [4179] 02  理论分析：性能优化有章可循，谈谈常用的切入点.mp4
│  │  [4180] 03  深入剖析：哪些资源，容易成为瓶颈？.mp4
│  │  [4181] 04  工具实践：如何获取代码性能数据？.mp4
│  │  [4182] 05  工具实践：基准测试 JMH，精确测量方法性能.mp4
│  │  [4183] 06  案例分析：缓冲区如何让代码加速.mp4
│  │  [4184] 07  案例分析：无处不在的缓存，高并发系统的法宝.mp4
│  │  [4185] 08  案例分析：Redi 如何助力秒杀业务.mp4
│  │  [4186] 09  案例分析：池化对象的应用场景.mp4
│  │  [4187] 10  案例分析：大对象复用的目标和注意点.mp4
│  │  [4188] 11  案例分析：如何用设计模式优化性能.mp4
│  │  [4189] 12  案例分析：并行计算让代码“飞”起来.mp4
│  │  [4190] 13  案例分析：多线程锁的优化.mp4
│  │  [4191] 14  案例分析：乐观锁和无锁.mp4
│  │  [4192] 15  案例分析：从 BIO 到 NIO，再到 AIO.mp4
│  │  [4193] 16  案例分析：常见 Java 代码优化法则.mp4
│  │  [4194] 17  高级进阶：JVM 如何完成垃圾回收？.mp4
│  │  [4195] 18  高级进阶：JIT 如何影响 JVM 的性能？.mp4
│  │  [4196] 19  高级进阶：JVM 常见优化参数.mp4
│  │  [4197] 20  SpringBoot 服务性能优化.mp4
│  │  [4198] 21  性能优化的过程方法与求职面经总结.mp4
│  │  [4199] 结束语   实践出真知.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：Java 源码剖析 34 讲
│  │  [1760] 开篇词：大厂技术面试“潜规则”.mp4
│  │  [1761] 第01讲：String 的特点是什么？它有哪些重要的方法？.mp4
│  │  [1762] 第02讲：HahMap 底层实现原理是什么？JDK8 做了哪些优化？.mp4
│  │  [1763] 第03讲：线程的状态有哪些？它是如何工作的？.mp4
│  │  [1764] 第04讲：详解 ThreadPoolExecutor 的参数含义及源码执行流程？.mp4
│  │  [1765] 第05讲：ynchronized 和 ReentrantLock 的实现原理是什么？它们有什么区别？.mp4
│  │  [1766] 第06讲：谈谈你对锁的理解？如何手动模拟一个死锁？.mp4
│  │  [1767] 第07讲：深克隆和浅克隆有什么区别？它的实现方式有哪些？.mp4
│  │  [1768] 第08讲：动态代理是如何实现的？JDK Proxy 和 CGLib 有什么区别？.mp4
│  │  [1769] 第09讲：如何实现本地缓存和分布式缓存？.mp4
│  │  [1770] 第10讲：如何手写一个消息队列和延迟消息队列？.mp4
│  │  [1771] 第11讲：底层源码分析 Spring 的核心功能和执行流程？（上）.mp4
│  │  [1772] 第12讲：底层源码分析 Spring 的核心功能和执行流程？（下）.mp4
│  │  [1773] 第13讲：MyBati 使用了哪些设计模式？在源码中是如何体现的？.mp4
│  │  [1774] 第14讲：SpringBoot 有哪些优点？它和 Spring 有什么区别？.mp4
│  │  [1775] 第15讲：MQ 有什么作用？你都用过哪些 MQ 中间件？.mp4
│  │  [1776] 第16讲：MySQL 的运行机制是什么？它有哪些引擎？.mp4
│  │  [1777] 第17讲：MySQL 的优化方案有哪些？.mp4
│  │  [1778] 第18讲：关系型数据和文档型数据库有什么区别？.mp4
│  │  [1779] 第19讲：Redi 的过期策略和内存淘汰机制有什么区别？.mp4
│  │  [1780] 第20讲：Redi 怎样实现的分布式锁？.mp4
│  │  [1781] 第21讲：Redi 中如何实现的消息队列？实现的方式有几种？.mp4
│  │  [1782] 第22讲：Redi 是如何实现高可用的？.mp4
│  │  [1783] 第23讲：说一下 JVM 的内存布局和运行原理？.mp4
│  │  [1784] 第24讲：垃圾回收算法有哪些？.mp4
│  │  [1785] 第25讲：你用过哪些垃圾回收器？它们有什么区别？.mp4
│  │  [1786] 第26讲：生产环境如何排除和优化 JVM？.mp4
│  │  [1787] 第27讲：单例的实现方式有几种？它们有什么优缺点？.mp4
│  │  [1788] 第28讲：你知道哪些设计模式？分别对应的应用场景有哪些？.mp4
│  │  [1789] 第29讲：红黑树和平衡二叉树有什么区别？.mp4
│  │  [1790] 第30讲：你知道哪些算法？讲一下它的内部实现过程？.mp4
│  │  [1791] 第31讲：如何保证接口的幂等性？常见的实现方案有哪些？.mp4
│  │  [1792] 第32讲：TCP 为什么需要三次握手？.mp4
│  │  [1793] 第33讲：Nginx 的负载均衡模式有哪些？它的实现原理是什么？.mp4
│  │  [1794] 第34讲：Docker 有什么优点？使用时需要注意什么问题？.mp4
│  │  [1795] 彩蛋：如何提高面试成功率？.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：JavaScript 核心原理精讲
│  │  [6173] 开篇词  打好 JS 基石，走稳前端进阶之路.mp4
│  │  [6174] 01  代码基本功测试（上）：JS 的数据类型你了解多少？.mp4
│  │  [6175] 02  代码基本功测试（下）：如何实现一个深浅拷贝？.mp4
│  │  [6176] 03  继承实现：探究 JS 常见的 6 种继承方式.mp4
│  │  [6177] 04  继承进阶：如何实现 new、apply、call、bind 的底层逻辑？.mp4
│  │  [6178] 05  函数那些事：JS 闭包难点剖析.mp4
│  │  [6179] 06  进阶练习：带你一起实现 JSON.Stringify 方法.mp4
│  │  [6180] 07  数组原理（上）：帮你梳理眼花缭乱的数组 API.mp4
│  │  [6181] 08  数组原理（中）：如何理解 JS 的类数组？.mp4
│  │  [6182] 09  数组原理（下）：实现数组扁平化的 6 种方式.mp4
│  │  [6183] 10  数组排序（上）：如何用 JS 实现各种数组排序？.mp4
│  │  [6184] 11  数组排序（下）：ort 排序方法的实现原理.mp4
│  │  [6185] 12  进阶练习：带你手写 JS 数组多个方法的底层实现.mp4
│  │  [6186] 13  异步编程（上）：JS 异步编程都有哪些方案？.mp4
│  │  [6187] 14  异步编程（中）：如何深入理解异步编程的核心 Promie？.mp4
│  │  [6188] 15  异步编程（下）：如何理解 Generator、Ayncawait 等异步编程的语法糖？.mp4
│  │  [6189] 16  进阶练习（上）：怎样轻松实现一个 EventEmitter？.mp4
│  │  [6190] 17  进阶练习（下）：如何实现符合 PromieA+ 规范的 Promie？.mp4
│  │  [6191] 18  垃圾回收：释放内存，提升浏览器页面性能.mp4
│  │  [6192] 19  事件轮询：如何理解浏览器中的 EventLoop？.mp4
│  │  [6193] 20  原理解析：JS 代码是如何被浏览器引擎编译、执行的？.mp4
│  │  [6194] 21  引擎进阶（上）：探究宏任务 & 微任务的运行机制.mp4
│  │  [6195] 22  引擎进阶（下）：如何理解 Proce.nextTick 的原理？.mp4
│  │  [6196] 彩蛋 1  如何应对大厂面试官的灵魂拷问？.mp4
│  │  [6197] 彩蛋 2  前端开发如何有针对性地学习算法？.mp4
│  │  [6198] 结束语  面向未来，我们该如何提升自己？.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：Kubernetes 原理剖析与实战应用
│  │  [4517] 开篇词  如何深入掌握 Kubernete？.mp4
│  │  [4518] 01  前世今生：Kubernete 是如何火起来的？.mp4
│  │  [4519] 02  高屋建瓴：Kubernete 的架构为什么是这样的？.mp4
│  │  [4520] 03  集群搭建：手把手教你玩转 Kubernete 集群搭建.mp4
│  │  [4521] 04  核心定义：Kubernete 是如何搞定“不可变基础设施”的？.mp4
│  │  [4522] 05  K8 Pod：最小调度单元的使用进阶及实践.mp4
│  │  [4523] 06  无状态应用：剖析 Kubernete 业务副本及水平扩展底层原理.mp4
│  │  [4524] 07  有状态应用：Kubernete 如何通过 StatefulSet 支持有状态应用？.mp4
│  │  [4525] 08  配置管理：Kubernete 管理业务配置方式有哪些？.mp4
│  │  [4526] 09  存储类型：如何挑选合适的存储插件？.mp4
│  │  [4527] 10  存储管理：怎样对业务数据进行持久化存储？.mp4
│  │  [4528] 11  K8 Service：轻松搞定服务发现和负载均衡.mp4
│  │  [4529] 12  Helm Chart：如何在生产环境中释放部署生产力？.mp4
│  │  [4530] 13  服务守护进程：如何在 Kubernete 中运行 DaemonSet 守护进程？.mp4
│  │  [4531] 14  日志采集：如何在 Kubernete 中做日志收集与管理？.mp4
│  │  [4532] 15  Prometheu：Kubernete 怎样实现自动化服务监控告警？.mp4
│  │  [4533] 16  迎战流量峰值：Kubernete 怎样控制业务的资源水位？.mp4
│  │  [4534] 17  案例实战：教你快速搭建 Kubernete 监控平台.mp4
│  │  [4535] 18  权限分析：Kubernete 集群权限管理那些事儿.mp4
│  │  [4536] 19  资源限制：如何保障你的 Kubernete 集群资源不会被打爆.mp4
│  │  [4537] 20  资源优化：Kubernete 中有 GC（垃圾回收）吗？.mp4
│  │  [4538] 21  优先级调度：你必须掌握的 Pod 抢占式资源调度.mp4
│  │  [4539] 22  安全机制：Kubernete 如何保障集群安全？.mp4
│  │  [4540] 23  最后的防线：怎样对 Kubernete 集群进行灾备和恢复？.mp4
│  │  [4541] 24  调度引擎：Kubernete 如何高效调度 Pod？.mp4
│  │  [4542] 25  稳定基石：带你剖析容器运行时以及 CRI 原理.mp4
│  │  [4543] 26  网络插件：Kubernete 搞定网络原来可以如此简单？.mp4
│  │  [4544] 27  K8 CRD：如何根据需求自定义你的 API？.mp4
│  │  [4545] 28  面向 K8 编程：如何通过 Operator 扩展 Kubernete  API？.mp4
│  │  [4546] 29  Kubernete 中也有定时任务吗？.mp4
│  │  [4547] 30  Kubectl 命令行工具使用秘笈.mp4
│  │  [4548] 结束语  Cloud Native i Eating the World：时代在召唤云原生.mp4
│  │  [5343] 加餐：问题答疑和优秀留言展示.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：Netty 核心原理剖析与 RPC 实践
│  │  [4913] 开篇词  学好 Netty，是你修炼 Java 内功的必经之路.mp4
│  │  [4914] 01  初识 Netty：为什么 Netty 这么流行？.mp4
│  │  [4915] 02  纵览全局：把握 Netty 整体架构脉络.mp4
│  │  [4916] 03  引导器作用：客户端和服务端启动都要做些什么？.mp4
│  │  [4917] 04  事件调度层：为什么 EventLoop 是 Netty 的精髓？.mp4
│  │  [4918] 05  服务编排层：Pipeline 如何协调各类 Handler ？.mp4
│  │  [4919] 06  粘包拆包问题：如何获取一个完整的网络包？.mp4
│  │  [4920] 07  接头暗语：如何利用 Netty 实现自定义协议通信？.mp4
│  │  [4921] 08  开箱即用：Netty 支持哪些常用的解码器？.mp4
│  │  [4922] 09  数据传输：writeAndFluh 处理流程剖析.mp4
│  │  [4923] 10  双刃剑：合理管理 Netty 堆外内存.mp4
│  │  [4924] 11  另起炉灶：Netty 数据传输载体 ByteBuf 详解.mp4
│  │  [4925] 12  他山之石：高性能内存分配器 jemalloc 基本原理.mp4
│  │  [4926] 13  举一反三：Netty 高性能内存管理设计（上）.mp4
│  │  [4927] 14  举一反三：Netty 高性能内存管理设计（下）.mp4
│  │  [4928] 15  轻量级对象回收站：Recycler 对象池技术解析.mp4
│  │  [4929] 16  IO 加速：与众不同的 Netty 零拷贝技术.mp4
│  │  [4930] 18  源码篇：解密 Netty Reactor 线程模型.mp4
│  │  [4931] 17  源码篇：从 Linux 出发深入剖析服务端启动流程.mp4
│  │  [4932] 19  源码篇：一个网络请求在 Netty 中的旅程.mp4
│  │  [4933] 20  技巧篇：Netty 的 FatThreadLocal 究竟比 ThreadLocal 快在哪儿？.mp4
│  │  [4934] 21  技巧篇：延迟任务处理神器之时间轮 HahedWheelTimer.mp4
│  │  [4935] 22  技巧篇：高性能无锁队列 Mpc Queue.mp4
│  │  [4936] 23  架构设计：如何实现一个高性能分布式 RPC 框架.mp4
│  │  [4937] 24  服务发布与订阅：搭建生产者和消费者的基础框架.mp4
│  │  [4938] 25  远程通信：通信协议设计以及编解码的实现.mp4
│  │  [4939] 26  服务治理：服务发现与负载均衡机制的实现.mp4
│  │  [4940] 27  动态代理：为用户屏蔽 RPC 调用的底层细节.mp4
│  │  [4941] 28  实战总结：RPC 实战总结与进阶延伸.mp4
│  │  [4942] 29  编程思想：Netty 中应用了哪些设计模式？.mp4
│  │  [4943] 30  实践总结：Netty 在项目开发中的一些最佳实践.mp4
│  │  [4944] 结束语  技术成长之路：如何打造自己的技术体系.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：Node.js 应用开发实战
│  │  [6781] 开篇词  Node.j 从工程化工具到后端服务应用的转变.mp4
│  │  [6782] 课前导读  Node.j 在前端工程化和后端服务应用的区别.mp4
│  │  [6783] 01  事件循环：高性能到底是如何做到的？.mp4
│  │  [6784] 02  应用场景：Node.j 作为后台可以提供哪些服务？.mp4
│  │  [6785] 03  如何构建一个简单的 RESTful 服务？.mp4
│  │  [6786] 04  3 大主流系统框架：由浅入深分析 Expre、Koa 和 Egg.j.mp4
│  │  [6787] 05  多进程解决方案：cluter 模式以及 PM2 工具的原理介绍.mp4
│  │  [6788] 06  哪些因素会影响 Node.j 性能？.mp4
│  │  [6789] 07  CPU 过载保护设计：如何在服务层面确保系统稳定？.mp4
│  │  [6790] 08  优化设计：在 IO 方面应该注意哪些要点？.mp4
│  │  [6791] 09  缓存与应用：多级缓存策略介绍与应用要点.mp4
│  │  [6792] 10  系统稳定：如何监控和保护进程安全？.mp4
│  │  [6793] 11  内存检查：多种类型的内存泄漏分析方案.mp4
│  │  [6794] 12  性能分析：性能影响的关键路径以及优化策略.mp4
│  │  [6795] 13  网络安全：常见网络攻击以及防护策略.mp4
│  │  [6796] 14  工具应用：使用 clinicj 工具实现通用性安全检查.mp4
│  │  [6797] 15  理论先行：高并发设计必须学的知识点有哪些？.mp4
│  │  [6798] 16  RESTful 应用实践：构建一个介于前后台之间的服务.mp4
│  │  [6799] 17  系统的实践设计（上）：完成一个通用抢票系统.mp4
│  │  [6800] 18  系统的实践设计（下）：完成一个通用投票系统.mp4
│  │  [6801] 19  Serverle 的实践：进一步提升系统的稳定性.mp4
│  │  [6802] 结束语  如何规划自己的 Node.j 学习之路？.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：OKR：组织敏捷目标和绩效管理
│  │  [5025] 开篇词  OKR 工作法：组织目标管理的神器.mp4
│  │  [5026] 01  目标管理发展：OKR 之前，大家都在用什么管理组织目标？.mp4
│  │  [5027] 02  OKR 价值：为什么互联网公司都在用 OKR？.mp4
│  │  [5028] 03  OKR 与战略：OKR 如何解决组织增长问题？.mp4
│  │  [5029] 04  OKR 生成：各层级的 OKR 要遵循什么规律？.mp4
│  │  [5030] 05  O：什么样的 O 得领导赏识？.mp4
│  │  [5031] 06  KR ：写好 KR 的万能公式.mp4
│  │  [5032] 07  案例实战：教你写出高质量的 OKR.mp4
│  │  [5033] 08  流程：你应该这样制定、管理 OKR!.mp4
│  │  [5034] 09  OKR 与 KPI 的区别和联系.mp4
│  │  [5035] 10  激励：如何用 OKR 激活你的团队？.mp4
│  │  [5036] 11  文化：OKR 文化的塑造和沉淀.mp4
│  │  [5037] 12  变革：OKR 转型难点及解决方案.mp4
│  │  [5038] 加餐  OKR 填写模板及案例.mp4
│  │  [5039] 结束语  OKR 工作法：制胜互联网下半场.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：ShardingSphere 核心原理精讲
│  │  [3559] 开篇词：如何正确学习一款分库分表开源框架？.mp4
│  │  [3560] 01  从理论到实践：如何让分库分表真正落地？.mp4
│  │  [3561] 02  顶级项目：ShardingSphere 是一款什么样的 Apache 开源软件？.mp4
│  │  [3562] 03  规范兼容：JDBC 规范与 ShardingSphere 是什么关系？.mp4
│  │  [3563] 04  应用集成：在业务系统中使用 ShardingSphere 的方式有哪些？.mp4
│  │  [3564] 05  配置驱动：ShardingSphere 中的配置体系是如何设计的？.mp4
│  │  [3565] 06  数据分片：如何实现分库、分表、分库+分表以及强制路由？（上）.mp4
│  │  [3566] 07  数据分片：如何实现分库、分表、分库+分表以及强制路由？（下）.mp4
│  │  [3567] 08  读写分离：如何集成分库分表+数据库主从架构？.mp4
│  │  [3568] 09  分布式事务：如何使用强一致性事务与柔性事务？.mp4
│  │  [3569] 10  数据脱敏：如何确保敏感数据的安全访问？.mp4
│  │  [3570] 11  编排治理：如何实现分布式环境下的动态配置管理？.mp4
│  │  [3571] 12  从应用到原理：如何高效阅读 ShardingSphere 源码？.mp4
│  │  [3572] 13  微内核架构：ShardingSphere 如何实现系统的扩展性？.mp4
│  │  [3573] 14  分布式主键：ShardingSphere 中有哪些分布式主键实现方式？.mp4
│  │  [3574] 15  解析引擎：SQL 解析流程应该包括哪些核心阶段？（上）.mp4
│  │  [3575] 16  解析引擎：SQL 解析流程应该包括哪些核心阶段？（下）.mp4
│  │  [3576] 17  路由引擎：如何理解分片路由核心类 ShardingRouter 的运作机制？.mp4
│  │  [3577] 18  路由引擎：如何实现数据访问的分片路由和广播路由？.mp4
│  │  [3578] 19  路由引擎：如何在路由过程中集成多种路由策略和路由算法？.mp4
│  │  [3579] 20  改写引擎：如何理解装饰器模式下的 SQL 改写实现机制？.mp4
│  │  [3580] 21  执行引擎：分片环境下 SQL 执行的整体流程应该如何进行抽象？.mp4
│  │  [3581] 22  执行引擎：如何把握 ShardingSphere 中的 Executor 执行模型？（上）.mp4
│  │  [3582] 23  执行引擎：如何把握 ShardingSphere 中的 Executor 执行模型？（下）.mp4
│  │  [3583] 24  归并引擎：如何理解数据归并的类型以及简单归并策略的实现过程？.mp4
│  │  [3584] 25  归并引擎：如何理解流式归并和内存归并在复杂归并场景下的应用方式？.mp4
│  │  [3585] 26  读写分离：普通主从架构和分片主从架构分别是如何实现的？.mp4
│  │  [3586] 27  分布式事务：如何理解 ShardingSphere 中对分布式事务的抽象过程？.mp4
│  │  [3587] 28  分布式事务：ShardingSphere 中如何集成强一致性事务和柔性事务支持？（上）.mp4
│  │  [3588] 29  分布式事务：ShardingSphere 中如何集成强一致性事务和柔性事务支持？（下）.mp4
│  │  [3589] 30  数据脱敏：如何基于改写引擎实现低侵入性数据脱敏方案？.mp4
│  │  [3590] 31  配置中心：如何基于配置中心实现配置信息的动态化管理？.mp4
│  │  [3591] 32  注册中心：如何基于注册中心实现数据库访问熔断机制？.mp4
│  │  [3592] 33  链路跟踪：如何基于 Hook 机制以及 OpenTracing 协议实现数据访问链路跟踪？.mp4
│  │  [3593] 34  系统集成：如何完成 ShardingSphere 内核与 Spring+SpringBoot 的无缝整合？.mp4
│  │  [3594] 结语：ShardingSphere 总结及展望.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：Spring Boot 实战开发
│  │  [5715] 开篇词  从零开始：为什么要学习 Spring Boot？.mp4
│  │  [5716] 01  家族生态：如何正确理解 Spring 家族的技术体系？.mp4
│  │  [5717] 02  案例驱动：如何剖析一个 Spring Web 应用程序？.mp4
│  │  [5718] 03  多维配置：如何使用 Spring Boot 中的配置体系？.mp4
│  │  [5719] 04  定制配置：如何创建和管理自定义的配置信息？.mp4
│  │  [5720] 05  自动配置：如何正确理解 Spring Boot 自动配置实现原理？.mp4
│  │  [5721] 06  基础规范：如何理解 JDBC 关系型数据库访问规范？.mp4
│  │  [5722] 07  数据访问：如何使用 JdbcTemplate 访问关系型数据库？.mp4
│  │  [5723] 08  数据访问：如何剖析 JdbcTemplate 数据访问实现原理？.mp4
│  │  [5724] 09  数据抽象：Spring Data 如何对数据访问过程进行统一抽象？.mp4
│  │  [5725] 10  ORM 集成：如何使用 Spring Data JPA 访问关系型数据库？.mp4
│  │  [5726] 11  服务发布：如何构建一个 RESTful 风格的 Web 服务？.mp4
│  │  [5727] 12  服务调用：如何使用 RetTemplate 消费 RESTful 服务？.mp4
│  │  [5728] 13  服务调用：如何正确理解 RetTemplate 远程调用实现原理？.mp4
│  │  [5729] 14  消息驱动：如何使用 KafkaTemplate 集成 Kafka？.mp4
│  │  [5730] 15  消息驱动：如何使用 JmTemplate 集成 ActiveMQ？.mp4
│  │  [5731] 16  消息驱动：如何使用 RabbitTemplate 集成 RabbitMQ？.mp4
│  │  [5732] 17  安全架构：如何理解 Spring 安全体系的整体架构？.mp4
│  │  [5733] 18  用户认证：如何基于 Spring Security 构建用户认证体系？.mp4
│  │  [5734] 19  服务授权：如何基于 Spring Security 确保请求安全访问？.mp4
│  │  [5735] 20  服务监控：如何使用 Actuator 组件实现系统监控？.mp4
│  │  [5736] 21  指标定制：如何实现自定义度量指标和 Actuator 端点？.mp4
│  │  [5737] 22  运行管理：如何使用 Admin Server 管理 Spring 应用程序？.mp4
│  │  [5738] 23  数据测试：如何使用 Spring 测试数据访问层组件？.mp4
│  │  [5739] 24  服务测试：如何使用 Spring 测试 Web 服务层组件？.mp4
│  │  [5740] 结束语  以终为始：Spring Boot 总结和展望.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：Spring Cloud 原理与实战
│  │  [4745] 开篇词  为什么你要学习微服务架构？.mp4
│  │  [4746] 01  追本溯源：究竟什么样的架构才是微服务架构？.mp4
│  │  [4747] 02  顶级框架：Spring Cloud 是一款什么样的微服务开发框架？.mp4
│  │  [4748] 03  案例驱动：如何通过实战案例来学习 Spring Cloud 框架？.mp4
│  │  [4749] 04  服务治理：如何正确理解服务治理解决方案？.mp4
│  │  [4750] 05  服务注册：如何构建 Eureka 服务器并理解其实现原理？.mp4
│  │  [4751] 06  服务发现：如何使用 Eureka 客户端并理解其实现原理？.mp4
│  │  [4752] 07  负载均衡：如何使用 Ribbon 实现客户端负载均衡？.mp4
│  │  [4753] 08  负载均衡：如何理解 Ribbon 的基本架构和实现原理？.mp4
│  │  [4754] 09  同步网关：如何基于 Zuul 构建 API 网关？.mp4
│  │  [4755] 10  同步网关：如何剖析 Zuul 网关的工作原理？.mp4
│  │  [4756] 11  异步网关：如何基于 Spring Cloud Gateway 构建 API 网关？.mp4
│  │  [4757] 12  服务容错：如何理解服务消费者容错思想和模式？.mp4
│  │  [4758] 13  熔断之器：如何使用 Spring Cloud Circuit Breaker 实现服务容错？（上）.mp4
│  │  [4759] 14  熔断之器：如何使用 Spring Cloud Circuit Breaker 实现服务容错？（下）.mp4
│  │  [4760] 15  熔断原理：如何正确理解 HytrixCircuitBreaker 的底层实现机制？.mp4
│  │  [4761] 16  配置方案：如何设计分布式环境下的配置中心解决方案？.mp4
│  │  [4762] 17  配置服务：如何基于Spring Cloud Config 构建配置中心服务器？.mp4
│  │  [4763] 18  配置集成：如何访问配置中心中的配置信息？.mp4
│  │  [4764] 19  配置更新：如何理解配置信息自动更新的工作原理？.mp4
│  │  [4765] 20  消息驱动：如何理解 Spring 中对消息处理机制的抽象过程？.mp4
│  │  [4766] 21  消息架构：如何把握 Spring Cloud Stream 的基本架构？.mp4
│  │  [4767] 22  消息发布：如何使用 Spring Cloud Stream 实现消息发布者和消费者？（上）.mp4
│  │  [4768] 23  消息消费：如何使用 Spring Cloud Stream 实现消息发布者和消费者？（下）.mp4
│  │  [4769] 24  消息集成：如何剖析 Spring Cloud Stream 集成消息中间件的实现原理？.mp4
│  │  [4770] 25  服务安全：如何理解微服务访问的安全需求和实现方案？.mp4
│  │  [4771] 26  服务授权：如何基于 Spring Cloud Security 集成 OAuth2 协议？.mp4
│  │  [4772] 27  服务授权：如何使用 OAuth2 协议实现对服务访问进行授权？.mp4
│  │  [4773] 28  服务认证：如何使用 JWT 实现定制化 Token？.mp4
│  │  [4774] 29  监控原理：如何理解服务监控和 Spring Cloud Sleuth 的基本原理？.mp4
│  │  [4775] 30  监控可视：如何整合 Spring Cloud Sleuth 与 Zipkin 实现可视化监控？.mp4
│  │  [4776] 31  监控扩展：如何使用 Tracer 在访问链路中创建自定义的 Span？.mp4
│  │  [4777] 32  测试方案：如何正确理解针对微服务的测试解决方案？.mp4
│  │  [4778] 33  组件测试：如何使用 Mock 和注解实施组件级别测试？.mp4
│  │  [4779] 34  契约测试：如何基于 Spring Cloud Contract 实现面向契约测试？.mp4
│  │  [4780] 总结  以终为始：微服务架构总结和展望.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：Spring Data JPA 原理与实战
│  │  [4700] 开篇词  勇敢走出舒适区，突破自己的技术瓶颈.mp4
│  │  [4701] 01  Spring Data JPA 初识.mp4
│  │  [4702] 02  Spring Data Common 之 Repoitory 如何全面掌握？.mp4
│  │  [4703] 03  Defining Query Method 的命名语法与参数.mp4
│  │  [4704] 04  如何利用 Repoitory 中的方法返回值解决实际问题？.mp4
│  │  [4705] 05  @Query 解决了什么问题？什么时候应该选择它？.mp4
│  │  [4706] 06  @Entity 里面的 JPA 注解有哪些？在 Java 多态场景下如何使用？.mp4
│  │  [4707] 07  @Entity 之间的关联关系注解如何正确使用？.mp4
│  │  [4708] 08  Jackon 注解在实体里面如何应用？常见的死循环问题如何解决？.mp4
│  │  [4709] 09  JpaSpecificationExecutor 解决了哪些问题？.mp4
│  │  [4710] 10  JpaSpecificationExecutor 实现的原理是什么？.mp4
│  │  [4711] 11  JpaRepoitory 如何自定义？.mp4
│  │  [4712] 12  JPA 的审计功能解决了哪些问题？.mp4
│  │  [4713] 13  如何正确使用 @Entity 里面的回调方法？.mp4
│  │  [4714] 14  乐观锁机制和重试机制在实战中应该怎么用.mp4
│  │  [4715] 15  JPA 对 Web MVC 开发者做了哪些支持.mp4
│  │  [4716] 16  如何自定义 HandlerMethodArgumentReolver？.mp4
│  │  [4717] 17  DataSource 为何物？加载过程是怎样的？.mp4
│  │  [4718] 18  生产环境多数据源的处理方法有哪些？.mp4
│  │  [4719] 19  如何搞清楚事务、连接池的关系？正确配置是怎样的？.mp4
│  │  [4720] 20  Spring JPA 中的 Hibernate 加载过程与配置项是怎么回事？.mp4
│  │  [4721] 21  Peritence Context 所表达的核心概念是什么？.mp4
│  │  [4722] 22  Seion 的 open-in-view 对事务的影响是什么？.mp4
│  │  [4723] 23  如何在 CompletableFuture 异步线程中正确使用 JPA？.mp4
│  │  [4724] 24  为什么总会遇到 Lazy Exception？如何解决？.mp4
│  │  [4725] 25  经典的 N+1 SQL 问题如何正确解决？（上）.mp4
│  │  [4726] 27  SpEL 解决了哪些问题？.mp4
│  │  [4727] 28  Hibernate 一级缓存是什么？起什么作用？.mp4
│  │  [4728] 29  二级缓存的思考：Redi 与 JPA 如何结合？.mp4
│  │  [4729] 30  Spring Data Ret 是什么？和 JPA 是什么关系？.mp4
│  │  [4730] 31  如何利用单元测试和集成测试让你开发效率翻倍？.mp4
│  │  [4731] 32  Spring Data ElaticSearch 在 Spring Data 中的用法有哪些？.mp4
│  │  [4732] 结束语  师傅领进门，修行靠个人.mp4
│  │  [5893] 26  经典的 N+1 SQL 问题如何正确解决？（下）.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：Spring 响应式编程实战
│  │  [6982] 开篇词  响应式编程：紧跟技术趋势，提升系统弹性.mp4
│  │  [6984] 02  背压机制：响应式流为什么能够提高系统的弹性？.mp4
│  │  [6985] 03  场景应用：响应式编程能够应用于哪些具体场景？.mp4
│  │  [6986] 04  案例驱动：如何基于 Spring 框架来学习响应式编程？.mp4
│  │  [6987] 05  顶级框架：Spring 为什么选择 Reactor 作为响应式编程框架？.mp4
│  │  [6988] 06  流式操作：如何使用 Flux 和 Mono 高效构建响应式数据流？.mp4
│  │  [6989] 07  Reactor 操作符（上）：如何快速转换响应式流？.mp4
│  │  [6990] 08  Reactor 操作符（下）：如何多样化裁剪响应式流？.mp4
│  │  [6992] 10  WebFlux（上）：如何使用注解编程模式构建异步非阻塞服务？.mp4
│  │  [6993] 11  WebFlux（下）：如何使用函数式编程模型构建异步非阻塞服务？.mp4
│  │  [6994] 12  WebClient：如何实现非阻塞式的跨服务远程调用？.mp4
│  │  [6995] 13  RSocket：一种新的高性能网络通信协议.mp4
│  │  [6996] 14  响应式全栈：响应式编程能为数据访问过程带来什么样的变化？.mp4
│  │  [7000] 18  消息驱动：Spring Cloud Stream 如何为系统提升伸缩性？.mp4
│  │  [7002] 20  消息消费：如何选择可用的高级开发技巧？.mp4
│  │  [7004] 22  测试集成：响应式 Web 应用程序如何进行测试？.mp4
│  │  [7005] 结束语  以终为始：响应式编程是一种银弹吗？.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：SpringCloud Alibaba 实战
│  │  [6745] 开篇词  Spring Cloud Alibaba 未来的微服务生态标准.mp4
│  │  [6746] 01  一探究竟：从架构的演变看微服务化架构.mp4
│  │  [6747] 02  经验教训：微服务设计时的五条宝贵经验.mp4
│  │  [6748] 03  顶层设计：微服务生态与 Spring Cloud Alibaba.mp4
│  │  [6749] 04  服务治理：Naco 如何实现微服务服务治理.mp4
│  │  [6750] 05  高可用保证：Naco 如何有效构建注册中心集群.mp4
│  │  [6751] 06  负载均衡：Ribbon 如何保证微服务的高可用.mp4
│  │  [6752] 07  REST消息通信：如何使用 OpenFeign 简化服务间通信.mp4
│  │  [6753] 08  RPC 消息：Dubbo 与 Naco 体系如何协同作业.mp4
│  │  [6754] 09  服务门户：Spring Cloud Gateway 如何把好微服务的大门.mp4
│  │  [6755] 10  系统保护：微服务架构雪崩效应与服务限流.mp4
│  │  [6756] 11  限流与熔断：Sentinel 在项目中的最佳实践.mp4
│  │  [6757] 12  配置中心：基于 Naco 集中管理应用配置.mp4
│  │  [6758] 13  生产实践：Sentinel 进阶应用场景.mp4
│  │  [6759] 14  链路跟踪：基于 Sleuth+Zipkin 实施链路跟踪体系.mp4
│  │  [6760] 15  应用性能监控：通过 SkyWalking 实施链路追踪.mp4
│  │  [6761] 16 ?分布式事务：Alibaba Seata 如何实现分布式事务.mp4
│  │  [6762] 17 ?消息队列：基于 RocketMQ 实现服务异步通信.mp4
│  │  [6763] 18  综合应用：Seata 分布式事务实战教程.mp4
│  │  [6764] 19  性能为王：微服务架构中的多级缓存设计.mp4
│  │  [6765] 20  升级改造：老项目升级到微服务的重构策略.mp4
│  │  [6766] 21  统一门户：基于网关的统一用户认证方案.mp4
│  │  [6767] 22  一致性挑战：微服务架构下的数据一致性解决方案.mp4
│  │  [6768] 23  极速运维：微服务与 DevOp.mp4
│  │  [6769] 结束语  学无止境：下一代微服务架构的规划与展望.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：TypeScript 入门实战笔记
│  │  [7432] 开篇词  你为什么要选择 TypeScript？.mp4
│  │  [7433] 01  如何快速搭建 TypeScript 学习开发环境？.mp4
│  │  [7434] 02  简单基础类型：TypeScript 与 JavaScript 有何不同？.mp4
│  │  [7435] 03  复杂基础类型：TypeScript 与 JavaScript 有何不同？.mp4
│  │  [7436] 04  什么是字面量类型、类型推断、类型拓宽和类型缩小？.mp4
│  │  [7437] 05  函数类型：返回值类型和参数类型到底如何定义？.mp4
│  │  [7438] 06  类类型：如何高效使用类型化的面向对象编程利器？.mp4
│  │  [7439] 07  接口类型与类型别名：这两者的用法与区别分别是什么？.mp4
│  │  [7440] 08  高级类型：如何快速读懂联合类型和交叉类型的含义？.mp4
│  │  [7441] 09  枚举类型：详解常见枚举类型的 7 种用法.mp4
│  │  [7442] 10  泛型：如何正确使用泛型约束类型变量？.mp4
│  │  [7443] 11  类型守卫：如何有效地保障类型的安全性？.mp4
│  │  [7444] 12  类型兼容：如何判断一个类型是否可以赋值给其他类型？.mp4
│  │  [7445] 13  必备增强类型系统的方式大盘点，让你的开发如虎添翼.mp4
│  │  [7446] 14  掌握 TypeScript 这些官方工具类型，让你的开发事半功倍.mp4
│  │  [7447] 15  类型编程：如何打造属于自己的工具类型？.mp4
│  │  [7448] 16  tconfig.jon 配置：如何定制 TypeScript 的行为？.mp4
│  │  [7449] 17  来自 100 +项目经历的常见 TypeScript 错误汇总分析.mp4
│  │  [7450] 18  手把手教你使用 TypeScript 开发 Node.j 应用.mp4
│  │  [7451] 19  使用 TypeScript 开发 Web 应用的最佳实践.mp4
│  │  [7452] 20  如何将 JavaScript 应用切换至 TypeScript？.mp4
│  │  [7453] 结束语  TypeScript 的这些实用技能，你不得不知.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：Vue.js 3.0 核心源码内参
│  │  [7624] 开篇词  解析 Vue.j 源码，提升编码能力.mp4
│  │  [7625] 导读  一文看懂 Vue.j 3.0 的优化.mp4
│  │  [7626] 01  组件渲染：vnode 到真实 DOM 是如何转变的？.mp4
│  │  [7627] 02  组件更新：完整的 DOM diff 流程是怎样的？（上）.mp4
│  │  [7628] 03  组件更新：完整的 DOM diff 流程是怎样的？（下）.mp4
│  │  [7629] 模块一导读  组件的实现：直击 Vue 核心的实现.mp4
│  │  [7630] 04  Setup：组件渲染前的初始化过程是怎样的？.mp4
│  │  [7631] 05  响应式：响应式内部的实现原理是怎样的？（上）.mp4
│  │  [7632] 07  计算属性：计算属性比普通函数好在哪里？.mp4
│  │  [7633] 08  侦听器：侦听器的实现原理和使用场景是什么？（上）.mp4
│  │  [7634] 10  生命周期：各个生命周期的执行时机和应用场景是怎样的？.mp4
│  │  [7635] 11  依赖注入：子孙组件如何共享数据？.mp4
│  │  [7636] 模块二导读  逻辑复用最佳实践：Compoition API.mp4
│  │  [7637] 06  响应式：响应式内部的实现原理是怎样的？（下）.mp4
│  │  [7638] 09  侦听器：侦听器的实现原理和使用场景是什么？（下）.mp4
│  │  [7639] 12  模板解析：构造 AST 的完整流程是怎样的？（上）.mp4
│  │  [7640] 14  AST 转换：AST 节点内部做了哪些转换？（上）.mp4
│  │  [7641] 16  生成代码：AST 如何生成可运行的代码？（上）.mp4
│  │  [7642] 13  模板解析：构造 AST 的完整流程是怎样的？（下）.mp4
│  │  [7643] 15  AST 转换：AST 节点内部做了哪些转换？（下）.mp4
│  │  [7644] 17  生成代码：AST 如何生成可运行的代码？（下）.mp4
│  │  [7645] 模块三导读  编译和优化：了解编译过程和背后的优化思想.mp4
│  │  [7646] 18  Prop：Prop 的初始化和更新流程是怎样的？.mp4
│  │  [7647] 19  插槽：如何实现内容分发？.mp4
│  │  [7648] 20  指令：指令完整的生命周期是怎样的？.mp4
│  │  [7649] 21  v-model：双向绑定到底是怎么实现的？.mp4
│  │  [7650] 模块四导读  实用特性：探索更多实用特性背后的原理.mp4
│  │  [7651] 22  Teleport 组件：如何脱离当前组件渲染子组件？.mp4
│  │  [7652] 23  KeepAlive 组件：如何让组件在内存中缓存和调度？.mp4
│  │  [7653] 24  Tranition 组件：过渡动画的实现原理是怎样的？（上）.mp4
│  │  [7654] 模块五导读  内置组件：学习 Vue 内置组件的实现原理.mp4
│  │  [7655] 25  Tranition 组件：过渡动画的实现原理是怎样的？（下）.mp4
│  │  [7656] 特别放送导读  研究 Vue 官方生态的实现原理.mp4
│  │  [7657] 26  Vue Router：如何实现一个前端路由？（上）.mp4
│  │  [7658] 27   Vue Router：如何实现一个前端路由？（下）.mp4
│  │  [7659] 结束语  终点也是起点.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：Web 安全攻防之道
│  │  [5966] 开篇词  学习 Web 安全，防止你的网站被入侵.mp4
│  │  [5967] 课前导读  如何学习 Web 渗透技术.mp4
│  │  [5968] 01  武器库：常用的渗透测试工具.mp4
│  │  [5969] 02  信息收集：掌握目标的一切信息.mp4
│  │  [5970] 03  靶场：搭建漏洞练习环境.mp4
│  │  [5971] 加餐  法律法规：如何合法地进行渗透测试.mp4
│  │  [5972] 04  XSS：劫持身份的“惯犯”.mp4
│  │  [5973] 05  XSS：漏洞的检测与防御.mp4
│  │  [5974] 06  SQL 注入：小心数据库被拖走（上）.mp4
│  │  [5975] 07  SQL 注入：小心数据库被拖走（下）.mp4
│  │  [5976] 08  SQL 注入：漏洞的检测与防御.mp4
│  │  [5977] 09  CSRF 漏洞：谁改了我的密码？.mp4
│  │  [5978] 10  SSRF 漏洞：外网隔离就绝对安全了吗？.mp4
│  │  [5979] 11  XXE 漏洞：XML 解析器的坑.mp4
│  │  [5980] 12  反序列化漏洞：数据转换下的欺骗.mp4
│  │  [5981] 13  文件上传漏洞：种植服务器木马的捷径.mp4
│  │  [5982] 14  命令与代码注入：常令安全人员半夜应急的漏洞.mp4
│  │  [5983] 15  文件包含：不受限地引入文件可能导致网站被入侵.mp4
│  │  [5984] 16  逻辑漏洞：你的订单信息是如何泄露的？.mp4
│  │  [5985] 17  内网渗透：内网的员工电脑是怎么被外部黑掉的？.mp4
│  │  [5986] 18  构建防线：服务器安全加固.mp4
│  │  [5987] 19  入侵排查：阻断与追踪黑客.mp4
│  │  [5988] 20  研发安全：从 SDL 到 DevSecOp.mp4
│  │  [5989] 结束语   谈谈我的安全观.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：Webpack原理与实践
│  │  [2260] 开篇词：Webpack 现代化前端应用的基石.mp4
│  │  [2261] 第01讲：Webpack 究竟解决了什么问题？.mp4
│  │  [2262] 第02讲：如何使用 Webpack 实现模块化打包？.mp4
│  │  [2263] 第03讲：如何通过 Loader 实现特殊资源加载？.mp4
│  │  [2264] 第04讲：如何利用插件机制横向扩展 Webpack 的构建能力？.mp4
│  │  [2265] 第05讲：探索 Webpack 运行机制与核心工作原理.mp4
│  │  [2266] 第06讲：如何使用 Dev Server 提高你的本地开发效率？.mp4
│  │  [2267] 第07讲：如何配置 Webpack SourceMap 的最佳实践？.mp4
│  │  [2268] 第08讲：如何让你的模块支持热替换（HMR）机制？.mp4
│  │  [2269] 第09讲：玩转 Webpack 高级特性应对项目优化需求（上）.mp4
│  │  [2270] 第11讲：如何优化 Webpack 的构建速度和打包结果？.mp4
│  │  [2271] 第12讲：如何选择打包工具：Rollup 和 Webpack ？.mp4
│  │  [2272] 第13讲：如何使用 Parcel 零配置完成打包任务？.mp4
│  │  [2273] 结束彩蛋：资深前端工程师培养计划.mp4
│  │  [3129] 加餐：Vue.j 3.0 到底带来了哪些变化？.mp4
│  │  [3336] 第10讲：玩转 Webpack 高级特性应对项目优化需求（下）.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：ZooKeeper源码分析与实战
│  │  [3130] 开篇词：选择 ZooKeeper，一步到位掌握分布式开发.mp4
│  │  [3131] 第01讲：ZooKeeper 数据模型：节点的特性与应用.mp4
│  │  [3132] 第02讲：发布订阅模式：如何使用 Watch 机制实现分布式通知.mp4
│  │  [3133] 第03讲：ACL 权限控制：如何避免未经授权的访问？.mp4
│  │  [3134] 第04讲：ZooKeeper 如何进行序列化？.mp4
│  │  [3135] 第05讲：深入分析 Jute 的底层实现原理.mp4
│  │  [3136] 第06讲：ZooKeeper 的网络通信协议详解.mp4
│  │  [3137] 第07讲：单机模式：服务器如何从初始化到对外提供服务？.mp4
│  │  [3138] 第08讲：集群模式：服务器如何从初始化到对外提供服务？.mp4
│  │  [3139] 第09讲：创建会话：避开日常开发的那些“坑”.mp4
│  │  [3140] 第10讲：ClientCnxn：客户端核心工作类工作原理解析.mp4
│  │  [3141] 第11讲：分桶策略：如何实现高效的会话管理？.mp4
│  │  [3142] 第12讲：服务端是如何处理一次会话请求的？.mp4
│  │  [3143] 第13讲：Curator：如何降低 ZooKeeper 使用的复杂性？.mp4
│  │  [3144] 第14讲：Leader 选举：如何保证分布式数据的一致性？.mp4
│  │  [3145] 第15讲：ZooKeeper 究竟是怎么选中 Leader 的？.mp4
│  │  [3146] 第16讲：ZooKeeper 集群中 Leader 与 Follower 的数据同步策略.mp4
│  │  [3147] 第17讲：集群中 Leader 的作用：事务的请求处理与调度分析.mp4
│  │  [3148] 第18讲：集群中 Follow 的作用：非事务请求的处理与 Leader 的选举分析.mp4
│  │  [3149] 第19讲：Oberver 的作用与 Follow 有哪些不同？.mp4
│  │  [3150] 第20讲：一个运行中的 ZooKeeper 服务会产生哪些数据和文件？.mp4
│  │  [3151] 第21讲：ZooKeeper 分布式锁：实现和原理解析.mp4
│  │  [3152] 第22讲：基于 ZooKeeper 命名服务的应用：分布式 ID 生成器.mp4
│  │  [3153] 第23讲：使用 ZooKeeper 实现负载均衡服务器功能.mp4
│  │  [3154] 第24讲：ZooKeeper 在 Kafka 和 Dubbo 中的工业级实现案例分析.mp4
│  │  [3155] 第25讲：如何搭建一个高可用的 ZooKeeper 生产环境？.mp4
│  │  [3156] 第26讲：JConole 与四字母命令：如何监控服务器上 ZooKeeper 的运行状态？.mp4
│  │  [3157] 第27讲：crontab 与 PurgeTxnLog：线上系统日志清理的最佳时间和方式.mp4
│  │  [3158] 第28讲：彻底掌握二阶段提交三阶段提交算法原理.mp4
│  │  [3159] 第29讲：ZAB 协议算法：崩溃恢复和消息广播.mp4
│  │  [3160] 第30讲：ZAB 与 Paxo 算法的联系与区别.mp4
│  │  [3161] 第31讲：ZooKeeper 中二阶段提交算法的实现分析.mp4
│  │  [3162] 第32讲：ZooKeeper 数据存储底层实现解析.mp4
│  │  [4317] 结束语  分布技术发展与 ZooKeeper 应用前景.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：万能的数据分析法则
│  │  [5870] 开篇词  技能决定下限，思维决定上限.mp4
│  │  [5871] 01  目标导向：如何走出取数的怪圈？.mp4
│  │  [5872] 02  客观严谨：事实+论证过程+观点，打造高水准分析.mp4
│  │  [5873] 03  指标思维：如何搞清楚各种不同的指标类型.mp4
│  │  [5874] 04  逻辑推理：招聘要求里的逻辑思维能力到底指什么？.mp4
│  │  [5875] 05  系统结构：跳出问题看问题，让你的分析直击关键.mp4
│  │  [5876] 06  懂业务：让你的分析结果与业务方、领导同频.mp4
│  │  [5877] 07  懂用户：数据分析+用户思维=精细化运营.mp4
│  │  [5878] 08  分析流程：业务数据分析的通用流程.mp4
│  │  [5879] 09  定义问题：怎么定义问题，打通分析思路？.mp4
│  │  [5880] 10  拆解问题：为什么总是拆解出一堆没用的数据？.mp4
│  │  [5881] 11  找出原因：问题原因那么多，哪条才是最关键.mp4
│  │  [5882] 12  提出建议：什么才是有价值的建议？.mp4
│  │  [5883] 13  报告撰写：怎样高效地写一份数据分析报告？.mp4
│  │  [5884] 14  分析框架进阶：其他常见的分析流程（预测竞品用户数学建模）.mp4
│  │  [5885] 15  产品分析：如何将某功能的次日留存率提升 10%？.mp4
│  │  [5886] 16  转化分析：如何提升产品的购买转化率？.mp4
│  │  [5887] 17  活动分析：如何分析活动效果并给出有效建议？.mp4
│  │  [5888] 18  用户增长：找出快速提升用户数的关键行为.mp4
│  │  [5889] 19  AB 测试： AB 测试的效果评估和优化.mp4
│  │  [5890] 彩蛋1  数据运营：如何搭建数据运营体系？.mp4
│  │  [5891] 彩蛋2  面试：业务数据分析师的面试指南.mp4
│  │  [5892] 结束语   深入业务，持续学习.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：云原生微信小程序开发实战
│  │  [5092] 开篇词  自顶向下，云端赋能：小程序的高效开发之道.mp4
│  │  [5093] 课前导读  开发一个在线商城小程序，要学哪些知识？.mp4
│  │  [5094] 01  双线程模型：为什么小程序不用浏览器的线程模型？.mp4
│  │  [5095] 02  授权模型： 小程序的用户体系与 OAuth 规范.mp4
│  │  [5096] 03  自定义组件：怎么培养组件化思维？.mp4
│  │  [5097] 04  性能优化：借助微信开发者工具提升小程序性能.mp4
│  │  [5098] 05  研发加速：使用 Webpack 提升小程序研发效率.mp4
│  │  [5099] 06  自动化测试：提高小程序的交付质量.mp4
│  │  [5100] 07  数据监控：善用数据驱动产品迭代.mp4
│  │  [5101] 08  CICD：打造小程序的工程交付体系.mp4
│  │  [5102] 09  开放数据：微信生态帮助业务快速落地.mp4
│  │  [5103] 10  订阅消息：提高小程序用户留存.mp4
│  │  [5104] 11  数据预取：合理缓存提高用户体验.mp4
│  │  [5105] 12  渐进增强：小程序的更新策略.mp4
│  │  [5106] 13  云开发：云原生一体化应用开发平台.mp4
│  │  [5107] 14  复杂数据库设计：如何用好云开发提供的文档型数据库？.mp4
│  │  [5108] 15  KISS：怎么设计简单易用的云开发函数？.mp4
│  │  [5109] 16  内容加速：如何借助云存储实现无缝上云？.mp4
│  │  [5110] 17  日志监控：怎样面向业务设计日志方案？.mp4
│  │  [5111] 18  持续在线：如何借助云应用持续运行队列消费者？.mp4
│  │  [5112] 19  业务告警：怎样借助云开发业务告警进行业务监控？.mp4
│  │  [5113] 项目实战  基于云开发开发一个在线商城小程序.mp4
│  │  [5114] 结束语  以端为始，向云而生：云原生加速前端向全栈演进.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：云原生微服务架构实战精讲
│  │  [1804] 开篇词：实战是学习新技术的不二法门.mp4
│  │  [1805] 第01讲：什么是微服务架构.mp4
│  │  [1806] 第02讲：什么是 Docker 与容器化技术.mp4
│  │  [1807] 第03讲：云原生应用的 15 个特征.mp4
│  │  [1808] 第04讲：什么是 Kubernete 容器化应用.mp4
│  │  [1809] 第05讲：什么是服务网格（Service Meh）.mp4
│  │  [1810] 第06讲：示例应用介绍与用户场景分析.mp4
│  │  [1811] 第07讲：如何进行领域驱动设计.mp4
│  │  [1812] 第08讲：如何对示例应用进行微服务划分.mp4
│  │  [1813] 第09讲：快速部署开发环境与框架.mp4
│  │  [1814] 第10讲：使用 OpenAPI 和 Swagger 实现 API 优先设计.mp4
│  │  [1815] 第11讲：使用 Spring Data JPA 实现数据库驱动微服务.mp4
│  │  [1816] 第12讲：如何基于 JUnit 5 的服务实现单元测试.mp4
│  │  [1817] 第13讲：如何基于 REST 服务实现集成测试.mp4
│  │  [1818] 第14讲：事件如何驱动微服务设计与异步消息传递.mp4
│  │  [1819] 第15讲：什么是事务性消息模式.mp4
│  │  [1820] 第16讲：事件发布如何进行处理.mp4
│  │  [1821] 第17讲：如何设计与实现事件源（Event ourcing）.mp4
│  │  [1822] 第18讲：如何处理司机位置更新事件.mp4
│  │  [1823] 第19讲：如何实现行程派发与调度算法.mp4
│  │  [1824] 第20讲：什么是数据一致性与 Saga 模式.mp4
│  │  [1825] 第21讲：如何使用 Saga 模式实现行程验证.mp4
│  │  [1826] 第22讲：CQRS 如何设计与实现.mp4
│  │  [1827] 第23讲：如何查询乘客和司机的行程.mp4
│  │  [1828] 第24讲：服务调用失败的处理策略与实践.mp4
│  │  [1829] 第25讲：如何基于 Spring Security 和 JWT 实现访问控制.mp4
│  │  [1830] 第26讲：服务版本更新策略是什么.mp4
│  │  [1831] 第27讲：如何实现应用配置的外部化与管理.mp4
│  │  [1832] 第28讲：使用 Prometheu 和 Grafana 处理性能指标数据.mp4
│  │  [1833] 第29讲：使用 Fluentd、ElaticSearch 和 Kibana 管理日志.mp4
│  │  [1834] 第30讲：使用 Sentry 处理异常.mp4
│  │  [1835] 第31讲：如何设计与实现 API 组合.mp4
│  │  [1836] 第32讲：如何使用 Netflix Falcor 组合 API.mp4
│  │  [1837] 第33讲：如何使用 GraphQL 组合 API.mp4
│  │  [1838] 第34讲：如何安装与配置 Itio.mp4
│  │  [1839] 第35讲：使用 API 网关作为应用请求入口.mp4
│  │  [1840] 第36讲：什么是服务重试与熔断器.mp4
│  │  [1841] 第37讲：如何实现追踪服务性能指标.mp4
│  │  [1842] 第38讲：如何实现服务访问控制与双向 TLS.mp4
│  │  [1843] 第39讲：使用 Jenkin 进行持续集成.mp4
│  │  [1844] 第40讲：如何持续部署到阿里云.mp4
│  │  [1845] 第41讲：如何结合服务网格进行灰度发布.mp4
│  │  [1846] 第42讲：使用 Spring HATEOAS 增强 REST 服务的语义.mp4
│  │  [1847] 第43讲：使用 gRPC 作为服务之间的交互方式.mp4
│  │  [1848] 第44讲：使用 Quarku 开发微服务.mp4
│  │  [1849] 第45讲：消费者驱动的服务契约测试.mp4
│  │  [1850] 结束语：微服务架构展望.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：产品体验设计思维与实操
│      [4448] 开篇词  打造具有同理心的产品体验设计.mp4
│      [4449] 01  准则：如何设计符合产品类型的启动页？.mp4
│      [4450] 02  案例：搜狐产品改版，启动页要如何设计？.mp4
│      
├─拉勾：人人都能学会的数据分析
│  │  [5255] 开篇词  掌握数据分析能力，是你职场发展的分水岭！.mp4
│  │  [5256] 导读  如何从目标出发，探究数据分析的本质？.mp4
│  │  [5257] 01  如何定量描述数据状况与概率事件？.mp4
│  │  [5258] 02  未来事件如何用数据进行预测？.mp4
│  │  [5259] 03  资源投入怎么分配更合理？.mp4
│  │  [5260] 04  最好用的产品、商品、用户的分类方法你知道吗？.mp4
│  │  [5261] 05  帕累托模型：如何用 20% 的成本产生 80% 的利润？.mp4
│  │  [5262] 06  波士顿模型：如何合理分配 100 万的投放资金与资源？.mp4
│  │  [5263] 07  尿布与啤酒背后的原理，如何让客户加满购物篮？.mp4
│  │  [5264] 08  场景分析前提：如何梳理业务流程、建立指标体系？.mp4
│  │  [5265] 09  FineBI 实操：毛利率下滑诊断与分析.mp4
│  │  [5266] 10  业务异常剖析：用时间溯源法，追踪订单下降原因.mp4
│  │  [5267] 11  5W2H 法：如何利用 5W2H 模型挽救断崖式订单？.mp4
│  │  [5268] 12  用户画像实例：客户增长受阻，该如何分析用户行为？.mp4
│  │  [5269] 13  指标拆解案例：如何用数据思维解剖采销成本上升的本因？.mp4
│  │  [5270] 彩蛋  职业分析：数据分析岗位如何升职加薪？.mp4
│  │  [5271] 结束语  数据分析之路道阻且长，吾将上下求索！.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：从零开始学数据分析
│  │  [4789] 开篇词  避免踩坑 搭建数据分析师的核心竞争力.mp4
│  │  [4790] 01  入行必备：数据处理的十大技巧.mp4
│  │  [4791] 02  如虎添翼：开源 OLAP 工具如何助力数据分析.mp4
│  │  [4792] 03  离线利器：大数据离线处理工具 Hive 的常用技巧.mp4
│  │  [4793] 04  晋级之路：轻松掌握新星 Spark 的入门之道.mp4
│  │  [4794] 05  效率提升：如何通过邮件报表释放人力.mp4
│  │  [4795] 06  BI 平台：如何进行报表可视化开发.mp4
│  │  [4796] 07  实战演练：一小时搭建可视化 BI 数据平台.mp4
│  │  [4797] 08  数据平台：本机部署大数据平台工具及使用.mp4
│  │  [4798] 09  贯通业务：处理临时需求的正确姿势.mp4
│  │  [4799] 10  问题诊断：定位数据异常的快速方法.mp4
│  │  [4800] 11  精细运营：数据分析在用户运营中的运用.mp4
│  │  [4801] 12  产品迭代：巧用数据分析优化产品.mp4
│  │  [4802] 13  自我驱动：如何开展专题分析.mp4
│  │  [4803] 14  经典案例：如何搭建信息流产品数据分析指标体系.mp4
│  │  [4804] 15  黄金流量：如何完成首页入口资源位最大价值.mp4
│  │  [4805] 16  业务提升：数据策略如何驱动业务增长.mp4
│  │  [4806] 17  科学验证：快速入门 AB 实验设计和评估.mp4
│  │  [4807] 18  策略案例：抖音、快手策略推荐分析.mp4
│  │  [4808] 19  商业变现：流量的商业闭环分析.mp4
│  │  [4809] 20  效率广告：迅速了解互联网广告的核心指标.mp4
│  │  [4810] 21  价值预估：拆解互联网公司价值数据量化模型.mp4
│  │  [4811] 22  提高效率：数据分析师知识构成及管理.mp4
│  │  [4812] 23  简历优化：数据分析师简历要避免哪些问题.mp4
│  │  [4813] 24  最佳选择：巧妙选择公司及投递策略.mp4
│  │  [4814] 25  良好开端：新人入职第一周的工作清单.mp4
│  │  [4815] 结束语  数据化的未来值得我们为之奋斗.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：分布式技术原理与实战45讲
│  │  [1898] 开篇词：搭建分布式知识体系，挑战高薪 Offer.mp4
│  │  [1899] 第01讲：如何证明分布式系统的 CAP 理论？.mp4
│  │  [1900] 第02讲：不同数据一致性模型有哪些应用？.mp4
│  │  [1901] 第03讲：如何透彻理解 Paxo 算法？.mp4
│  │  [1902] 第04讲：ZooKeeper 如何保证数据一致性？.mp4
│  │  [1903] 第05讲：共识问题：区块链如何确认记账权？.mp4
│  │  [1904] 加餐1：如何准备一线互联网公司面试？.mp4
│  │  [1905] 第06讲：分布式事务有哪些解决方案？.mp4
│  │  [1906] 第07讲：对比两阶段提交，三阶段协议有哪些改进？.mp4
│  │  [1907] 第08讲：MySQL 数据库如何实现 XA 规范？.mp4
│  │  [1908] 第09讲：如何在业务中体现 TCC 事务模型？.mp4
│  │  [1909] 第10讲：分布式锁有哪些应用场景和实现？.mp4
│  │  [1910] 第11讲：如何使用 Redi 快速实现分布式锁？.mp4
│  │  [1911] 加餐2：分布式事务考点梳理 + 高频面试题.mp4
│  │  [1912] 第12讲：如何理解 RPC 远程服务调用？.mp4
│  │  [1913] 第13讲：为什么微服务需要 API 网关？.mp4
│  │  [1914] 第14讲：如何实现服务注册与发现？.mp4
│  │  [1915] 第15讲：如何实现分布式调用跟踪？.mp4
│  │  [1916] 第16讲：分布式下如何实现配置管理？.mp4
│  │  [1917] 第17讲：容器化升级对服务有哪些影响？.mp4
│  │  [1918] 第18讲：ServiceMeh：服务网格有哪些应用？.mp4
│  │  [1919] 第19讲：Dubbo v Spring Cloud：两大技术栈如何选型？.mp4
│  │  [1920] 加餐3：分布式服务考点梳理 + 高频面试题.mp4
│  │  [1921] 第20讲：读写分离如何在业务中落地？.mp4
│  │  [1922] 第21讲：为什么需要分库分表，如何实现？.mp4
│  │  [1923] 第22讲：存储拆分后，如何解决唯一主键问题？.mp4
│  │  [1924] 第23讲：分库分表以后，如何实现扩容？.mp4
│  │  [1925] 第24讲：NoSQL 数据库有哪些典型应用？.mp4
│  │  [1926] 第25讲：ElaticSearch 是如何建立索引的？.mp4
│  │  [1927] 加餐4：分布式存储考点梳理 + 高频面试题.mp4
│  │  [1928] 第26讲：消息队列有哪些应用场景？.mp4
│  │  [1929] 第27讲：集群消费和广播消费有什么区别？.mp4
│  │  [1930] 第28讲：业务上需要顺序消费，怎么保证时序性？.mp4
│  │  [1931] 第29讲：消息幂等：如何保证消息不被重复消费？.mp4
│  │  [1932] 第30讲：高可用：如何实现消息队列的 HA？.mp4
│  │  [1933] 第31讲：消息队列选型：Kafka 如何实现高性能？.mp4
│  │  [1934] 第32讲：消息队列选型：RocketMQ 适用哪些场景？.mp4
│  │  [1935] 加餐5：消息队列考点梳理 + 高频面试题.mp4
│  │  [1936] 第33讲：不止业务缓存，分布式系统中还有哪些缓存？.mp4
│  │  [1937] 第34讲：如何避免缓存穿透、缓存击穿、缓存雪崩？.mp4
│  │  [1938] 第35讲：经典问题：先更新数据库，还是先更新缓存？.mp4
│  │  [1939] 第36讲：失效策略：缓存过期都有哪些策略？.mp4
│  │  [1940] 第37讲：负载均衡：一致性哈希解决了哪些问题？.mp4
│  │  [1941] 第38讲：缓存高可用：缓存如何保证高可用？.mp4
│  │  [1942] 加餐6：分布式缓存考点梳理 + 高频面试题.mp4
│  │  [1943] 第39讲：从双十一看高可用的保障方式.mp4
│  │  [1944] 第40讲：高并发场景下如何实现系统限流？.mp4
│  │  [1945] 第41讲：降级和熔断：如何增强服务稳定性？.mp4
│  │  [1946] 第42讲：如何选择适合业务的负载均衡策略？.mp4
│  │  [1947] 第43讲：线上服务有哪些稳定性指标？.mp4
│  │  [1948] 第44讲：分布式下有哪些好用的监控组件？.mp4
│  │  [1949] 第45讲：分布式下如何实现统一日志系统？.mp4
│  │  [1950] 结语：分布式路漫漫，厚积薄发才是王道.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：分布式链路追踪实战
│  │  [4321] 开篇词  如何更好地观测线上系统？.mp4
│  │  [4322] 01  数据观测：数据追踪的基石从哪里来？.mp4
│  │  [4323] 02  系统日志：何以成为保障稳定性的关键？.mp4
│  │  [4324] 03  日志编写：怎样才能编写“可观测”的系统日志？.mp4
│  │  [4325] 04  统计指标：“五个九”对系统稳定的真正意义.mp4
│  │  [4326] 05  监控指标：如何通过分析数据快速定位系统隐患？（上）.mp4
│  │  [4327] 06  监控指标：如何通过分析数据快速定位系统隐患？（下）.mp4
│  │  [4328] 07  指标编写：如何编写出更加了解系统的指标？.mp4
│  │  [4329] 08  链路监控：为什么对于系统而言必不可少？.mp4
│  │  [4330] 09  性能剖析：如何补足分布式追踪短板？.mp4
│  │  [4331] 10  链路分析：除了观测链路，还能做什么？.mp4
│  │  [4332] 11  黑白盒监控：系统功能与结构稳定的根基.mp4
│  │  [4333] 12  系统告警：快速感知业务隐藏问题.mp4
│  │  [4334] 13  告警质量：如何更好地创建告警规则和质量？.mp4
│  │  [4335] 14  告警处理：怎样才能更好地解决问题？.mp4
│  │  [4336] 15  日志收集：ELK 如何更高效地收集日志？.mp4
│  │  [4337] 16  指标体系：Prometheu 如何更完美地显示指标体系？.mp4
│  │  [4338] 17  链路追踪：Zipkin 如何进行分布式追踪？.mp4
│  │  [4339] 18  观测分析：SkyWalking 如何把观测和分析结合起来？.mp4
│  │  [4340] 19  云端观测：ARMS 如何进行云观测？.mp4
│  │  [4341] 20  运维集成：内部的 OSS 系统如何与观测相结合？.mp4
│  │  [4342] 结束语  未来的监控是什么样子？.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：前端基础建设与架构 30 讲
│  │  [5905] 开篇词  像架构师一样思考，突破技术成长瓶颈.mp4
│  │  [5906] 01  npm 安装机制及企业级部署私服原理.mp4
│  │  [5907] 02  Yarn 的安装理念及如何破解依赖管理困境.mp4
│  │  [5908] 03  CI 环境上的 npm 优化及更多工程化问题解析.mp4
│  │  [5909] 04  横向对比主流构建工具，了解构建工具的设计考量.mp4
│  │  [5910] 05  Vite 实现：从源码分析出发，构建 bundlele 开发工程.mp4
│  │  [5911] 06  core-j 及垫片理念：设计一个“最完美”的 Polyfill 方案.mp4
│  │  [5912] 07  梳理混乱的 Babel，不再被编译报错困扰.mp4
│  │  [5913] 08  探索前端工具链生态，制定一个统一标准化 babel-preet.mp4
│  │  [5914] 09  从实战出发，从 0 到 1 构建一个符合标准的公共库.mp4
│  │  [5915] 10  代码拆分和按需加载：缩减 bundle ize，把性能做到极致.mp4
│  │  [5916] 11  Tree Shaking：移除 JavaScript 上下文中的未引用代码.mp4
│  │  [5917] 12  如何理解 AST 实现和编译原理？.mp4
│  │  [5918] 13  工程化思维处理方案：如何实现应用主题切换功能？.mp4
│  │  [5919] 14  解析 Webpack 源码，实现自己的构建工具.mp4
│  │  [5920] 15  从编译到运行，跨端解析小程序多端方案.mp4
│  │  [5921] 16  原生跨平台技术：移动端跨平台到 Flutter 的技术变革.mp4
│  │  [5922] 17  学习 axio：封装一个结构清晰的 Fetch 库.mp4
│  │  [5923] 18  对比 Koa 和 Redux：分析前端中的中间件理念.mp4
│  │  [5924] 19  如何理解软件开发灵活性和高定制性？.mp4
│  │  [5925] 20  如何理解前端中面向对象的思想？.mp4
│  │  [5926] 结束语  再谈项目的基建和架构，个人的价值和方向.mp4
│  │  [5949] 导读  前端技术发展回顾和架构升级之路.mp4
│  │  [5950] 21  如何利用 JavaScript 实现经典数据结构？.mp4
│  │  [5951] 22  剖析前端中的数据结构应用场景.mp4
│  │  [5952] 23  npm cript：打造一体化的构建和部署流程.mp4
│  │  [5953] 24  自动化代码检查：剖析 Lint 工具和工程化接入&优化方案.mp4
│  │  [5954] 25  如何设计一个前端 + 移动端离线包方案？.mp4
│  │  [5955] 26  如何设计一个“万能”项目脚手架？.mp4
│  │  [5956] 27  同构渲染架构：实现一个 SSR 应用.mp4
│  │  [5957] 28  设计性能守卫系统：完善 CICD 流程.mp4
│  │  [5958] 29  实践打造网关：改造企业 BFF 方案.mp4
│  │  [5959] 30  实现高可用：使用 Puppeteer 生成性能最优的海报系统.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：前端工程化精讲
│  │  [4357] 开篇词  建立上帝视角，全面系统掌握前端效率工程化.mp4
│  │  [4415] 01  项目基石：前端脚手架工具探秘.mp4
│  │  [4416] 02  界面调试：热更新技术如何开着飞机修引擎？.mp4
│  │  [4417] 03  构建提速：如何正确使用 SourceMap？.mp4
│  │  [4418] 04  接口调试：Mock 工具如何快速进行接口调试？.mp4
│  │  [4419] 05  编码效率：如何提高编写代码的效率？.mp4
│  │  [4420] 06  团队工具：如何利用云开发提升团队开发效率？.mp4
│  │  [4421] 07  低代码工具：如何用更少的代码实现更灵活的需求？.mp4
│  │  [4422] 08  无代码工具：如何做到不写代码就能高效交付？.mp4
│  │  [4423] 09  构建总览：前端构建工具的演进.mp4
│  │  [4424] 10  流程分解：Webpack 的完整构建流程.mp4
│  │  [4425] 11  编译提效：如何为 Webpack 编译阶段提速？.mp4
│  │  [4426] 12  打包提效：如何为 Webpack 打包阶段提速？.mp4
│  │  [4427] 13  缓存优化：那些基于缓存的优化方案.mp4
│  │  [4428] 14  增量构建：Webpack 中的增量构建.mp4
│  │  [4429] 15  版本特性：Webpack 5 中的优化细节.mp4
│  │  [4430] 16  无包构建：盘点那些 No-bundle 的构建方案.mp4
│  │  [4431] 17  部署初探：为什么一般不在开发环境下部署代码？.mp4
│  │  [4432] 18  工具盘点：掌握那些流行的代码部署工具.mp4
│  │  [4433] 19  安装提效：部署流程中的依赖安装效率优化.mp4
│  │  [4434] 20  流程优化：部署流程中的构建流程策略优化.mp4
│  │  [4435] 21  容器方案：从构建到部署，容器化方案的优势有哪些？.mp4
│  │  [4436] 22  案例分析：搭建基本的前端高效部署系统.mp4
│  │  [4437] 结束语  前端效率工程化的未来展望.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：前端性能优化方法与实战
│  │  [6537] 开篇词  开启刻意练习之路，进阶前端性能技术专家.mp4
│  │  [6538] 01  体系总览：性能优化体系及关键指标设定.mp4
│  │  [6539] 02  性能瓶颈点：从 URL 输入到页面加载整过程分析.mp4
│  │  [6540] 03  案例分析：移动端 M 站性能优化落地注意事项.mp4
│  │  [6568] 04  指标采集：首屏时间指标采集具体办法.mp4
│  │  [6569] 05  指标采集：白屏、卡顿、网络环境指标采集方法.mp4
│  │  [6570] 06  工具实践：性能 SDK 及上报策略设计.mp4
│  │  [6571] 07  平台实践：如何从 0 到 1 搭建前端性能平台.mp4
│  │  [6572] 08  诊断清单：如何实现监控预警并进行问题诊断.mp4
│  │  [6573] 09  优化手段：首屏秒开的 4 重保障.mp4
│  │  [6574] 10  优化手段：白屏 300m 和界面流畅优化技巧.mp4
│  │  [6575] 11  工具实践：如何进行性能专项测试.mp4
│  │  [6576] 12  理论分析：Hybrid 下的性能优化整体分析.mp4
│  │  [6577] 13  高级进阶：保证首次加载为秒开的离线包设计.mp4
│  │  [6578] 14  高级进阶：瞒天过海的骨架屏及 SSR 优化手段.mp4
│  │  [6579] 15  高级进阶：WebView 层及代码架构层面优化.mp4
│  │  [6580] 16  黑科技：详解预请求、预加载及预渲染机制.mp4
│  │  [6581] 17  横向对比：百度、阿里云、美团性能方案对比.mp4
│  │  [6582] 18  性能演进：RN、Flutter、小程序和 Enhance Hybrid.mp4
│  │  [6583] 19  成长之路：前端技术专业能力与业务产出平衡.mp4
│  │  [6584] 结束语  开启性能优化实践之路.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：前端进击笔记
│  │  [7193] 开篇词  前端进阶得打好基础，靠近业务.mp4
│  │  [7194] 导读 1  前端基础知识体系之专业知识篇.mp4
│  │  [7195] 导读 2  前端基础知识体系之项目经验篇.mp4
│  │  [7196] 01  重识 HTML，掌握页面基本结构和加载过程.mp4
│  │  [7197] 02  CSS：页面布局的基本规则和方式.mp4
│  │  [7198] 23  如何设计一个前端项目.mp4
│  │  [7199] 03  JavaScript 如何实现继承？.mp4
│  │  [7200] 04  JavaScript 引擎如何执行 JavaScript 代码？.mp4
│  │  [7201] 05  单线程的 JavaScript 如何管理任务？.mp4
│  │  [7202] 06  一个网络请求是怎么进行的？.mp4
│  │  [7203] 07  HTTP 协议和前端开发有什么关系？.mp4
│  │  [7204] 08  深入剖析浏览器中页面的渲染过程.mp4
│  │  [7205] 09  改善编程思维：从事件驱动到数据驱动.mp4
│  │  [7206] 10  掌握前端框架模板引擎的实现原理.mp4
│  │  [7207] 11  为什么小程序特立独行？.mp4
│  │  [7208] 12  单页应用与前端路由库设计原理.mp4
│  │  [7209] 13  代码构建与 Webpack 必备技能.mp4
│  │  [7210] 14  提升编程体验：组件化与模块化设计.mp4
│  │  [7211] 15  提升开发效率：数据抽象与配置化.mp4
│  │  [7212] 16  实战：三天实现管理端系统.mp4
│  │  [7213] 17  AngularReactVue 三大前端框架的设计特色.mp4
│  │  [7214] 18  如何设计合适的状态管理方案？.mp4
│  │  [7215] 19  如何搭建前端监控体系为业务排忧解难？.mp4
│  │  [7216] 20  如何进行性能分析的自动化实现.mp4
│  │  [7217] 21  前端性能优化与解决方案.mp4
│  │  [7218] 22  如何进行技术方案调研与设计？.mp4
│  │  [7219] 24  通过前端工程化提升团队开发效率.mp4
│  │  [7220] 25  大型前端项目的痛点和优化方案.mp4
│  │  [7221] 26  如何通过前期准备和后期复盘让项目稳定上线.mp4
│  │  [7222] 结束语  如何进行前端职业规划？.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：前端面试宝典之 React 篇
│  │  [5790] 开篇词  如何拿下大厂前端面试.mp4
│  │  [5791] 01  你真的了解 React 吗？.mp4
│  │  [5792] 02  为什么 React 要用 JSX？.mp4
│  │  [5793] 03  如何避免生命周期中的坑？.mp4
│  │  [5794] 04  类组件与函数组件有什么区别呢？.mp4
│  │  [5795] 05  如何设计 React 组件？.mp4
│  │  [5796] 06  etState 是同步更新还是异步更新？.mp4
│  │  [5797] 07  如何面向组件跨层级通信？.mp4
│  │  [5798] 08  列举一种你了解的 React 状态管理框架.mp4
│  │  [5799] 09  Virtual DOM 的工作原理是什么？.mp4
│  │  [5800] 10  与其他框架相比，React 的 diff 算法有何不同？.mp4
│  │  [5801] 11  如何解释 React 的渲染流程？.mp4
│  │  [5802] 12  React 的渲染异常会造成什么后果？.mp4
│  │  [5803] 13  如何分析和调优性能瓶颈？.mp4
│  │  [5804] 14  如何避免重复渲染？.mp4
│  │  [5805] 15  如何提升 React 代码可维护性？.mp4
│  │  [5806] 16  React Hook 的使用限制有哪些？.mp4
│  │  [5807] 17  ueEffect 与 ueLayoutEffect 区别在哪里？.mp4
│  │  [5808] 18  谈谈 React Hook 的设计模式.mp4
│  │  [5809] 19  React-Router 的实现原理及工作方式分别是什么？.mp4
│  │  [5810] 20  React 中你常用的工具库有哪些？.mp4
│  │  [5811] 彩蛋  如何写一份大厂 HR 满意的简历？.mp4
│  │  [5812] 结束语  沉淀知识体系，精进个人成长.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：前端高手进阶
│  │  [3170] 开篇词：带你一起筑建前端工程师的“护城河”.mp4
│  │  [3171] 第01讲：你真的熟悉 HTML 标签吗？.mp4
│  │  [3172] 第02讲：如何高效操作 DOM 元素？.mp4
│  │  [3173] 第03讲：3 个使用场景助你用好 DOM 事件.mp4
│  │  [3174] 第04讲：掌握 CSS 精髓：布局.mp4
│  │  [3175] 第05讲：如何管理你的 CSS 代码？.mp4
│  │  [3176] 加餐1：手写 CSS 预处理.mp4
│  │  [3177] 第06讲：浏览器如何渲染页面？.mp4
│  │  [3178] 第07讲：关于 JavaScript 的数据类型，你知多少？.mp4
│  │  [3179] 第08讲：为什么说函数是 JavaScript 的一等公民？.mp4
│  │  [3180] 第09讲：为什么代码没有按照编写顺序执行？.mp4
│  │  [3181] 第10讲：怎么复用你的代码？.mp4
│  │  [3182] 第11讲：为什么说 JavaScript 不适合大型项目？.mp4
│  │  [3183] 第12讲：浏览器如何执行 JavaScript 代码？.mp4
│  │  [3184] 第13讲：区分浏览器中的进程与线程.mp4
│  │  [3185] 加餐2：手写 Promie、ayncawait.mp4
│  │  [3186] 第14讲：HTTP 协议和它的“补丁”们.mp4
│  │  [3187] 第15讲：如何让浏览器更快地加载网络资源？.mp4
│  │  [3188] 第16讲：浏览器同源策略与跨域方案详解.mp4
│  │  [3189] 第17讲：前后端如何有效沟通？.mp4
│  │  [3190] 第18讲：你是怎么理解“组件”这个概念的？.mp4
│  │  [3191] 第19讲：把路由放在前端意味着什么？.mp4
│  │  [3192] 第20讲：详解组件通信之状态管理.mp4
│  │  [3193] 第21讲：你的代码到底是怎么编译的？.mp4
│  │  [3194] 第22讲：如何合理搭建前端项目？.mp4
│  │  [3195] 第23讲：谈性能优化到底在谈什么？.mp4
│  │  [3196] 第24讲：你的代码是怎么成为黑客工具的？.mp4
│  │  [3197] 第25讲：Node.j == 全栈？.mp4
│  │  [3198] 第26讲：常用的数据结构了解多少？.mp4
│  │  [3199] 第27讲：到底该不该了解算法？.mp4
│  │  [3200] 第28讲：你都了解过哪些编程方式？.mp4
│  │  [3201] 第29讲：框架到底用了哪些设计模式？.mp4
│  │  [3202] 第30讲：前端热点技术之 Serverle.mp4
│  │  [3203] 第31讲：微前端与功能的可重用性.mp4
│  │  [3204] 彩蛋：如何获得心仪的 Offer？.mp4
│  │  [3205] 结束语：谈谈前端工程师的职业规划（如何跳槽、如何晋升）.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：即学即用的Spark实战44讲
│  │  [1971] 开篇词：学了就能用的 Spark？.mp4
│  │  [1972] 第01讲： MapReduce：计算框架和编程模型.mp4
│  │  [1973] 第02讲：Hadoop：集群的操作系统.mp4
│  │  [1974] 第03讲：如何设计与实现统一资源管理与调度系统.mp4
│  │  [1975] 第04讲：解析 Spark 数据处理与分析场景.mp4
│  │  [1976] 第05讲：如何选择 Spark 编程语言以及部署 Spark.mp4
│  │  [1977] 第06讲：Spark 抽象、架构与运行环境.mp4
│  │  [1978] 第07讲：Spark 核心数据结构：弹性分布式数据集 RDD.mp4
│  │  [1979] 第08讲：算子：如何构建你的数据管道？.mp4
│  │  [1980] 第09讲：函数式编程思想：你用什么声明，你在声明什么？.mp4
│  │  [1981] 第10讲：共享变量：如何在数据管道中使用中间结果？.mp4
│  │  [1982] 第11讲：计算框架的分布式实现：剖析 Spark Shuffle 原理.mp4
│  │  [1983] 第12讲：如何处理结构化数据：DataFrame 、Dataet和Spark SQL.mp4
│  │  [1984] 第13讲：如何使用用户自定义函数？.mp4
│  │  [1985] 第14讲：列式存储：针对查询场景的极致优化.mp4
│  │  [1986] 第15讲：如何对 Spark 进行全方位性能调优？.mp4
│  │  [1987] 第16讲：Tungten 和 Hydrogen：Spark 性能提升与优化计划.mp4
│  │  [1988] 第17讲：实战：探索葡萄牙银行电话调查的结果.mp4
│  │  [1989] 第18讲：流处理：什么是流处理？以及你必须考虑的消息送达保证问题.mp4
│  │  [1990] 第19讲：批处理还是流处理：Spark Streaming 抽象、架构与使用方法.mp4
│  │  [1991] 第20讲：如何在生产环境中使用 Spark Streaming.mp4
│  │  [1992] 第21讲：统一批处理与流处理：Dataflow.mp4
│  │  [1993] 第22讲：新一代流式计算框架：Structured Streaming.mp4
│  │  [1994] 第23讲：如何对 Spark 流处理进行性能调优？.mp4
│  │  [1995] 第24讲：实战：如何对股票交易实时价格进行分析？.mp4
│  │  [1996] 第25讲： 什么是图：图模式，图相关技术与使用场景.mp4
│  │  [1997] 第26讲：数据并行：Spark 如何抽象图，如何切分图，如何处理图.mp4
│  │  [1998] 第27讲：像顶点一样思考：大规模并行图挖掘引擎 GraphX.mp4
│  │  [1999] 第28讲：Pregel 还是 MapReduce：一个有趣的算子 AggregateMeage.mp4
│  │  [2000] 第29讲：实战 1：用 GraphX 实现 PageRank 算法.mp4
│  │  [2001] 第30讲：实战 2：用 GraphX 求得顶点的 n 度邻居.mp4
│  │  [2002] 第31讲：机器学习是什么： 机器学习与机器学习工作流.mp4
│  │  [2003] 第32讲：标准化机器学习流程：ML pipeline.mp4
│  │  [2004] 第33讲：如何对数据进行预处理？.mp4
│  │  [2005] 第34讲：少数服从多数：随机森林分类器.mp4
│  │  [2006] 第35讲：物以类聚：Kmean 聚类算法.mp4
│  │  [2007] 第36讲：推荐引擎：协同过滤.mp4
│  │  [2008] 第37讲：如何对模型性能进行评估并调优？.mp4
│  │  [2009] 第38讲：数据仓库与商业智能系统架构剖析.mp4
│  │  [2010] 第39讲：作为 Yelp 运营负责人，如何根据数据进行决策？.mp4
│  │  [2011] 第40讲：如何获取业务数据库的数据.mp4
│  │  [2012] 第41讲：如何构建数据立方体.mp4
│  │  [2013] 第42讲：如何通过 OLAP 与报表呈现结果.mp4
│  │  [2014] 第43讲：两个简化了的重要问题：数据更新和数据实时性.mp4
│  │  [2015] 第44讲：另一种并行：Lambda 架构与 Kappa 架构.mp4
│  │  [2016] 结束语：统一的编程模型，统一的编程语言，统一的架构.mp4
│  │  [2017] 彩蛋：如何成为 Spark Contributor.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：大数据技术基础 22 讲
│  │  [6512] 开篇词  如何在庞大的大数据体系中明确路径？.mp4
│  │  [6513] 01  从天气预报看什么是大数据.mp4
│  │  [6514] 02  从萌芽到爆发，大数据经历了哪些发展？.mp4
│  │  [6515] 03  为了追赶当下趋势，我们要做什么思想准备？.mp4
│  │  [6516] 04  阿里美团这些大厂都在用什么大数据架构？.mp4
│  │  [6517] 05  大数据开发必备工具——Hadoop.mp4
│  │  [6518] 06  精准溯源：大数据中的数据到底是从哪儿来的？.mp4
│  │  [6519] 07  专为解决大数据存储问题而产生的 HDFS.mp4
│  │  [6520] 08  HBae 和 Hive 你能分清楚吗？.mp4
│  │  [6521] 09  让你彻底明白为什么大公司都在做云服务.mp4
│  │  [6522] 10  消息系统 Kafka 与 Flume 如何抉择.mp4
│  │  [6523] 11  MapReduce 处理大数据的基本思想有哪些.mp4
│  │  [6524] 12  Spark 与 Flink 的爱恨情仇（上）.mp4
│  │  [6525] 13  Spark 与 Flink 的爱恨情仇（下）.mp4
│  │  [6526] 14  带你聊一聊标准化数据挖掘全流程.mp4
│  │  [6527] 15  让你一看就懂的数据挖掘四大经典算法.mp4
│  │  [6528] 16  计算机视觉 VS 自然语言处理，你选哪个？.mp4
│  │  [6529] 17  如何深入分析电商数据中的价值？.mp4
│  │  [6530] 18  数据可视化：如何直观地“看见”数据？.mp4
│  │  [6531] 19  如何快速搭建一个推荐系统？.mp4
│  │  [6532] 20  如何从零开始做数据化运营？.mp4
│  │  [6533] 21  大数据环境下如何保护隐私.mp4
│  │  [6534] 22  数据中台：用大数据赋能业务.mp4
│  │  [6535] 彩蛋  大数据时代，未来将去向何方.mp4
│  │  [6536] 结束语  得大数据者得天下.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：大数据运维实战
│  │  [3075] 开篇词：掌握大数据，把握未来.mp4
│  │  [3076] 第01讲：大话 Hadoop 生态圈.mp4
│  │  [3077] 第02讲：Hadoop 发行版选型和伪分布式平台的构建.mp4
│  │  [3078] 第03讲：自动化运维工具 Anible 在部署大数据平台下的应用（上）.mp4
│  │  [3079] 第05讲：手动模式构建双 Namenode+Yarn 的 Hadoop 集群（上）.mp4
│  │  [3080] 第07讲：通过 Ambari 工具自动化构建 Hadoop 大数据平台和外围应用（上）.mp4
│  │  [3081] 第09讲：如何通过 Hivetez 与 Hadoop 的整合快速实现大数据开发（上）.mp4
│  │  [3082] 第11讲：HDFS 组件运行机制剖析及 HDFS Shell 的使用.mp4
│  │  [3083] 第12讲：Hadoop 分布式资源管理器 Yarn、MR 运行机制剖析.mp4
│  │  [3084] 第13讲：Spark Standalone 模式的构建以及 Spark 与 Yarn 的整合.mp4
│  │  [3085] 第14讲：HBae 与 Hadoop 的整合应用实践.mp4
│  │  [3086] 第15讲：Flink Standalone、Flink on Yarn 集群构建与应用场景.mp4
│  │  [3087] 第16讲：轻量级日志收集工具 Filebeat 应用案例.mp4
│  │  [3088] 第17讲：日志收集、分析过滤工具 Logtah 应用实战.mp4
│  │  [3089] 第18讲：Elaticearch 应用架构的实现与调优.mp4
│  │  [3090] 第19讲：Kafka 应用场景、集群容量规划、架构设计应用案例.mp4
│  │  [3091] 第20讲：日均数据量 30 亿的 Filebeat+Kafka+Mirrormaker 跨机房实时日志传送案例.mp4
│  │  [3092] 第21讲：Filebeat+Kafka+Logtah+Elaticearch 构建可视化日志分析系统.mp4
│  │  [3093] 第22讲：通过 Ganglia 实现对 HDFS、Yarn、Spark 运行状态监控.mp4
│  │  [3094] 第23讲：Namenode、Datanode、Nodemanager 等服务状态监控策略.mp4
│  │  [3095] 第24讲：通过 Kafka Eagle 实现对 Kafka 消息队列的监控.mp4
│  │  [3096] 第25讲：Yarn 资源调度 Fair Schedule 与 Capacity Scheduler 配置选型.mp4
│  │  [3097] 第26讲：HDFS 存储权限 ACL 控制策略以及与系统权限整合应用.mp4
│  │  [3098] 第27讲：Yarn、HDFS、Kafka 内存调优策略以及性能瓶颈.mp4
│  │  [3099] 第28讲：Hadoop 平台常见故障汇总以及操作系统性能调优.mp4
│  │  [3100] 第29讲：大数据平台的硬件规划、网络调优、架构设计、节点规划.mp4
│  │  [3101] 第30讲：Hadoop 跨集群数据迁移应用实践.mp4
│  │  [3163] 第04讲：自动化运维工具 Anible 在部署大数据平台下的应用（下）.mp4
│  │  [3208] 第06讲：手动模式构建双 Namenode+Yarn 的 Hadoop 集群（下）.mp4
│  │  [3337] 第08讲：通过 Ambari 工具自动化构建 Hadoop 大数据平台和外围应用（下）.mp4
│  │  [3338] 第10讲：如何通过 Hivetez 与 Hadoop 的整合快速实现大数据开发（下）.mp4
│  │  [4445] 结语：大数据运维，大有作为.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：如何高效准备简历和面试
│  │  [41] 第01讲：技术岗薪资对比+供需分析.mp4
│  │  [42] 第02讲：如何挑选命中率高的好工作？.mp4
│  │  [43] 第03讲：诊断：简历为什么被忽视？.mp4
│  │  [44] 第04讲：技术简历应该怎么写、怎么投？.mp4
│  │  [45] 第05讲：如何提高面试成功率？.mp4
│  │  [46] 第06讲：使用STAR法则表现自己.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：应用性能分析实战
│  │  [7049] 开篇词  提效工具 or 耗能摆设？落地 APM 要做好这三点.mp4
│  │  [7050] 01  APM 引领者：Apache SkyWalking 的开放、共享精神.mp4
│  │  [7051] 02  系统监控：老牌监控点评 CAT，依然经久不衰.mp4
│  │  [7052] 03  诊断利器：Java 性能分析神器 Alibaba  Artha.mp4
│  │  [7053] 04  流量卫士：Alibaba Sentinel 时刻守卫流量健康.mp4
│  │  [7054] 05  故障定位：Java ViualVM，第一款多合一的轻量可视化工具.mp4
│  │  [7055] 06  日志可视化：Kibana 让千万行日志有形有样.mp4
│  │  [7056] 07  数据可视化：多数据源让 Grafana 监控报警更高效.mp4
│  │  [7057] 08  工匠精神：熟悉 APM 产品的能力是 RD 的分内之事.mp4
│  │  [7058] 09  OpenTracing 解密 Dapper 说它是树，SkyWalking 说它是图.mp4
│  │  [7059] 10  亲和线程模型：分布式链路追踪，学习 SkyWalking 就够了.mp4
│  │  [7060] 11  资源节点树：通过 Sentinel 无侵入实现流量链生成规则.mp4
│  │  [7061] 12  并发编程：流量洪峰下，Sentinel 如何高效精准计算？.mp4
│  │  [7062] 13  结构化日志：如何规范数千开发的应用日志？.mp4
│  │  [7063] 14  互通有无：如何设计跨语言的 APM 交互协议？.mp4
│  │  [7064] 15  数据磐石：APM 收集端的存储模型.mp4
│  │  [7065] 16  采样设计：资源有限，如何实现数据的低损耗、高收集？.mp4
│  │  [7066] 17  数据猎手：基于 Binlog，用 Canal 快速搭建 BI 监控.mp4
│  │  [7067] 18  链路训练：分布式问题下，让每个 RD 拥有独立定位能力.mp4
│  │  [7068] 19  望火楼：与故障系统联动，纳入、积累故障资产.mp4
│  │  [7069] 20  能力进阶：APM 工具自燃？随时客串 APM 工程师.mp4
│  │  [7070] 21  高维思考：通过监控 Cae，彻底悟透 OpenTracing.mp4
│  │  [7071] 22  拥抱未来：如何备战下一代性能监控系统？.mp4
│  │  [7072] 结束语：学习 APM，从工具视角看性能管理.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：微服务Service Mesh原理与实战
│  │  [5992] 开篇词  Service Meh，传统微服务架构新的里程碑.mp4
│  │  [5993] 导读  Service Meh：从单体服务出发，独立于业务演进的微服务架构.mp4
│  │  [5994] 01  注册中心：微服务的重中之重.mp4
│  │  [5995] 02  注册中心：如何搭建一个高可用、健壮的注册中心？.mp4
│  │  [5996] 03  负载均衡器：服务发现后如何实现节点保护？.mp4
│  │  [5997] 04  负载均衡器：如何实现染色和地域优先？.mp4
│  │  [5998] 05  路由器：针对不同的流量实现多种路由策略.mp4
│  │  [5999] 06  服务治理之限流熔断：引入微服务架构后，不可缺少的功能组件.mp4
│  │  [6000] 07  连接池：阻塞式连接池和多路复用连接池的差异.mp4
│  │  [6001] 08  微服务网关（Kong）：网关在微服务架构中的作用.mp4
│  │  [6002] 09  配置中心：如何在微服务治理中发挥更大的作用？.mp4
│  │  [6003] 10  可观测性之 Trace：更快速定位问题.mp4
│  │  [6004] 11  可观测性之监控告警：利用 Prometheu 和 Grafana 收集监控数据.mp4
│  │  [6005] 12  技术选型：在众多 Service Meh 开源产品中选择合适自己的.mp4
│  │  [6006] 13  Envoy 入门：最常用的数据面介绍.mp4
│  │  [6007] 14  Itio 入门：基于最新 1.7 版本的环境搭建和介绍.mp4
│  │  [6008] 15  xDS：控制面和数据面的通信桥梁.mp4
│  │  [6009] 16  Ingre 和 Egre：入口流量和出口流量控制.mp4
│  │  [6010] 17  金丝雀发布：金丝雀部署和版本控制.mp4
│  │  [6011] 18  如何利用组件做到服务的可观测性？.mp4
│  │  [6012] 19  项目背景：判断选择开源产品还是自研.mp4
│  │  [6013] 20  数据面：基于 Go-Micro 快速实现代理模块.mp4
│  │  [6014] 21  控制面：实现 xDS 配置管理.mp4
│  │  [6015] 22  如何落地：在实践落地中可能遇到的问题和困难.mp4
│  │  [6016] 23  最佳实践：为什么要从 SDK 演进到 Service Meh？.mp4
│  │  [6017] 24  未来展望：中间件 Meh 化的可行性.mp4
│  │  [6018] 结束语  Service Meh 会是微服务演进的终极方向吗？.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：微服务质量保障 20 讲
│  │  [4221] 开篇词  既往不恋，当下不杂，未来不迎.mp4
│  │  [4222] 01  微服务架构有哪些特点？.mp4
│  │  [4223] 02  微服务架构下的质量挑战.mp4
│  │  [4224] 03  微服务架构下的测试策略.mp4
│  │  [4225] 04  单元测试：怎样提升最小可测试单元的质量？.mp4
│  │  [4226] 05  集成测试：如何进行微服务的集成测试？.mp4
│  │  [4227] 06  组件测试：如何保证单服务的质量？.mp4
│  │  [4228] 07  契约测试：如何进行消费者驱动的契约测试？.mp4
│  │  [4229] 08  端到端测试：站在用户视角验证整个系统.mp4
│  │  [4230] 09  微服务架构下的质量保障体系全景概览.mp4
│  │  [4231] 10  流程规范篇：高速迭代的研发过程需要怎样的规范？.mp4
│  │  [4232] 11  测试技术篇：测试技术这么多，我该如何选型？.mp4
│  │  [4233] 12  测试技术篇：如何提升测试效率？.mp4
│  │  [4234] 13  测试技术篇：专项测试技术解决了哪些专项问题？.mp4
│  │  [4235] 14  CICD 篇：如何更好地利用多个“测试”环境？.mp4
│  │  [4236] 15  CICD 篇：如何构建持续交付工具链？.mp4
│  │  [4237] 16  度量与运营篇：如何做好质量和效率的度量与运营？.mp4
│  │  [4238] 17  度量与运营篇：如何度量与运营效率和价值？.mp4
│  │  [4239] 18  组织保障篇：质量是设计出来的.mp4
│  │  [4240] 19  软件测试新趋势探讨.mp4
│  │  [4241] 结束语  QA 如何打造自身的核心竞争力？.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：成为会带团队的技术人
│  │  [6348] 开篇词  在管理艺术中寻找确定性的“工程逻辑”.mp4
│  │  [6349] 01  稳定性（一）：如何应对事故并做好复盘？.mp4
│  │  [6350] 02  稳定性（二）：可用性治理的三个关键要点.mp4
│  │  [6351] 03  稳定性（三）：那些年源源不断的“红包”事故.mp4
│  │  [6352] 04  技术债务：如何带领团队从困境中突围而出？.mp4
│  │  [6353] 05  大项目：把握关键点，谋定而后动.mp4
│  │  [6354] 06  业务理解：深入业务是做好架构的前提.mp4
│  │  [6355] 07  架构设计：治理好系统复杂度才最务实.mp4
│  │  [6356] 08  定目标：让你的方向与公司的方向保持一致.mp4
│  │  [6357] 09  追过程：如何用 PDCA 做过程管理？.mp4
│  │  [6358] 10  奖优罚劣：怎样传递我们要什么与“不要什么”？.mp4
│  │  [6359] 11  勤沟通：在信任的基础上，让沟通简单且纯粹.mp4
│  │  [6360] 12  建机制：规则流程越建越多，为何效果却越来越差？.mp4
│  │  [6361] 13  知人善用：借事修人，借人成事.mp4
│  │  [6362] 14  找到人：招聘是 Leader 的责任，不是 HR 的.mp4
│  │  [6363] 15  能落地：90 天试用期，转正时我们要考察什么？.mp4
│  │  [6364] 16  升级汰换：“心要慈，刀要快”.mp4
│  │  [6365] 17  晋升：是不是技术到位、项目做好就够了？.mp4
│  │  [6366] 18  跨团队：没有汇报线的人和事就是推不动？.mp4
│  │  [6367] 19  做规划：除了交付和稳定性，还要规划什么？.mp4
│  │  [6368] 20  接手新团队：士气低、交付迟、事故多发，如何下手解决？.mp4
│  │  [6369] 结束语  岁月静好，技术人依然要负重前行.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：打造千万级流量秒杀系统
│  │  [5273] 开篇词  秒杀系统的“三高”架构是怎么炼成的？.mp4
│  │  [5274] 01  功能需求：秒杀业务背景及前端需求是怎么产生的？.mp4
│  │  [5291] 02  功能需求：秒杀活动信息是如何管理的？.mp4
│  │  [5292] 03  非功能需求：高可用、高性能、高并发的指标如何计算？.mp4
│  │  [5293] 04  系统架构：如何设计秒杀的系统架构？.mp4
│  │  [5294] 05  领域建模：DDD 原理及秒杀系统领域模型.mp4
│  │  [5295] 06  云架构：基础设施是如何做到高可用的？.mp4
│  │  [5296] 07  故障转移和恢复：如何通过主备切换缩减故障时间？.mp4
│  │  [5297] 08  过载保护：如何通过熔断和限流解决流量过载问题？.mp4
│  │  [5298] 09  KV 存储：etcd 和 Redi 高可用原理和部署方法.mp4
│  │  [5299] 10  Web 安全：如何解决重放攻击和 XSS 注入？.mp4
│  │  [5300] 11  系统参数：如何按业务场景优化网络性能？.mp4
│  │  [5301] 12  高性能缓存：多级缓存是如何提升服务性能的？.mp4
│  │  [5302] 13  高性能日志：如何提升日志性能避免 IO 瓶颈？.mp4
│  │  [5303] 14  流量负载均衡：LVS 和 Nginx 原理和使用方法.mp4
│  │  [5304] 15  池化技术：连接池和协程池为何能提升并发能力？.mp4
│  │  [5305] 16  漏斗模型：如何将并发流量过滤和串行化？.mp4
│  │  [5306] 17  技术选型：如何选择满足“三高”要求的技术？.mp4
│  │  [5307] 18  项目规范：Go 项目初始化都有哪些规范？.mp4
│  │  [5308] 19  热更新：如何解决程序升级中的稳定性问题？.mp4
│  │  [5309] 20  API 设计：如何使用 RESTFul 和 RPC 实现 API ？.mp4
│  │  [5310] 21  etcd 实战：如何使用 etcd 存储配置信息？.mp4
│  │  [5311] 22  Redi 实战：如何使用 Redi 缓存库存信息？.mp4
│  │  [5312] 23  本地缓存实战：如何使用内存缓存提升数据命中率？.mp4
│  │  [5313] 24  连接池：如何实现连接池减少连接所需时间？.mp4
│  │  [5314] 25  协程池：如何实现协程池降低 CPU 消耗？.mp4
│  │  [5315] 26  过滤器：如何实现用户认证和反黄牛过滤无效请求？.mp4
│  │  [5316] 27  限流器：如何实现熔断器和限流器防止宕机和雪崩？.mp4
│  │  [5317] 28  分布式事务：如何使用队列和分布式锁防止库存超售？.mp4
│  │  [5318] 29  单元测试：如何做单元测试和 benchmark？.mp4
│  │  [5319] 30  性能调优：如何使用 ab 命令和 pprof 分析性能？.mp4
│  │  [5320] 31  预热和压测：SLB 预热和压测的意义及方法.mp4
│  │  [5321] 结束语  程序员成长之路.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：拉勾教育 社群运营增长与变现
│  │  拉勾教育 社群运营增长与变现 22讲.docx
│  │  
│  └─视频
│          00：开篇词：道理都懂，为啥做不好社群运营.mp4
│          01：社群运营演变的 3 个阶段 ：萌芽期－粗放期－精细化运营.mp4
│          02：社群运营新思维模式：C-ACM-MT 模型，全链路思考.mp4
│          03：社群运营新方法（一）：PMP 式社群运营法.mp4
│          04：社群运营新方法（二）：5 步手把手教你搭建社群矩阵.mp4
│          05：用对社群“CABT”引流模型，实现 0 成本获客.mp4
│          06：用好这 4 种方法，获取精准社群种子用户.mp4
│          07：社群裂变成功的 3 要素：海报、工具、诱饵.mp4
│          08：管理社群有 3 宝，立规范、勤培训、树榜样！.mp4
│          09：潜水 vs 划水？3 大经典活动模版帮你找到社群活跃的最佳方式.mp4
│          10：短命 or 长寿？这 4 种社群内容策略是决定性因素.mp4
│          11：社群变现 6 大路径拆解，环环相扣、立竿见影.mp4
│          12：促成用户下单的 5 大成交公式，3 个维度提升转化率.mp4
│          13：CRM 式跟单技巧：3 种聊天剧本设计法，让用户乐意掏腰包.mp4
│          14：一张“社群体检表”带你诊断社群健康度.mp4
│          15：4 个数据维度，帮你找到社群运营核心指标.mp4
│          16：0 门槛 10 分钟教你学会使用一款社群数据分析工具.mp4
│          17：案例实操  内容种草圈粉 10w，社群变现周销售额近 130w.mp4
│          18：案例实操｜在线教育行业社群运营实操案例.mp4
│          19：案例实操｜女装店在双十一裂变，做促销、当晚破 103w.mp4
│          20：实操案例｜靠“读书”社群不断裂变，一年用户暴增 10 倍.mp4
│          21：实操案例｜设置诱饵裂变 100 位团长，每月配送生鲜 50w.mp4
│          22：案例实操｜借助 3 大流量工具，奶粉社群日均吸粉 2000 人.mp4
│          
├─拉勾：数据分析与可视化精讲
│  │  [4474] 开篇词  掌握数字化转型时代的必备技能.mp4
│  │  [4475] 01  概念解析：什么是数据可视化分析.mp4
│  │  [4476] 02  建设方法：数据可视化分析的庖丁之术.mp4
│  │  [4477] 03  技术框架：数据可视化分析的两种武器.mp4
│  │  [4478] 04  图表组件：Echart 数据可视化图表基础.mp4
│  │  [4479] 05  框架搭建：PyEchart 数据可视化环境.mp4
│  │  [4480] 06  PyEchart 开发快速入门.mp4
│  │  [4481] 07  案例 1：实时数据监控指标卡设计.mp4
│  │  [4482] 08  案例 2：历史数据变化趋势图设计.mp4
│  │  [4483] 09  案例 3：订单商品构成模型图设计.mp4
│  │  [4484] 10  案例 4：客户地理位置分布图设计.mp4
│  │  [4485] 11  案例 5：门店盈利能力对比图设计.mp4
│  │  [4486] 12  案例 6：竞争优势多维分析图设计.mp4
│  │  [4487] 13  Flak Web 框架基础.mp4
│  │  [4488] 14  PyEchart & Flak 框架集成.mp4
│  │  [4489] 15  PyEchart & Flak 集成案例.mp4
│  │  [4490] 结束语  数据可视化分析学习经验总结和心得体会.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：数据分析思维与实战 23 讲
│  │  [3491] 开篇词：数据分析能力，是每个职场人必备的核心竞争力.mp4
│  │  [3492] 01  如何解决临时提数需求？.mp4
│  │  [3493] 02  如何搞定 BAT 大厂的数据分析项目？.mp4
│  │  [3494] 03  怎样才更好地转型或成功跳槽？.mp4
│  │  [3495] 04  如何挑选适合项目场景的数据分析工具？.mp4
│  │  [3496] 05  多元思维模型：数据分析需要具备的四大能力？.mp4
│  │  [3497] 06  电商数据分析：京东 App 的详细产品分析.mp4
│  │  [3498] 07  互联网金融：芝麻信用分的建模过程是怎样的？.mp4
│  │  [3499] 08  游戏：游戏行业的 ROI 和付费率是怎么算的？.mp4
│  │  [3500] 09  销售：传统行业如何做好交易额提升？.mp4
│  │  [3501] 10  指标体系搭建：指标体系的经典四步.mp4
│  │  [3502] 11  流量分析：如何分析数据的波动？.mp4
│  │  [3503] 12  路径分析：用户的使用路径网络分析.mp4
│  │  [3504] 13  竞品分析：教你如何做竞品分析.mp4
│  │  [3505] 14  营销活动：日常运营活动的分析模板.mp4
│  │  [3506] 15  用户增长：用户增长的本质是什么？.mp4
│  │  [3507] 16  问题定义和拆解：如何去定义问题、拆解问题？.mp4
│  │  [3508] 17  数据获取与分析：常见的 SQL 技巧和分析方法.mp4
│  │  [3509] 18  报告撰写：专题报告的完美标准化格式.mp4
│  │  [3510] 19  AB 测试：AB 测试的效果监控.mp4
│  │  [3511] 20  行业分析：行业分析及框架分析.mp4
│  │  [3512] 21  数仓：数据仓库的三种类型表.mp4
│  │  [3513] 22  用户研究：用户研究和数据分析的根本联系与区别.mp4
│  │  [3514] 23  时间管理：优秀的数据分析师如何做时间管理？.mp4
│  │  [4513] 结束语：数据分析师职场提升的关键点.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：数据化运营落地实战
│  │  [6273] 开篇词  给你一套数据化运营的“三段式”标准路径.mp4
│  │  [6274] 01  指标体系，思考业务逻辑的第一步.mp4
│  │  [6275] 02  告别迷茫！北极星指标，为业务指明方向.mp4
│  │  [6276] 03  如何规避虚荣指标，合理界定“有效注册用户”？.mp4
│  │  [6277] 04  DAU、MAU、UV：谁是最有参考价值的活跃指标？.mp4
│  │  [6278] 05  关注用户留存就够了吗？值得你关注的另外 3 种留存.mp4
│  │  [6279] 06  四步成诗：一个快速创建指标体系的好方法.mp4
│  │  [6280] 07  分析突破口：如何通过指标抓取数据的主要特征？.mp4
│  │  [6281] 08  多维分析：如何利用指标维度摆脱视野局限？.mp4
│  │  [6282] 09  抓住问题关键：用相关性分析拆解多个影响因素.mp4
│  │  [6283] 10  运营评估：如何通过数据复盘衡量你的运营策略？.mp4
│  │  [6284] 11  业务摸底：如何通过少量样本推断整体业务情况？.mp4
│  │  [6285] 12  趋势预测：如何推测核心指标的未来发展趋势？.mp4
│  │  [6286] 13  工具与方法：如何运用 3A3R 模型将数据转化为运营策略.mp4
│  │  [6287] 14  洞察与获客：如何?效拉新获客？.mp4
│  │  [6288] 15  活跃（上）：如何通过运营手法提升?户活跃度？.mp4
│  │  [6289] 16  活跃（下）： 如何通过用户分层进?沉默唤醒？.mp4
│  │  [6290] 17  留存：如何通过数据、社交、内容手段提升用户留存？.mp4
│  │  [6291] 18  营收：如何通过交叉营销提升用户营收贡献？.mp4
│  │  [6292] 19  传播（上）：如何打造千万级的私域运营体系？.mp4
│  │  [6293] 20  传播（下）：如何制定百万级的裂变传播策略？.mp4
│  │  [6294] 彩蛋  如何用“金字塔原理”撰写数据运营分析报告？.mp4
│  │  [6295] 结束语  工作之余：功夫在诗外，数据在生活.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：数据挖掘思维与实战 24 讲
│  │  [4287] 开篇词  掌握数据挖掘，搭上划时代的数字化列车.mp4
│  │  [4288] 01  数据挖掘，到底在解决什么问题？.mp4
│  │  [4289] 02  Python 的数据结构和基本语法.mp4
│  │  [4290] 03  工欲善其事必先利其器，扩展包与 Python 环境.mp4
│  │  [4291] 04  理解业务和数据：我们需要做好什么计划？.mp4
│  │  [4292] 05  准备数据：如何处理出完整、干净的数据？.mp4
│  │  [4293] 06  数据建模：该如何选择一个适合我需求的算法？.mp4
│  │  [4294] 07  模型评估：如何确认我们的模型已经达标？.mp4
│  │  [4295] 08  模型应用：我们的模型是否可以解决业务需求？.mp4
│  │  [4296] 09  KNN 算法：近朱者赤，近墨者黑.mp4
│  │  [4297] 10  决策树：女神使用的约会决策.mp4
│  │  [4298] 11  朴素贝叶斯：算一算你是否要买延误险.mp4
│  │  [4299] 12  支持向量机（SVM）：用一条线分开红豆与绿豆.mp4
│  │  [4300] 13  人工神经网络：当前最火热的深度学习基础.mp4
│  │  [4301] 14  实践 1：使用 XGB 实现酒店信息消歧.mp4
│  │  [4302] 15  k-mean 聚类：擒贼先擒王，找到中心点，它附近的都是一类.mp4
│  │  [4303] 16  DBScan 聚类：打破形状的限制，使用密度聚类.mp4
│  │  [4304] 17  实践 2：如何使用 word2vec 和 k-mean 聚类寻找相似的城市.mp4
│  │  [4305] 18  线性回归与逻辑回归找到一个函数去拟合数据.mp4
│  │  [4306] 19  实践 3：使用线性回归预测房价.mp4
│  │  [4307] 20  Apriori 与 FP-Growth：不得不再说一遍啤酒与尿布的故事.mp4
│  │  [4308] 21  实践 4：用关联分析找到景点与玩法的关系.mp4
│  │  [4309] 22  TF-IDF：一种简单、古老，但有用的关键词提取技术.mp4
│  │  [4310] 23  word2vec：让文字可以进行逻辑运算，女人+王冠=女王.mp4
│  │  [4311] 24  实践 5：使用 fatText 进行新闻文本分类.mp4
│  │  [4312] 彩蛋  数据挖掘工程师如何进阶.mp4
│  │  [4313] 结语  培养数据挖掘思维，终身学习.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：数据结构与算法面试宝典
│  │  [6689] 开篇词 ?告别盲目刷题，击破算法面试.mp4
│  │  [6690] 01  栈：从简单栈到单调栈，解决经典栈问题.mp4
│  │  [6691] 02  队列：FIFO 队列与单调队列的深挖与扩展.mp4
│  │  [6692] 03  优先级队列：堆与优先级队列，筛选最优元素.mp4
│  │  [6693] 04  链表：如何利用“假头、新链表、双指针”解决链表题？（上）.mp4
│  │  [6694] 05  链表：如何利用“假头、新链表、双指针”解决链表题？（下）.mp4
│  │  [6695] 06  树：如何深度运用树的遍历？.mp4
│  │  [6696] 07  并查集：如何利用两行代码写并查集？.mp4
│  │  [6697] 08? 排序：如何利用合并与快排的小技巧，解决算法难题？.mp4
│  │  [6698] 09? 二分搜索：为什么说有序皆可用二分？.mp4
│  │  [6699] 10? 双指针：如何掌握最长、定长、最短区间问题的解题决窍？.mp4
│  │  [6700] 11? 贪心：这种思想，没有模板，如何才能掌握它？.mp4
│  │  [6701] 12? 回溯：我把回溯总结成一个公式，回溯题一出就用它.mp4
│  │  [6702] 13? 搜索：如何掌握 DFS 与 BFS 的解题套路？.mp4
│  │  [6703] 14  DP：我是怎么治好“DP?头痛症”的？.mp4
│  │  [6704] 15? 字符串查找：为什么我最终选择了 BM 算法？.mp4
│  │  [6705] 16? 如何利用 DP 与单调队列寻找最大矩形？.mp4
│  │  [6706] 17? 深度思考子集：如何掌握 5 种通用解法？.mp4
│  │  [6707] 18? 单词接龙：如何巧用深搜与广搜的变形？.mp4
│  │  [6708] 19? 最小体力消耗路径：如何突破经典题型，掌握解题模板？.mp4
│  │  [6709] 20? 5 种解法，如何利用常量空间求解最长有效括号长度？.mp4
│  │  [6710] 21? 安排会议室：如何利用多种方法安排会议室？.mp4
│  │  [6711] 22 ?数据结构模板：如何让解题变成搭积木？.mp4
│  │  [6712] 23 ?算法模板：如何让高频算法考点秒变默写题？.mp4
│  │  [6713] 彩蛋  聊聊我的大厂面试经历，谈谈我对算法学习的看法.mp4
│  │  [6714] 结束语 ?算法的精进之路.mp4
│  │  [6852] 加餐与答疑  第一期 ：一问一答.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：数据结构精讲：从原理到实战
│  │  [513] 第 01 讲：数组内存模型.mp4
│  │  [514] 第 02 讲：位图数组在 Redi 中的应用.mp4
│  │  [517] 第 03 讲：链表基础原理.mp4
│  │  [520] 第 04 讲：链表在 Apache Kafka 中的应用.mp4
│  │  [524] 开篇词：从此不再“面试造火箭、工作拧螺丝”.mp4
│  │  [526] 第 05 讲：哈希函数的本质及生成方式.mp4
│  │  [530] 第 06 讲：哈希函数在 GitHub 和比特币中的应用.mp4
│  │  [544] 第 10 讲：树在 Amazon 中的应用.mp4
│  │  [546] 第 11 讲：平衡树的性能优化.mp4
│  │  [547] 第 12 讲：LSM 树在 Apache HBae 等存储系统中的应用.mp4
│  │  [550] 第 13 讲：用图来表达更为复杂的数据关系.mp4
│  │  [552] 第 14 讲：有向无环图在 Spark 中的应用.mp4
│  │  [553] 第 15 讲：图的实现方式与核心算法.mp4
│  │  [555] 第 16 讲：图在 Uber 拼车业务中的应用.mp4
│  │  [557] 第 17 讲：缓存数据结构在 Nginx 中的应用.mp4
│  │  [559] 第 18讲：高并发数据结构在 Intagram 与 Twitter 中的应用.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：文案高手的18项修炼
│  │  [3392] 开篇词  从小白到文案高手，手把手教你写出爆款文案.mp4
│  │  [3393] 重点内容总结.mp4
│  │  [3394] 01  用户画像：如何对你的目标顾客群做精准分析？.mp4
│  │  [3395] 02  产品测评：20 分钟测评你的产品，如何让文案分分钟打动消费者.mp4
│  │  [3396] 03  深挖痛点：3 招深挖顾客极痛点，如何写出有说服力的购买理由.mp4
│  │  [3397] 04  超级卖点：用 3+5 模型打造产品超级卖点，让顾客看了秒下单.mp4
│  │  [3398] 05  搜集素材：拿到产品无从下笔？学会这两招充实你的话题素材库.mp4
│  │  [3399] 06  搭建框架：如何搭建一个逻辑清晰、吸引人的 “文章框架”？.mp4
│  │  [3400] 07  案例拆解 A：揭秘千万级爆款案例使用的 6 大狠招，手把手教你做爆款.mp4
│  │  [3401] 08  爆款标题：如何在 10 分钟内，写出点击率 5 倍飙升的推文标题？.mp4
│  │  [3402] 09  勾魂开场：如何写出吸引顾客眼球的开场白，让他 10 秒上瘾戒不掉？.mp4
│  │  [3403] 10  塑造信任：拒绝自嗨，如何让顾客完全信任你推荐的产品？.mp4
│  │  [3404] 11  快速成交：如何让“抠门”顾客爽快掏钱下单？.mp4
│  │  [3405] 12  优化自检：转化率至少翻 2 倍，如何 5 步快速优化推文？.mp4
│  │  [3406] 13  案例拆解 B：如何识别伪痛点？掌握蹭热点的绝招.mp4
│  │  [3407] 14  高效拆解：10 分钟拆解爆文，快速进阶成为文案高手！.mp4
│  │  [3408] 15  朋友圈卖货：4 个狠招让朋友圈潜在顾客纷纷下单，转化翻倍.mp4
│  │  [3409] 16  社群转化：3 个核心 6 个步骤，小白也能操作一场收款 10 万+ 的社群发售.mp4
│  │  [3410] 17  文案变现：1 套金主谈判、求职面试的万能表达脚本.mp4
│  │  [3411] 18  影响力打造：1 套影响力模型，教你打造吸金网红 IP.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：极简 OKR 实战
│  │  [4889] 开篇词  如何完成 OKR 理论到实践落地的跨越？.mp4
│  │  [4890] 01  为什么 OKR 广受企业青睐？.mp4
│  │  [4891] 02  创业公司 VS 500 强公司，落地 OKR 重点关注什么？.mp4
│  │  [4892] 03  互联网行业 VS 传统行业，如何灵活应用 OKR ？.mp4
│  │  [4893] 04  重识目标 O：任务和价值，应该以谁为导向？.mp4
│  │  [4894] 05  关键结果 KR：如何制定才能体现目标“进度”？.mp4
│  │  [4895] 06  团队激励难？OKR 目标思维轻松达成.mp4
│  │  [4896] 07  追踪：可视化追踪，让 OKR 公开透明.mp4
│  │  [4897] 08  提优：如何打造高效率的 OKR 制定、评审会议？.mp4
│  │  [4898] 09  反馈：自下而上，OKR 为战略提供优化导向.mp4
│  │  [4899] 结束语  OKR，对价值的极致追求.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：架构师的 36 项修炼
│  │  [16] 开篇词：7分钟Get技术人进阶技巧.mp4
│  │  [17] 第01讲：大型架构的演进之路.mp4
│  │  [18] 第02讲：架构核心技术之分布式缓存（上）.mp4
│  │  [19] 第02讲：架构核心技术之分布式缓存（下）.mp4
│  │  [20] 第03讲：架构核心技术之分布式消息队列.mp4
│  │  [21] 第04讲：架构核心技术之分布式数据存储.mp4
│  │  [22] 第05讲：架构核心技术之微服务.mp4
│  │  [23] 第06讲：高性能系统架构设计.mp4
│  │  [24] 第07讲：高可用系统架构设计.mp4
│  │  [25] 第08讲：系统的安全架构设计.mp4
│  │  [26] 第09讲：架构实战案例分析.mp4
│  │  [27] 第10讲：致未来的架构师.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：架构设计面试精讲
│  │  [6049] 开篇词  中高级研发面试，逃不开架构设计这一环.mp4
│  │  [6050] 01  研发工程师想提升面试竞争力，该具备这三个技术认知.mp4
│  │  [6051] 02  研发工程师如何用架构师视角回答架构设计方案？.mp4
│  │  [6052] 03  面试官如何考察与 CAP 有关的分布式理论？.mp4
│  │  [6053] 04  亿级商品存储下，如何深度回答分布式系统的原理性问题？.mp4
│  │  [6054] 05  海量并发场景下，如何回答分布式事务一致性问题？.mp4
│  │  [6055] 06  分布式系统中，如何回答锁的实现原理？.mp4
│  │  [6056] 07  RPC：如何在面试中展现出“造轮子”的能力？.mp4
│  │  [6057] 08  MQ：如何回答消息队列的丢失、重复与积压问题.mp4
│  │  [6058] 案例串联  如何让系统抗住双十一的预约抢购活动？.mp4
│  │  [6059] 09  如何回答 MySQL 的索引原理与优化问题？.mp4
│  │  [6060] 10  如何回答 MySQL 的事务隔离级别和锁的机制？.mp4
│  │  [6061] 11  读多写少：MySQL 如何优化数据查询方案？.mp4
│  │  [6062] 12  写多读少：MySQL 如何优化数据存储方案？.mp4
│  │  [6063] 13  缓存原理：应对面试你要掌握 Redi 哪些原理？.mp4
│  │  [6064] 14  缓存策略：面试中如何回答缓存穿透、雪崩等问题？.mp4
│  │  [6065] 15  如何向面试官证明你做的系统是高可用的？.mp4
│  │  [6066] 16  如何从架构师角度回答系统容错、降级等高可用问题？.mp4
│  │  [6067] 17  如何向面试官证明你做的系统是高性能的？.mp4
│  │  [6068] 18  如何从架构师角度回答怎么应对千万级流量的问题？.mp4
│  │  [6069] 彩蛋  互联网架构设计面试，你需要掌握的知识体系.mp4
│  │  [6070] 结束语  程序员的道、术、势.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：测试开发入门与实战
│  │  [4660] 开篇词  功能测试转测试开发的正确姿势.mp4
│  │  [4661] 课前必读 1  时代赋予测试开发的机遇与挑战.mp4
│  │  [4662] 课前必读 2  测试开发的职业生涯是怎样的？.mp4
│  │  [4663] 01  自动化测试框架知多少：概述、构成及常用框架类型.mp4
│  │  [4664] 02  经验凝练，反复践行的 13 条自动化测试框架设计原则.mp4
│  │  [4665] 03  告别三大误区，别让分层测试欺骗了你！.mp4
│  │  [4666] 04  必知必会，打好 Python 基本功.mp4
│  │  [4667] 05  告别 CURD，拥抱 Python 高阶编程.mp4
│  │  [4668] 06  玩转 Git 命令，搞定团队协作.mp4
│  │  [4669] 07  你的第一个 Web 测试框架（一）.mp4
│  │  [4670] 08  你的第一个 Web 测试框架（二）.mp4
│  │  [4671] 11  如虎添翼，API 和 UI 自动化测试融合.mp4
│  │  [4672] 12  如何使用 Page Object 设计模型？.mp4
│  │  [4673] 13  DDT：博采众长，数据驱动的秘诀（一）.mp4
│  │  [4674] 14  DDT：博采众长，数据驱动的秘诀（二）.mp4
│  │  [4675] 15  Panda：拒绝低效，数据驱动新手段.mp4
│  │  [4688] 16  测试框架如何做好数据持久化？（一）.mp4
│  │  [4689] 17  测试框架如何做好数据持久化？（二）.mp4
│  │  [4690] 19  命令行参数，助力测试框架高度定制化.mp4
│  │  [4691] 20  环境变化，测试框架如何动态秒切换？.mp4
│  │  [4692] 21  需求多变，测试框架如何动态挑选用例？.mp4
│  │  [4693] 22  技术新趋势，微服务下的测试框架分层实践.mp4
│  │  [4694] 23  告别依赖，Mock Server 必杀技.mp4
│  │  [4695] 24  对外输出，让测试报告自己说话.mp4
│  │  [4696] 25  测试开发求职面经帖.mp4
│  │  [4697] 26  团队影响力，如何在测试工作中脱颖而出？.mp4
│  │  [4698] 结束语  软件测试职业发展之道.mp4
│  │  [4820] 09  你的第一个 API 测试框架（一）.mp4
│  │  [4829] 10  你的第一个 API 测试框架（二）.mp4
│  │  [5193] 18  不只 HTTP，玩转 Web Service 接口测试.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：测试开发核心技术 46 讲
│  │  [1582] 第18讲（下）：名企算法真题剖析.mp4
│  │  [1851] 第30讲：Page Object 模式（移动端）（下）.mp4
│  │  [2078] 第36讲：代理工具与高级 Mock 使用（下）.mp4
│  │  [317] 开篇词：功能测试如何成功转型测试开发？.mp4
│  │  [318] 加餐 1：测试技能的正确学习节奏与进阶之路.mp4
│  │  [319] 第01讲：Linux 与 Shell 环境搭建及介绍.mp4
│  │  [320] 第02讲：Linux 常用命令.mp4
│  │  [321] 第03讲：Linux 三剑客（上）.mp4
│  │  [322] 第05讲：Shell 编程核心技术（上）.mp4
│  │  [323] 第07讲：Linux 与 Shell 名企面试考点梳理与真题剖析.mp4
│  │  [324] 加餐 2：BAT 名企测试工程师职级划分与发展成长.mp4
│  │  [325] 第09讲：Python 数据结构剖析.mp4
│  │  [326] 第10讲：Python 语法知识.mp4
│  │  [327] 第11讲：Python 测试框架.mp4
│  │  [328] 第12讲：Python 面试考点梳理+真题剖析.mp4
│  │  [329] 第13讲：Java 语言在测试行业的地位及知识梳理.mp4
│  │  [330] 加餐 3：测试经典好书&学习资料推荐.mp4
│  │  [331] 第14讲：排序算法考题与经典冒泡排序算法剖析.mp4
│  │  [332] 第15讲：栈与队列及考题剖析.mp4
│  │  [333] 第16讲：链表及经典考题剖析.mp4
│  │  [334] 第17讲：树结构及经典考题剖析.mp4
│  │  [335] 第18讲（上）：名企算法真题剖析.mp4
│  │  [336] 加餐 4 ：大厂测试岗面试流程梳理.mp4
│  │  [337] 第19讲：MySQL 数据库搭建与操作.mp4
│  │  [338] 第20讲：SQL 语法与关键知识点.mp4
│  │  [339] 第21讲：Redi 高性能缓存数据存储.mp4
│  │  [340] 第22讲：数据库面试题剖析.mp4
│  │  [341] 加餐 5：阿里质量管理体系名师解析.mp4
│  │  [342] 第23讲：Selenium 框架安装与使用.mp4
│  │  [343] 第24讲：Selenium 显式等待与隐式等待.mp4
│  │  [344] 第25讲：Selenium 常用自动化 API.mp4
│  │  [345] 第26讲：Page Object 模式（Web 端）.mp4
│  │  [346] 第27讲：Web 自动化测试演练.mp4
│  │  [347] 加餐 6：腾讯质量管理体系名师解析.mp4
│  │  [348] 第28讲：Appium 自动化测试框架.mp4
│  │  [349] 第29讲：Appium 框架常用自动化 API.mp4
│  │  [350] 第30讲：Page Object 模式（移动端）（上）.mp4
│  │  [351] 第31讲：Android 自动化测试.mp4
│  │  [352] 第32讲：WebView 自动化测试.mp4
│  │  [353] 第33讲：iOS 自动化测试.mp4
│  │  [354] 第34讲：App 自动化测试演练.mp4
│  │  [355] 加餐 7：头条质量管理体系名师解析.mp4
│  │  [356] 第35讲：接口常用协议讲解.mp4
│  │  [358] 第36讲：代理工具与高级 Mock 使用（上）.mp4
│  │  [359] 第37讲：Seion 与 Cookie 的区别.mp4
│  │  [360] 第38讲：接口测试框架.mp4
│  │  [361] 第39讲：接口测试演练.mp4
│  │  [362] 加餐 8：Google 质量管理体系名师解析.mp4
│  │  [363] 第40讲：持续集成体系.mp4
│  │  [364] 第41讲：Jenkin 系统安装与使用.mp4
│  │  [365] 第42讲：Jenkin Job 管理.mp4
│  │  [366] 第43讲：UI 自动化测试持续集成.mp4
│  │  [367] 第44讲：接口测试持续集成.mp4
│  │  [368] 第45讲：持续交付与 DevOp 技术点剖析.mp4
│  │  [369] 加餐 9：测试工程师面试加分项及技巧.mp4
│  │  [370] 第46讲：开源自动化测试框架底层代码改造.mp4
│  │  [371] 第47讲：利用参数化与数据驱动打造通用测试框架.mp4
│  │  [372] 第48讲：测试平台开发技术栈讲解.mp4
│  │  [373] 第04讲：Linux 三剑客（下）.mp4
│  │  [387] 第06讲：Shell 编程核心技术（下）.mp4
│  │  [687] 第08讲：Python 语言基础.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：深入剖析 MyBatis 核心原理
│  │  [6371] 开篇词  领略 MyBati 设计思维，突破持久化技术瓶颈.mp4
│  │  [6372] 01  常见持久层框架赏析，到底是什么让你选择 MyBati？.mp4
│  │  [6373] 02  订单系统持久层示例分析，20 分钟带你快速上手 MyBati.mp4
│  │  [6374] 03  MyBati 源码环境搭建及整体架构解析.mp4
│  │  [6375] 04  MyBati 反射工具箱：带你领略不一样的反射设计思路.mp4
│  │  [6376] 05  数据库类型体系与 Java 类型体系之间的“爱恨情仇”.mp4
│  │  [6377] 06  日志框架千千万，MyBati 都能兼容的秘密是什么？.mp4
│  │  [6378] 07  深入数据源和事务，把握持久化框架的两个关键命脉.mp4
│  │  [6379] 08  Mapper 文件与 Java 接口的优雅映射之道.mp4
│  │  [6380] 09  基于 MyBati 缓存分析装饰器模式的最佳实践.mp4
│  │  [6381] 10  鸟瞰 MyBati 初始化，把握 MyBati 启动流程脉络（上）.mp4
│  │  [6382] 11  鸟瞰 MyBati 初始化，把握 MyBati 启动流程脉络（下）.mp4
│  │  [6383] 12  深入分析动态 SQL 语句解析全流程（上）.mp4
│  │  [6384] 13  深入分析动态 SQL 语句解析全流程（下）.mp4
│  │  [6385] 14  探究 MyBati 结果集映射机制背后的秘密（上）.mp4
│  │  [6386] 15  探究 MyBati 结果集映射机制背后的秘密（下）.mp4
│  │  [6387] 16  StatementHandler：参数绑定、SQL 执行和结果映射的奠基者.mp4
│  │  [6388] 17  Executor 才是执行 SQL 语句的幕后推手（上）.mp4
│  │  [6389] 18  Executor 才是执行 SQL 语句的幕后推手（下）.mp4
│  │  [6390] 20  插件体系让 MyBati 世界更加精彩.mp4
│  │  [6391] 21  深挖 MyBati 与 Spring 集成底层原理.mp4
│  │  [6392] 22  基于 MyBati 的衍生框架一览.mp4
│  │  [6393] 结束语  会使用只能默默“搬砖”，懂原理才能快速晋升.mp4
│  │  [7016] 19  深入 MyBati 内核与业务逻辑的桥梁——接口层.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：深入浅出 Java 虚拟机
│  │  [1025] 第01讲：一探究竟：为什么需要 JVM？它处在什么位置？.mp4
│  │  [1026] 第02讲：大厂面试题：你不得不掌握的 JVM 内存管理.mp4
│  │  [1027] 第03讲：大厂面试题：从覆盖 JDK 的类开始掌握类的加载机制.mp4
│  │  [1028] 第04讲：动手实践：从栈帧看字节码是如何在 JVM 中进行流转的.mp4
│  │  [1030] 第06讲：深入剖析：垃圾回收你真的了解吗？（上）.mp4
│  │  [1031] 第07讲：大厂面试题：有了 G1 还需要其他垃圾回收器吗？.mp4
│  │  [1033] 第09讲：案例实战：面对突如其来的 GC 问题如何下手解决.mp4
│  │  [1034] 第10讲：动手实践：自己模拟 JVM 内存溢出场景.mp4
│  │  [1035] 第11讲：动手实践：遇到问题不要慌，轻松搞定内存泄漏.mp4
│  │  [1036] 第12讲：工具进阶：如何利用 MAT 找到问题发生的根本原因.mp4
│  │  [1037] 第13讲：动手实践：让面试官刮目相看的堆外内存排查.mp4
│  │  [1038] 第14讲：预警与解决：深入浅出 GC 监控与调优.mp4
│  │  [1041] 开篇词：JVM，一块难啃的骨头.mp4
│  │  [1044] 第19讲：动手实践：从字节码看并发编程的底层实现.mp4
│  │  [1045] 第20讲：动手实践：不为人熟知的字节码指令.mp4
│  │  [1046] 第21讲：深入剖析：如何使用 Java Agent 技术对字节码进行修改.mp4
│  │  [1047] 第22讲：动手实践：JIT 参数配置如何影响程序运行？.mp4
│  │  [1048] 第23讲：案例分析：大型项目如何进行性能瓶颈调优？.mp4
│  │  [1049] 第24讲：未来：JVM 的历史与展望.mp4
│  │  [1050] 第25讲：福利：常见 JVM 面试题补充.mp4
│  │  [1544] 第06讲：深入剖析：垃圾回收你真的了解吗？（下）.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：深入浅出搞定 React
│  │  [4849] 开篇词  这一次，真正吃透 React 知识链路与底层逻辑.mp4
│  │  [4850] 01  JSX 代码是如何“摇身一变”成为 DOM 的？.mp4
│  │  [4851] 02  为什么 React 16 要更改组件的生命周期？（上）.mp4
│  │  [4852] 03  为什么 React 16 要更改组件的生命周期？（下）.mp4
│  │  [4853] 04  数据是如何在 React 组件之间流动的？（上）.mp4
│  │  [4854] 05  数据是如何在 React 组件之间流动的？（下）.mp4
│  │  [4855] 06  React-Hook 设计动机与工作模式（上）.mp4
│  │  [4856] 07  React-Hook 设计动机与工作模式（下）.mp4
│  │  [4857] 08  深入 React-Hook 工作机制：“原则”的背后，是“原理”.mp4
│  │  [4858] 09  真正理解虚拟 DOM：React 选它，真的是为了性能吗？.mp4
│  │  [4859] 10  React 中的“栈调和”（Stack Reconciler）过程是怎样的？.mp4
│  │  [4860] 11  etState 到底是同步的，还是异步的？.mp4
│  │  [4861] 12  如何理解 Fiber 架构的迭代动机与设计思想？.mp4
│  │  [4862] 13  ReactDOM.render 是如何串联渲染链路的？（上）.mp4
│  │  [4863] 16  剖析 Fiber 架构下 Concurrent 模式的实现原理.mp4
│  │  [4864] 17  特别的事件系统：React 事件与 DOM 事件有何不同？.mp4
│  │  [4865] 18  揭秘 Redux 设计思想与工作原理（上）.mp4
│  │  [4866] 19  揭秘 Redux 设计思想与工作原理（下）.mp4
│  │  [4867] 20  从 Redux 中间件实现原理切入，理解“面向切面编程”.mp4
│  │  [4868] 22  思路拓展：如何打造高性能的 React 应用？.mp4
│  │  [4869] 23  跟 React 学设计模式：掌握编程“套路”，打造高质量应用.mp4
│  │  [4870] 结束语  聊聊 React 17，谈谈学习前端框架的心法.mp4
│  │  [5367] 14  ReactDOM.render 是如何串联渲染链路的？（中）.mp4
│  │  [5368] 15  ReactDOM.render 是如何串联渲染链路的？（下）.mp4
│  │  [5894] 21  从 React-Router 切入，系统学习前端路由解决方案.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：深度学习入门与实战
│  │  [4974] 开篇词  掌握深度学习，畅游 AI 时代.mp4
│  │  [4975] 01  从神经元说起：数学篇.mp4
│  │  [4976] 02  从神经元说起：结构篇.mp4
│  │  [4977] 03  AI 术语：让你变得更加专业.mp4
│  │  [4978] 04  函数与优化方法：模型的自我学习（上）.mp4
│  │  [4979] 05  前馈网络与反向传播：模型的自我学习（下）.mp4
│  │  [4980] 06  线性回归模型：在问题中回顾与了解基础概念.mp4
│  │  [4981] 07  卷积神经网络：给你的模型一双可以看到世界的眼睛.mp4
│  │  [4982] 08  RNN 与 LSTM：模型也可以持续不断地思考.mp4
│  │  [4983] 09  自编码器：让模型拥有属于自己的表达和语言.mp4
│  │  [4984] 10  生成式对抗网络：艺术创造也可以成为深度学习的拿手好戏.mp4
│  │  [4985] 11  集成、共享、敏捷：Jupyter Notebook 的使用.mp4
│  │  [4986] 12  数据预处理：让模型学得更好.mp4
│  │  [4987] 13  张量、数据流图与概念：初步了解 TenorFlow.mp4
│  │  [4988] 14  工作机制与流程：通过手写识别深入了解 TenorFlow.mp4
│  │  [4989] 15  TenorBoard：实验统计分析助手.mp4
│  │  [4990] 16  图像分类：技术背景与常用模型解析.mp4
│  │  [4991] 17  图像分类：实现你的第一个图像分类实战项目.mp4
│  │  [4992] 18  语义分割：技术背景与算法剖析.mp4
│  │  [4993] 19  语义分割：打造简单高效的人像分割模型.mp4
│  │  [4994] 20  文本分类：技术背景与经典网络结构介绍.mp4
│  │  [4995] 21  文本分类：用 Bert 做出一个优秀的文本分类模型.mp4
│  │  [4996] 结束语  掌握深度学习，搭上 AI 快车.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：玩转 Python 数据分析
│  │  [7134] 开篇词  数据赋能未来，Python 势不可挡.mp4
│  │  [7135] 课前基础  计算机运行一个程序的过程.mp4
│  │  [7136] 课前准备  搭建一个高效的 Python 开发环境.mp4
│  │  [7137] 01  Python 常用的变量与数据类型.mp4
│  │  [7138] 02  流程控制：如何控制代码执行的顺序？.mp4
│  │  [7139] 03  函数：快速实现代码的复用.mp4
│  │  [7140] 04  类与对象：更好地组织你的代码.mp4
│  │  [7141] 05  案例实战：日程管理小工具.mp4
│  │  [7142] 06  获取数据：公开数据集与 DIY 数据集.mp4
│  │  [7143] 07  下载网页：如何使用模拟请求下载真实的网页？.mp4
│  │  [7144] 08  提取数据：如何从网页中提取感兴趣的内容？.mp4
│  │  [7145] 09  保存数据：如何将爬取的数据保存成 CSV 格式.mp4
│  │  [7146] 10  实战：手把手教你构建国产电视剧评分数据集.mp4
│  │  [7148] 11  文件处理：如何读取多种文件（cvexcel）的数据？.mp4
│  │  [7149] 12  DataFrame：如何以表格的形式查看和操作数据？.mp4
│  │  [7150] 13  高级索引：过滤与查看表格中的局部数据.mp4
│  │  [7151] 14  数据清洗：表格数据缺失值与异常值的处理.mp4
│  │  [7152] 15  时间序列：时间数据的解析与应用.mp4
│  │  [7153] 16  案例实战：如何用 Python 分析电商用户行为？.mp4
│  │  [7155] 17  如何快速实现数据的批量计算？.mp4
│  │  [7156] 18  基础统计：如何统计数据的均值、方差等特征？.mp4
│  │  [7157] 19  回归分析：如何预测未来数据趋势？.mp4
│  │  [7158] 20  案例实战：电商用户对商品喜好的预测.mp4
│  │  [7160] 21  绘图基础：如何将表中的数据特征画成图？.mp4
│  │  [7161] 22  散点图与线图：如何展示不同特征之间的相关性？.mp4
│  │  [7162] 23  直方图、条形图和饼图：如何分析数据分布与占比？.mp4
│  │  [7163] 24  图像的脊柱、注解和图例：如何画出更专业的图表？.mp4
│  │  [7164] 25  Seaborn：实现用户可交互的图标.mp4
│  │  [7165] 26  案例实战：用图例可视化用户行为分析和喜好预测过程.mp4
│  │  [7166] 27  初识 EDA：全球新冠肺炎确诊病例趋势分析.mp4
│  │  [7168] 28  AI 落地实战：训练通用电影票房预测模型.mp4
│  │  [7169] 29  综合实战：网络服务用户流失预测与分析.mp4
│  │  [7170] 30  综合实战：国产电视剧评分预测与分析.mp4
│  │  [7171] 结束语  构建数据分析的技能树.mp4
│  │  [7484] 加餐  VS Code 新版 Notebook 使用指南.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：玩转 Serverless 架构
│  │  [6028] 开篇词  Serverle 大热，程序员面临的新机遇与挑战.mp4
│  │  [6029] 01  前因后果：Serverle 架构兴起的必然因素是什么？.mp4
│  │  [6030] 02  概念新知：到底什么是 Serverle.mp4
│  │  [6031] 03｜基础入门：编写你的第一个 Serverle 应用.mp4
│  │  [6032] 04  运行原理： Serverle 应用是怎么运行的？.mp4
│  │  [6033] 05  开发框架：如何提高应用开发调试和部署效率？.mp4
│  │  [6034] 06  依赖管理：Serverle 应用怎么安装依赖？.mp4
│  │  [6035] 07｜运行时：使用自定义运行时支持自定义编程语言.mp4
│  │  [6036] 08｜单元测试：Serverle 应用如何进行单元测试？.mp4
│  │  [6037] 09｜性能优化：如何提升 Serverle 应用的性能？.mp4
│  │  [6038] 10｜访问控制：如何授权访问其他云服务？.mp4
│  │  [6039] 11｜安全生产（一）：Serverle 安全的主要风险是什么？.mp4
│  │  [6040] 12  安全生产（二）：如何提高 Serverle 应用的安全性？.mp4
│  │  [6041] 13｜成本优化：Serverle 真的省钱吗？.mp4
│  │  [6042] 经验  送给你 N 条 Serverle 开发的实践经验.mp4
│  │  [6043] 15  身份认证：使用 Serverle 实现登录注册功能.mp4
│  │  [6044] 16  API：基于 Servele 构建弹性可扩展的 Retful API.mp4
│  │  [6045] 17  SSR：使用 React.j 开发 Serverle 服务端渲染应用.mp4
│  │  [6046] 18  数据处理：基于 Serverle 开发高可用音视频处理系统.mp4
│  │  [6047] 结束语  未来展望：Serverle 掀起新的前后端技术变革.mp4
│  │  [6048] 结课测试  关于 Serverle 这些知识，你都掌握了吗？.mp4
│  │  [6467] 14  系统迁移 传统应用如何迁移到 Serverle ？.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：由浅入深吃透 Docker
│  │  [4571] 开篇词  溯本求源，吃透 Docker！.mp4
│  │  [4572] 01  Docker 安装：入门案例带你了解容器技术原理.mp4
│  │  [4573] 02  核心概念：镜像、容器、仓库，彻底掌握 Docker 架构核心设计理念.mp4
│  │  [4574] 03  镜像使用：Docker 环境下如何配置你的镜像？.mp4
│  │  [4575] 04  容器操作：得心应手掌握 Docker 容器基本操作.mp4
│  │  [4576] 05  仓库访问：怎样搭建属于你的私有仓库？.mp4
│  │  [4577] 06  最佳实践：如何在生产中编写最优 Dockerfile？.mp4
│  │  [4578] 07  Docker 安全：基于内核的弱隔离系统如何保障安全性？.mp4
│  │  [4579] 08  容器监控：容器监控原理及 cAdvior 的安装与使用.mp4
│  │  [4580] 09  资源隔离：为什么构建容器需要 Namepace ？.mp4
│  │  [4581] 10  资源限制：如何通过 Cgroup 机制实现资源限制？.mp4
│  │  [4582] 11  组件组成：剖析 Docker 组件作用及其底层工作原理.mp4
│  │  [4583] 12  网络模型：剖析 Docker 网络实现及 Libnetwork 底层原理.mp4
│  │  [4584] 13  数据存储：剖析 Docker 卷与持久化数据存储的底层原理.mp4
│  │  [4585] 14  文件存储驱动：AUFS 文件系统原理及生产环境的最佳配置.mp4
│  │  [4586] 15  文件存储驱动：Devicemapper 文件系统原理及生产环境的最佳配置.mp4
│  │  [4587] 16  文件存储驱动：OverlayFS 文件系统原理及生产环境的最佳配置.mp4
│  │  [4588] 17  原理实践：自己动手使用 Golang 开发 Docker（上）.mp4
│  │  [4589] 18  原理实践：自己动手使用 Golang 开发 Docker（下）.mp4
│  │  [4590] 19  如何使用 Docker Compoe 解决开发环境的依赖？.mp4
│  │  [4591] 20  如何在生产环境中使用 Docker Swarm 调度容器？.mp4
│  │  [4592] 21  如何使 Docker 和 Kubernete 结合发挥容器的最大价值？.mp4
│  │  [4593] 22  多阶段构建：Docker 下如何实现镜像多阶级构建？.mp4
│  │  [4594] 23  DevOp：容器化后如何通过 DevOp 提高协作效能？.mp4
│  │  [4595] 24  CICD：容器化后如何实现持续集成与交付？（上）.mp4
│  │  [4596] 25  CICD：容器化后如何实现持续集成与交付？（下）.mp4
│  │  [4597] 结束语  展望未来：Docker 的称霸之路.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：社群运营增长与变现 22 讲
│  │  [1636] 开篇词：道理都懂，为啥做不好社群运营.mp4
│  │  [1637] 第01讲：社群运营演变的 3 个阶段 ：萌芽期－粗放期－精细化运营.mp4
│  │  [1638] 第02讲：社群运营新思维模式：C-ACM-MT 模型，全链路思考.mp4
│  │  [1639] 第03讲：社群运营新方法（一）：PMP 式社群运营法.mp4
│  │  [1641] 第17讲：案例实操  内容种草圈粉 10w，社群变现周销售额近 130w.mp4
│  │  [1645] 第18讲：案例实操｜在线教育行业社群运营实操案例.mp4
│  │  [1648] 第10讲：短命 or 长寿？这 4 种社群内容策略是决定性因素.mp4
│  │  [1649] 第19讲：案例实操｜女装店在双十一裂变，做促销、当晚破 103w.mp4
│  │  [1650] 第11讲：社群变现 6 大路径拆解，环环相扣、立竿见影.mp4
│  │  [1651] 第12讲：促成用户下单的 5 大成交公式，3 个维度提升转化率.mp4
│  │  [1652] 第13讲：CRM 式跟单技巧：3 种聊天剧本设计法，让用户乐意掏腰包.mp4
│  │  [1653] 第20讲：实操案例｜靠“读书”社群不断裂变，一年用户暴增 10 倍.mp4
│  │  [1654] 第14讲：一张“社群体检表”带你诊断社群健康度.mp4
│  │  [1655] 第15讲：4 个数据维度，帮你找到社群运营核心指标.mp4
│  │  [1656] 第16讲：0 门槛 10 分钟教你学会使用一款社群数据分析工具.mp4
│  │  [1657] 第21讲：实操案例｜设置诱饵裂变 100 位团长，每月配送生鲜 50w.mp4
│  │  [1658] 第22讲：案例实操｜借助 3 大流量工具，奶粉社群日均吸粉 2000 人.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：程序员的数学课
│  │  [5000] 开篇词  数学，编程能力的营养根基.mp4
│  │  [5001] 01  从计数开始，程序员必知必会的数制转换法.mp4
│  │  [5002] 02  逻辑与沟通，怎样才能讲出有逻辑的话？.mp4
│  │  [5003] 03  用数学决策，如何规划好投入、转化和产出？.mp4
│  │  [5004] 04  万物可数学，经典公式是如何在生活中应用的？.mp4
│  │  [5005] 05  求极值：如何找到复杂业务的最优解？.mp4
│  │  [5006] 06  向量及其导数：计算机如何完成对海量高维度数据计算？.mp4
│  │  [5007] 07  线性回归：如何在离散点中寻找数据规律？.mp4
│  │  [5008] 08  加乘法则：如何计算复杂事件发生的概率？.mp4
│  │  [5009] 09  似然估计：如何利用 MLE 对参数进行估计？.mp4
│  │  [5010] 10  信息熵：事件的不确定性如何计算？.mp4
│  │  [5011] 11  灰度实验：如何设计灰度实验并计算实验的收益？.mp4
│  │  [5012] 12  统计学方法：如何证明灰度实验效果不是偶然得到的？.mp4
│  │  [5013] 13  复杂度：如何利用数学推导对程序进行优化？.mp4
│  │  [5014] 14  程序的循环：如何利用数学归纳法进行程序开发？.mp4
│  │  [5015] 15  递归：如何计算汉诺塔问题的移动步数？.mp4
│  │  [5016] 16  二分法：如何利用指数爆炸优化程序？.mp4
│  │  [5017] 17  动态规划：如何利用最优子结构解决问题？.mp4
│  │  [5018] 18  AI 入门：利用 3 个公式搭建最简 AI 框架.mp4
│  │  [5019] 19  逻辑回归：如何让计算机做出二值化决策？.mp4
│  │  [5020] 20  决策树：如何对 NP 难复杂问题进行启发式求解？.mp4
│  │  [5021] 21  神经网络与深度学习：计算机是如何理解图像、文本和语音的？.mp4
│  │  [5022] 22  面试中那些坑了无数人的算法题.mp4
│  │  [5023] 23  站在生活的十字路口，如何用数学抉择？.mp4
│  │  [5024] 结束语  数学底子好，学啥都快.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：竞品分析实操手册
│  │  [8037] 开篇词  别再让你的竞品分析只是纸上谈兵.mp4
│  │  [8038] 01  竞品分析的目标究竟是什么？.mp4
│  │  [8039] 02  你的竞争对手选对了吗？.mp4
│  │  [8040] 03  什么是产品视角的分析维度？.mp4
│  │  [8041] 04  什么是用户视角的分析维度？.mp4
│  │  [8042] 05  你选择产品视角还是用户视角？.mp4
│  │  [8043] 06  如何收集竞争对手的信息？.mp4
│  │  [8044] 07  通过 SWOT 分析法，看美团优选的先天优势.mp4
│  │  [8045] 08  除了 SWOT 分析，另外 4 个常见的分析方法.mp4
│  │  [8046] 09  怎样输出一份营养丰富的竞品分析报告？.mp4
│  │  [8047] 10  如何在竞品分析的过程中发现真需求？.mp4
│  │  [8048] 11  竞品分析过后就是抄吗？.mp4
│  │  [8049] 12  跟踪竞品怎么帮我们做竞品分析？.mp4
│  │  [8050] 13  怎么用 AARRR 模型做运营策略的竞品分析？.mp4
│  │  [8051] 14  如何用博弈论制定出有竞争力的运营价格？.mp4
│  │  [8052] 15  产品差异化竞争的 5 个建议.mp4
│  │  [8053] 16  如何与竞争对手合作？.mp4
│  │  [8054] 17  什么是最高级的竞争？.mp4
│  │  [8055] 彩蛋  竞品思维提炼和总结.mp4
│  │  [8056] 期末测试  写一份竞品分析报告，并制定竞争策略.mp4
│  │  [8057] 结束语  互联网人应不应该考虑社会价值？.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：腾讯产品启示录
│  │  [143] 开篇寄语.mp4
│  │  [144] 第01讲：腾讯为何总能突破困境？.mp4
│  │  [145] 第02讲：如何做到产品进化式创新.mp4
│  │  [146] 第03讲：如何给你的产品做减法.mp4
│  │  [147] 第04讲：小团队如何做进化式创新.mp4
│  │  [148] 第05讲：不懂人性何谈产品.mp4
│  │  [149] 第06讲：如何打造一款有温度的产品.mp4
│  │  [150] 第07讲：如何让产品小步快跑.mp4
│  │  [151] 第08讲：人人都是增长黑客.mp4
│  │  [152] 第09讲：如何给产品注入你的价值观.mp4
│  │  [153] 彩蛋：微信红包改变支付格局的始末.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：腾讯敏捷项目管理实战
│  │  [3750] 开篇词  敏捷是互联网时代的超级管理术.mp4
│  │  [3751] 01  演化：腾讯的敏捷管理之路.mp4
│  │  [3752] 02  入门：你必须知道的敏捷内容.mp4
│  │  [3753] 03  量体：如何判断是否适合做敏捷转型？.mp4
│  │  [3754] 04  裁衣：如何使敏捷方法适合公司实情？.mp4
│  │  [3755] 05  启动：如何拥有敏捷思维？.mp4
│  │  [3756] 06  自组织：敏捷团队如何开展自组织？.mp4
│  │  [3757] 07  计划：如何制定一份好的迭代计划？.mp4
│  │  [3758] 08  执行和监控：如何使团队进展“透明化”？.mp4
│  │  [3759] 09  收尾：如何开展展示与回顾会？.mp4
│  │  [3760] 10  度量：如何度量敏捷团队的绩效？.mp4
│  │  [3761] 11  落地：如何从 0 到 1 导入敏捷？.mp4
│  │  [3762] 彩蛋  项目管理进阶之 ACP 认证攻略.mp4
│  │  [4316] 结束语  敏捷，实践出真知.mp4
│  │  [6103] 加餐  个人成长.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：解读你身边的经济学
│  │  [7794] 开篇词  掌握经济学思维，做个理性投资者.mp4
│  │  [7795] 01  中美贸易战的经过.mp4
│  │  [7796] 02  毁约理由：美国到底想要什么.mp4
│  │  [7797] 03  前车之鉴：日本和美国的贸易战.mp4
│  │  [7798] 04  战略博弈：美国的极限施压与中国的底线思维.mp4
│  │  [7799] 05  美国失败的原因（一）：特朗普的经济观.mp4
│  │  [7800] 06  美国失败的原因（二）：中国具有“比较优势”.mp4
│  │  [7801] 07  中国成功的原因：贸易战里的 5 大底牌.mp4
│  │  [7802] 08  贸易战影响：高额关税损害了谁的利益？.mp4
│  │  [7803] 09  贸易战经验：中国如何在贸易战中自保？.mp4
│  │  [7804] 10  作为企业家，如何积极应对贸易战？.mp4
│  │  [7805] 11  房价的“成长史”.mp4
│  │  [7806] 12  供求决定房价：楼市中看不见的手.mp4
│  │  [7807] 13  买房参考：请选择稀缺性房源.mp4
│  │  [7808] 14  买住宅不得不考虑的因素.mp4
│  │  [7809] 15  投资商铺和写字楼，你需要考虑哪些因素？.mp4
│  │  [7810] 16  房屋买卖：请务必重视机会成本.mp4
│  │  [7811] 17  买房还是租房，哪个更适合你？.mp4
│  │  [7812] 18  个人买房：选择“眼见为实”的现房.mp4
│  │  [7813] 19  政府为何要对楼市进行宏观调控.mp4
│  │  [7814] 20  中国会推出房地产税吗？.mp4
│  │  [7815] 21  警惕房地产泡沫的破灭.mp4
│  │  [7816] 22  炒股一定要懂的经济学知识.mp4
│  │  [7817] 23  为什么会出现股票？.mp4
│  │  [7818] 24  英美资本市场的“发家史”.mp4
│  │  [7819] 25  股市是如何运行的？.mp4
│  │  [7820] 26  证券交易所的作用.mp4
│  │  [7821] 27  如何看懂股价指数，判断股市走势？.mp4
│  │  [7822] 28  股市的投资理念：投资不代表投机.mp4
│  │  [7823] 29  参与股市投资的 5 种方式.mp4
│  │  [7825] 30  普通人炒股应该注意什么？.mp4
│  │  [7826] 31  警惕泡沫经济（一）：郁金香泡沫给欧洲经济带来的灾难.mp4
│  │  [7827] 32  警惕泡沫经济（二）：1929 年美国股灾的大崩盘.mp4
│  │  [7828] 33  警惕泡沫经济（三）：2007 年中国股市的暴涨.mp4
│  │  [7829] 34  警惕泡沫经济（四）：2015 年中国股市的大缩水.mp4
│  │  [7830] 35  如何判断中国股市未来的走势？.mp4
│  │  [7831] 36  普通人也要了解的汇率知识.mp4
│  │  [7832] 37  人民币升值对我们有什么影响？.mp4
│  │  [7833] 38  欧元是怎样诞生的？.mp4
│  │  [7834] 39  美元霸权的前世今生.mp4
│  │  [7835] 40  人民币的未来走势和国际化之路.mp4
│  │  [7842] 彩蛋 1  面对疫情，各国的救市措施.mp4
│  │  [7843] 彩蛋 2  疫情下的中国经济.mp4
│  │  [7844] 结束语  把知识变成能力，把精力变成财富.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：说透性能测试
│  │  [6150] 开篇词  为什么每个测试人都要学好性能测试？.mp4
│  │  [6151] 课前导读  性能测试全流程，你需要注意什么？.mp4
│  │  [6152] 01  JMeter 的核心概念.mp4
│  │  [6153] 02  JMeter 参数化策略.mp4
│  │  [6154] 03  构建并执行 JMeter 脚本的正确姿势.mp4
│  │  [6155] 04  JMeter 二次开发其实并不难.mp4
│  │  [6156] 05  如何基于 JMeter API 开发性能测试平台？.mp4
│  │  [6157] 06  Nginx 在系统架构中的作用.mp4
│  │  [6158] 07  你真的知道如何制定性能测试的目标吗？.mp4
│  │  [6159] 08  性能测试场景的分类和意义.mp4
│  │  [6160] 09  如何制定一份有效的性能测试方案？.mp4
│  │  [6161] 10  命令行监控 Linux 服务器的要点.mp4
│  │  [6162] 11  分布式服务链路监控以及报警方案.mp4
│  │  [6163] 12  如何把可视化监控也做得酷炫？.mp4
│  │  [6164] 13  Docker 的制作、运行以及监控.mp4
│  │  [6165] 14  如何从 CPU 飙升定位到热点方法？.mp4
│  │  [6166] 15  如何基于 JVM 分析内存使用对象？.mp4
│  │  [6167] 16  如何通过 Artha 定位代码链路问题？.mp4
│  │  [6168] 17  如何应对 Redi 缓存穿透、击穿和雪崩？.mp4
│  │  [6169] 18  如何才能优化 MySQL 性能？.mp4
│  │  [6170] 19  如何根治慢 SQL？.mp4
│  │  [6171] 结束语  线上全链路性能测试实践总结.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：趣学设计模式
│  │  [6861] 开篇词  设计模式：程序员的基本功，你离及格还差多少？.mp4
│  │  [6862] 01  学习思维：怎样才能学好 Java 设计模式？.mp4
│  │  [6863] 02  组合思维：Unix 哲学到底给现代编程带来哪些重要启示？.mp4
│  │  [6864] 03  分层思维：为什么要做代码分层架构？.mp4
│  │  [6865] 04  工程思维：如何用软件工程方法解决开发难题？.mp4
│  │  [6866] 05  对象思维：面向对象编程有哪些优势？.mp4
│  │  [6867] 06  迭代思维：如何高效编程？.mp4
│  │  [6868] 07  单一原则：如何跳出错误抽象的误区？.mp4
│  │  [6869] 08  简单原则：如何写出“简单”代码？.mp4
│  │  [6870] 09  最少原则：如何实现“最少知识”代码？.mp4
│  │  [6871] 10  表达原则：如何让源代码成为一种逻辑线索？.mp4
│  │  [6872] 11  职责原则：如何在代码设计中实现职责分离？.mp4
│  │  [6877] 12  面向对象原则：面向对象编程框架到底长什么样？.mp4
│  │  [6878] 13  反转原则：如何减少代码间的相互影响？.mp4
│  │  [6879] 14  惯例原则：如何提升编程中的沟通效率？.mp4
│  │  [6880] 15  分离原则：如何将复杂问题拆分成小问题？.mp4
│  │  [6881] 16  契约原则：如何做好 API 接口设计？.mp4
│  │  [6882] 17  单例模式：如何有效进行程序初始化？.mp4
│  │  [6883] 18  建造者模式：如何创建不同形式的复杂对象？.mp4
│  │  [6884] 19  抽象工厂模式：如何统一不同代码风格下的代码级别？.mp4
│  │  [6885] 20  工厂方法模式：如何解决生成对象时的不确定性？.mp4
│  │  [6886] 21  原型模式：什么场景下需要用到对象拷贝？.mp4
│  │  [6887] 22  适配器模式：如何处理不同 API 接口的兼容性？.mp4
│  │  [6888] 23  桥接模式：如何实现抽象协议与不同实现的绑定？.mp4
│  │  [6889] 24  组合模式：如何用树形结构处理对象之间的复杂关系？.mp4
│  │  [6890] 25  装饰模式：如何在基础组件上扩展新功能？.mp4
│  │  [6891] 26  门面模式：如何实现 API 网关的高可用性？.mp4
│  │  [6892] 27  享元模式：如何通过共享对象减少内存加载消耗？.mp4
│  │  [6893] 28  代理模式：如何控制和管理对象的访问？.mp4
│  │  [6894] 29  访问者模式：如何实现对象级别的矩阵结构？.mp4
│  │  [6895] 30  模板方法模式：如何实现同一模板框架下的算法扩展？.mp4
│  │  [6896] 31  策略模式：如何解决不同活动策略的营销推荐场景？.mp4
│  │  [6897] 32  状态模式：如何通过有限状态机监控功能的“状态变化”？.mp4
│  │  [6898] 33  观察者模式：如何发送消息变化的通知？.mp4
│  │  [6899] 34  备忘录模式：如何在聊天会话中记录历史消息？.mp4
│  │  [6900] 35  中介者模式：如何通过中间层来解决耦合过多的问题？.mp4
│  │  [6901] 36  迭代器模式：如何实现遍历数据时的职责分离？.mp4
│  │  [6902] 37  解释器模式：如何实现一个自定义配置规则功能？.mp4
│  │  [6903] 38  命令模式：如何在一次请求中封装多个参数？.mp4
│  │  [6904] 39  责任链模式：如何解决审核、过滤场景问题？.mp4
│  │  [6905] 结束语  扬帆起航，从心开始.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：软件架构场景实战 22 讲
│  │  [5927] 开篇词  学好软件架构，先从场景入手.mp4
│  │  [5928] 01  冷热分离：表数据量大读写缓慢如何优化？.mp4
│  │  [5929] 02  查询分离：表数据量大查询缓慢如何优化？.mp4
│  │  [5930] 03  Elaticearch 注意要点：这三点你不得不知.mp4
│  │  [5931] 04  分表分库：单表数据量大读写缓慢如何解决？.mp4
│  │  [5932] 05  读缓存：如何减少数据库读操作压力？.mp4
│  │  [5933] 06  写缓存：如何节省数据库写操作资源？.mp4
│  │  [5934] 07  数据收集：高频数据收集请求如何不影响主业务？.mp4
│  │  [5935] 08  秒杀架构：设计秒杀架构必知必会的那些事.mp4
│  │  [5936] 09  注册发现：如何对后台服务进行高效管理？.mp4
│  │  [5937] 10  全链路日志：这个请求到底经历了什么？.mp4
│  │  [5938] 11  熔断：如何预防一个服务故障崩掉整个系统？.mp4
│  │  [5939] 12  限流：如何保障服务器承受亿级流量？.mp4
│  │  [5940] 13  微服务的痛：用实际经历告诉你它有多坑（一）.mp4
│  │  [5941] 14  微服务的痛：用实际经历告诉你它有多坑（二）.mp4
│  │  [5942] 15  微服务的痛：用实际经历告诉你它有多坑（三）.mp4
│  │  [5943] 16  数据一致性：下游服务失败上游服务如何独善其身？.mp4
│  │  [5944] 17  数据同步：如何解决微服务之间的数据依赖问题？.mp4
│  │  [5945] 18  BFF：如何处理好微服务之间千丝万缕的关系？.mp4
│  │  [5946] 19  接口 Mock：第三方服务还没好，功能设计如何继续？.mp4
│  │  [5947] 20  一人一套测试环境：测试环境何时能释放出来使用？.mp4
│  │  [5948] 结束语  如何成为老板不可或缺的人？.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：运维高手的36项修炼
│  │  [1545] 开篇词：运维开发架构师的晋级之路.mp4
│  │  [1546] 第01讲：工作累积的最常用 Shell 命令合集及使用技巧.mp4
│  │  [1547] 第02讲（上）：企业 Nginx 高性能优化配置实战总结.mp4
│  │  [1548] 第03讲（上）：Nginx 负载均衡常见架构及问题解析.mp4
│  │  [1549] 第04课：入口网关服务注册发现-Openrety 动态 uptream.mp4
│  │  [1550] 第05课：Curl 命令最常见使用方式及案例.mp4
│  │  [1551] 第06课：系统性能验收：Unixbench、FIO 性能压测.mp4
│  │  [1552] 第07课：基于 Django_crontab、Xadmin 做一套定时任务管理系统.mp4
│  │  [1553] 第08课：Shell 如何来实现系统初始化.mp4
│  │  [1554] 第09课：搭建基于 Jenkin 的持续集成平台所需关注的几个问题.mp4
│  │  [1555] 第10课：基于 Python+Anible+Django 搭建 CMDB 平台.mp4
│  │  [1556] 第11课：基于 Python+Anible+Django 搭建自动化任务平台.mp4
│  │  [1557] 第12课：基于 K8S 架构下打造 CICD 平台的核心思路.mp4
│  │  [1558] 第13课：网站割接必须掌握的 N 个检查项及命令.mp4
│  │  [1559] 第14课：割接关键思路解析：停服维护、无缝升级如何设计.mp4
│  │  [1560] 第15课：服务向 Kubernete 容器平台迁移必须了解的事情.mp4
│  │  [1561] 第16课：典型系统故障：快速排错操作系统问题进程.mp4
│  │  [1562] 第17课：磁盘数据恢复：rm -rf 误删数据，如何进行数据恢复.mp4
│  │  [1563] 第18课：典型网络故障：选择长连接 or 短连接，大量 Timewait 的产生时如何处理？.mp4
│  │  [1564] 第19课：网络故障分析（ping、mtr、traceroute）与抓包分析（tcpdump）诊断.mp4
│  │  [1565] 第20课：Linux 系统快速分析日志定位故障原因的 10 个方法.mp4
│  │  [1566] 第21课：Shell 脚本如何作日志分析.mp4
│  │  [1567] 第22课：ELK 构建 MySQL 慢日志收集平台详解.mp4
│  │  [1568] 第23课：操作系统紧急故障修复常见有效方案.mp4
│  │  [1569] 第24课：Zabbix 自动发现和自动注册.mp4
│  │  [1570] 第25课：容器监控实践：Prometheu、Grafana 方案介绍.mp4
│  │  [1571] 第26课：防火墙：iptable 企业级安全策略.mp4
│  │  [1572] 第27课：应用安全：基于 HTTP、HTTPS 请求过程中常见 waf 攻防策略.mp4
│  │  [1573] 第28课：防洪安全：DDoS 的原理分析及攻防策略.mp4
│  │  [1574] 第29课：虚拟化关键技术浅析（NUMA、dpdk、绑核）.mp4
│  │  [1575] 第30课：k8 主流网络方案（OVS、Flannel、Calico）及原理.mp4
│  │  [1576] 第31课：4、7 层入口负载均衡 SLB 如何作才是最佳姿势.mp4
│  │  [1577] 第32课：浅析多可用区容灾、多活到两地三中心的架构.mp4
│  │  [1578] 第33课：云原生关键技术浅析.mp4
│  │  [1579] 第34课：分析 Anycat 应用程度及场景.mp4
│  │  [1580] 第35课：HTTP2.0 在 Nginx 的实践.mp4
│  │  [1581] 第36课：IPv6 特性及当前应用程度介绍.mp4
│  │  [1584] 第02讲（下）：企业 Nginx 高性能优化配置实战总结.mp4
│  │  [1660] 第03讲（下）：Nginx 负载均衡常见架构及问题解析.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：重学操作系统
│  │  [4604] 开篇词  为什么大厂面试必考操作系统？.mp4
│  │  [4605] 01  计算机是什么：“如何把程序写好”这个问题是可计算的吗？.mp4
│  │  [4607] 课前必读  构建知识体系，可以这样做！.mp4
│  │  [4608] 02  程序的执行：相比 32 位，64 位的优势是什么？（上）.mp4
│  │  [4609] 04  构造复杂的程序：将一个递归函数转成非递归函数的通用方法.mp4
│  │  [4610] 05  存储器分级：L1 Cache 比内存和 SSD 快多少倍？.mp4
│  │  [4611] 加餐  练习题详解（一）.mp4
│  │  [4612] 06  目录结构和文件管理指令：rm  -rf 指令的作用是？.mp4
│  │  [4613] 07  进程、重定向和管道指令：xarg 指令的作用是？.mp4
│  │  [4614] 08  用户和权限管理指令： 请简述 Linux 权限划分的原则？.mp4
│  │  [4615] 09  Linux 中的网络指令：如何查看一个域名有哪些 NS 记录？.mp4
│  │  [4616] 10  软件的安装： 编译安装和包管理器安装有什么优势和劣势？.mp4
│  │  [4617] 11  高级技巧之日志分析：利用 Linux 指令分析 Web 日志.mp4
│  │  [4618] 12  高级技巧之集群部署：利用 Linux 指令同时在多台机器部署程序.mp4
│  │  [4619] 加餐  练习题详解（二）.mp4
│  │  [4620] 13  操作系统内核：Linux 内核和 Window 内核有什么区别？.mp4
│  │  [4621] 14  用户态和内核态：用户态线程和内核态线程有什么区别？.mp4
│  │  [4622] 15  中断和中断向量：Javaj 等语言为什么可以捕获到键盘输入？.mp4
│  │  [4623] 16  WinMacUnixLinux 的区别和联系：为什么 Debian 漏洞排名第一还这么多人用？.mp4
│  │  [4624] 加餐  练习题详解（三）.mp4
│  │  [4625] 17  进程和线程：进程的开销比线程大在了哪里？.mp4
│  │  [4626] 18  锁、信号量和分布式锁：如何控制同一时间只有 2 个线程运行？.mp4
│  │  [4627] 19  乐观锁、区块链：除了上锁还有哪些并发控制方法？.mp4
│  │  [4628] 20  线程的调度：线程调度都有哪些方法？.mp4
│  │  [4629] 21  哲学家就餐问题：什么情况下会触发饥饿和死锁？.mp4
│  │  [4630] 22  进程间通信： 进程间通信都有哪些方法？.mp4
│  │  [4631] 23  分析服务的特性：我的服务应该开多少个进程、多少个线程？.mp4
│  │  [4632] 加餐  练习题详解（四）.mp4
│  │  [4633] 24  虚拟内存 ：一个程序最多能使用多少内存？.mp4
│  │  [4634] 25  内存管理单元： 什么情况下使用大内存分页？.mp4
│  │  [4635] 26  缓存置换算法： LRU 用什么数据结构实现更合理？.mp4
│  │  [4636] 27  内存回收上篇：如何解决内存的循环引用问题？.mp4
│  │  [4637] 28  内存回收下篇：三色标记-清除算法是怎么回事？.mp4
│  │  [4638] 加餐  练习题详解（五）.mp4
│  │  [4639] 29  Linux 下的各个目录有什么作用？.mp4
│  │  [4640] 30  文件系统的底层实现：FAT、NTFS 和 Ext3 有什么区别？.mp4
│  │  [4641] 31  数据库文件系统实例：MySQL 中 B 树和 B+ 树有什么区别？.mp4
│  │  [4642] 32  HDFS 介绍：分布式文件系统是怎么回事？.mp4
│  │  [4643] 加餐  练习题详解（六）.mp4
│  │  [4644] 33  互联网协议群（TCPIP）：多路复用是怎么回事？.mp4
│  │  [4645] 34  UDP 协议：UDP 和 TCP 相比快在哪里？.mp4
│  │  [4646] 35  Linux 的 IO 模式：electpollepoll 有什么区别？.mp4
│  │  [4647] 36  公私钥体系和网络安全：什么是中间人攻击？.mp4
│  │  [4648] 加餐   练习题详解（七）.mp4
│  │  [4649] 37  虚拟化技术介绍：VMware 和 Docker 的区别？.mp4
│  │  [4650] 38  容器编排技术：如何利用 K8 和 Docker Swarm 管理微服务？.mp4
│  │  [4651] 39  Linux 架构优秀在哪里.mp4
│  │  [4652] 40  商业操作系统：电商操作系统是不是一个噱头？.mp4
│  │  [4653] 加餐  练习题详解（八）.mp4
│  │  [4654] 结束语  论程序员的发展——信仰、选择和博弈.mp4
│  │  [4680] 03  程序的执行：相比 32 位，64 位的优势是什么？（下）.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：重学数据结构与算法
│  │  [3329] 开篇词  数据结构与算法，应该这样学！.mp4
│  │  [3339] 01  复杂度：如何衡量程序运行的效率？.mp4
│  │  [3340] 02  数据结构：将“昂贵”的时间复杂度转换成“廉价”的空间复杂度.mp4
│  │  [3341] 03  增删查：掌握数据处理的基本操作,以不变应万变.mp4
│  │  [3342] 04  如何完成线性表结构下的增删查？.mp4
│  │  [3343] 05  栈：后进先出的线性表，如何实现增删查？.mp4
│  │  [3344] 06  队列：先进先出的线性表，如何实现增删查？.mp4
│  │  [3345] 07  数组：如何实现基于索引的查找？.mp4
│  │  [3346] 08  字符串：如何正确回答面试中高频考察的字符串匹配算法？.mp4
│  │  [3347] 09  树和二叉树：分支关系与层次结构下，如何有效实现增删查？.mp4
│  │  [3348] 10  哈希表：如何利用好高效率查找的“利器”？.mp4
│  │  [3349] 11  递归：如何利用递归求解汉诺塔问题？.mp4
│  │  [3350] 12  分治：如何利用分治法完成数据查找？.mp4
│  │  [3351] 13  排序：经典排序算法原理解析与优劣对比.mp4
│  │  [3352] 14  动态规划：如何通过最优子结构，完成复杂问题求解？.mp4
│  │  [3353] 15  定位问题才能更好地解决问题：开发前的复杂度分析与技术选型.mp4
│  │  [3354] 16  真题案例（一）：算法思维训练.mp4
│  │  [3355] 17  真题案例（二）：数据结构训练.mp4
│  │  [3356] 18  真题案例（三）：力扣真题训练.mp4
│  │  [3357] 19  真题案例（四）：大厂真题实战演练.mp4
│  │  [3358] 20  代码之外，技术面试中你应该具备哪些软素质？.mp4
│  │  [3359] 21  面试中如何建立全局观，快速完成优质的手写代码？.mp4
│  │  [4314] 结束语  勤修内功，构建你的核心竞争力.mp4
│  │  [4510] 加餐  课后练习题详解.mp4
│  │  
│  └─文档
│          文档.zip
│          
├─拉勾：高性能MySQL实战
│  │  [47] 开篇寄语：建立完整的MySQL知识体系.mp4
│  │  [48] 第01讲：MySQL体系结构与存储引擎.mp4
│  │  [49] 第02讲：深入理解事务与锁机制（上）.mp4
│  │  [50] 第02讲：深入理解事务与锁机制（下）.mp4
│  │  [51] 第03讲：高性能数据库表该如何设计？.mp4
│  │  [52] 第04讲：高性能索引该如何设计（上）.mp4
│  │  [53] 第04讲：高性能索引该如何设计（下）.mp4
│  │  [54] 第05讲：如何提高查询性能？.mp4
│  │  [55] 第06讲：如何突破单库性能瓶颈？.mp4
│  │  [56] 第07讲：如何做到MySQL的高可用？.mp4
│  │  [57] 第08讲：搭建稳固的MySQL运维体系.mp4
│  │  [58] 第09讲：如何做到MySQL高扩展性？.mp4
│  │  [68] 第10讲：海量数据MySQL项目实战.mp4
│  │  
│  └─文档
│          文档.zip
│          
└─拉勾：高效敏捷测试 49 讲
    │  [1585] 开篇词：重剑无锋、大道至简.mp4
    │  [1586] 第01讲：究竟什么是敏捷测试？.mp4
    │  [1587] 第02讲：通过案例全面比较传统测试与敏捷测试.mp4
    │  [1588] 第03讲：敏捷测试思维方式.mp4
    │  [1589] 第04讲：敏捷测试流程解析.mp4
    │  [1590] 第05讲：仅有的两本敏捷测试的图书是如何误导我们的？.mp4
    │  [1591] 第06讲：敏捷团队究竟要不要专职的测试人员？.mp4
    │  [1592] 第07讲：如果有专职的敏捷测试人员，他们的职责是什么？.mp4
    │  [1593] 第08讲：借助 Tet Owner 角色，完成团队转型？.mp4
    │  [1594] 第09讲：如何构建有强烈质量意识的学习型组织？.mp4
    │  [1595] 第10讲：如何更好地为测试而学？.mp4
    │  [1596] 第11讲：产品、测试与开发如何协作？.mp4
    │  [1597] 第12讲：持续交付（CD）与持续集成（CI）意味着什么？.mp4
    │  [1598] 第13讲：测试如何融入 CICD 环境中？.mp4
    │  [1599] 第14讲：基于 DevOp 的测试基础设施构成.mp4
    │  [1600] 第15讲：虚拟机技术与容器技术的应用.mp4
    │  [1601] 第16讲：测试四象限与金字塔模型.mp4
    │  [1602] 第17讲：如何完成全自动的部署和 BVT？（上）.mp4
    │  [1603] 第18讲：增加自动的静态测试和测试报告生成功能.mp4
    │  [1604] 第19讲：搭建敏捷自动化测试框架及其案例分析.mp4
    │  [1605] 第20讲：没有 ATDD，就没有用户故事的可测试性.mp4
    │  [1606] 第21讲：产品价值分析：商业画布、影响地图、故事地图.mp4
    │  [1607] 第22讲：从 Epic 到 Uer Story 完成需求评审.mp4
    │  [1608] 第23讲：不可忽视的设计评审.mp4
    │  [1609] 第24讲：BDD 及其自动化实践.mp4
    │  [1610] 第25讲：再往前一步，让实例化需求（RBE）落地.mp4
    │  [1611] 第26讲：基于上下文驱动思维的测试分析.mp4
    │  [1612] 第27讲：如何培养自己的业务与用户体验分析技能？.mp4
    │  [1613] 第28讲：敏捷测试风险在哪里？.mp4
    │  [1614] 第29讲：启发式测试策略与测试策略制定.mp4
    │  [1615] 第30讲：代码依赖性分析与精准测试.mp4
    │  [1616] 第31讲：敏捷测试要不要计划？.mp4
    │  [1617] 第32讲：探索式测试与基于脚本的测试.mp4
    │  [1618] 第33讲：如何采用 SBTM：从 Miion 到 Seion？.mp4
    │  [1619] 加餐2：敏捷测试分析与计划的案例.mp4
    │  [1620] 第35讲：正确理解 DoD 与敏捷中的验收测试.mp4
    │  [1621] 第36讲：如何将用户故事转化为测试用例？.mp4
    │  [1622] 第37讲：敏捷开发中基于场景事件流的用例设计.mp4
    │  [1623] 第38讲：探索式测试的设计与执行：扮演角色、场景挖掘.mp4
    │  [1624] 第39讲：测试自动化设计模式：一步到位.mp4
    │  [1625] 第40讲：脚本开发、调试与维护的常用技巧.mp4
    │  [1626] 第41讲：质效合一：自动化测试和手工测试的完美融合.mp4
    │  [1627] 第42讲：单元测试必须 TDD 吗？.mp4
    │  [1628] 第43讲：优先实现面向接口的测试.mp4
    │  [1629] 第44讲：大数据+AI 系统的测试设计与执行.mp4
    │  [1630] 第45讲：测试右移：在线测试与日志分析.mp4
    │  [1631] 第46讲：如何分析测试结果和评估测试工作的质量？.mp4
    │  [1632] 第47讲：如何获得良好的（测试与质量）可追溯性、可视化.mp4
    │  [1633] 第48讲：敏捷测试优秀实践.mp4
    │  [1634] 第49讲：敏捷过程的反思与持续改进.mp4
    │  [1889] 第17讲：如何完成全自动的部署和 BVT？（下）.mp4
    │  [2034] 加餐1：搭建基于 K8 和 Docker 的 Jenkin 可伸缩持续集成系统.mp4
    │  [3165] 第34讲：一个应用 SBTM 的真实案例.mp4
    │  
    └─文档
            文档.zip