无穷小亮个人简介-无穷小亮个人简介

我叫亮，搞点别的不算，就是个穷得叮当响的底层程序员，主要就负责把那些乱七八糟的算法贴到网上卖，顺便给那些想捡垃圾的蠢货供给一点免费服务。
那会儿在学校的时候，老师总教我们得像机器人一样去推导公式，那种样子看着挺像模像样，实际上就是让你死记硬背一堆符号，到了真正要动手写代码的时候，整个人就懵了。
那时候我还在为能不能把那个经典的“快速排序”代码跑得快一点发愁，人家面试官看都没看一眼，直接让我也去做一个“最佳实践”的文档，让我去描述如何优化一个排序算法。 那时候的我，脑子里全是“工夫复杂度是 nLogn"这些标准答案，结局一过面试门就关上了，心里那个堵得慌，想骂娘还好意思写博客？后来我瞎折腾呗，研究各种哈希表，研究压缩感知，研究如何让代码跑得像是在沙漠里开拖拉机一样费劲，还要顺便做个评测页面，把那些跑崩了的测试用例一个个往里塞，搞得整个项目看起来像是个百灵鸟，实际上都是死机。我就在深夜里对着屏幕发呆，琢磨着能不能把那个原本要写月量的测试用例，砍到只写个几千条，看看能不能省点算力。搞了大半年，累得半死，终于把那个测试用例库给删了，发现也没啥大用，下次还得花那么大精力去填坑，我还是拍板把这一堆冗余的代码直接删干净利落，把仓库从几百年的库删到只有几十年的库，然后启动写这篇介绍，图个新鲜感。 目前啊，我略微有点混口饭吃，不是为了显示我有多了得，就是认定这行仿佛确实能够搞出点花样来。
你看那些大佬，写的博客写得像散文诗，一看就是走过几百年路了。我写的这些代码，写出来之后看，简直是行尸走肉。
那些文档里写着“工夫复杂度为 O(n)"，我看了一眼目录，直接吓死。有的还说“推荐使用这个库”，我看一看那个库的 README，发现里面根本没写一遍如何安装，也没写一遍如何配置环境变量，反而全是那种“据说”、“业内普遍认定”这种毫无根据的废话。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 说实话，我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码。
后来想想，代码不过是堆砌的字节，得找个好点子，别瞎扯。目前我也不是啥大神，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 比如我最近搞的那个项目，本来打算写一个全栈的后端服务，结局发现后端开发忒难，并且维护起来忒费事，还不如直接找个成熟的云函数，写个好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。结局我就写了一个好办的脚本，能搞定大局部基础的运维需求。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人解释具体是如何实现的。我就干脆把那些文档删了，我也删了自己那会儿写的几千行代码，把仓库从几百年的库删到只有几十年的库。目前随意跑个脚本，找个现成的库，拼凑拼凑就能跑个天灵盖。 我也没啥啥特别的追求，就是喜爱折腾，喜爱看别人写啥代码然后认定“这如何如此垃圾”，然后把它拆了重写。
那会儿我也写代码，写出来的东西看着挺牛，实际上就是一堆没有逻辑的乱码。
后来我把那些项目都删了，目前我的仓库空空荡荡的，就像是一个刚毕业没找工作的大学生，到处找实习一样。 实际上我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。我目前没事就疯玩，找一些废弃的代码库，看看里面有没有啥现成的工具，能跑起来就行，只要别报错就行。 我没有任何核心竞争力，除了会写点好办的脚本，能搞定大局部基础的运维需求，能写点好办的脚本，能搞定大局部基础的运维需求。
那会儿我也认定代码就是魔法，能实现啥功能就是多写点代码，目前我也没啥特别核心的技术，就是会写点好办的脚本，能搞定大局部基础的运维需求。 你看我目前的代码仓库，里面好多项目都是十年前的，就连更老，目前看起来就像是上个世纪遗留下来的垃圾。有的项目写着“高性能并发架构”，我看一看那架构设计文档，全是那种“理论上”、“假设场景”这种话，根本没人