跳到主要内容

架构拾遗(1)——新手必看!白话拆解开发模型方法论

· 阅读需 31 分钟

在之前的文章里,我们从计算机的发展唠起,聊了聊软件开发模型那些事儿。不管是老派但经典的瀑布模型、V模型,还是现在互联网公司几乎都在用地Scrum、DevOps模型,都简单过了一遍。

后台有不少刚入行的朋友私信我,说自己刚毕业小半年,干软件开发也才摸门儿,看着这些“方法论”总觉得飘在天上,太空洞了,完全对应不上自己每天写代码、改bug、开小会的具体工作,越看越懵,甚至怀疑这些模型是不是纸上谈兵。

其实真不怪大家,不是我们理解能力不够,是很多讲解都太官方,没结合咱们实际干活的场景。

所以本篇文章,我就彻底放下专业术语,结合咱们实际工作中的角色、每天要做的活儿、要扛的责任,把开发模型和咱们的日常工作绑在一起讲,保证新手也能看明白、用得上,再也不觉得这些方法论是“废话”。

先从最常用的V模型入手,一步步拆明白​

咱们先从大家最容易混淆、也最常用的V模型说起。毕竟很多公司,尤其是传统软件公司、刚起步的小团队,都在用这个模型,新手接触最多。

先给大家划个重点,V模型的核心就是先想清楚、设计好,再动手干,干完再一步步测。整个流程像个V字,一边是分析设计,一边是测试验证,对应得明明白白。

具体流程分为:需求分析、系统设计、详细设计、编码、单元测试、集成测试、系统测试、验收测试。

第一步:需求分析——先搞懂用户到底想要啥​

V模型的第一步,是需求分析。说句实在的,不管你用哪种开发模型,第一步基本都是干这个,就像盖房子先定图纸,总不能没搞清楚要盖平房还是楼房,就直接挖地基吧?

在标准一点的团队里,这活儿一般是需求工程师来干。收到客户的需求,比如客户说“我要一个能统计销量的系统”,或者公司内部的需求,比如产品说“咱们得加个用户登录的功能”,先坐下来琢磨琢磨。

这个需求到底要做啥、范围有多大,是只统计销量,还是还要生成报表?能不能实现,技术上有没有坑?要花多少功夫,几个人干多久能做完?琢磨完了,会写一份“需求分析文档”存起来,相当于给后续所有工作定个“总规矩”。

这一步的核心,就俩字:搞懂。搞懂用户到底想要啥。

很多时候你会发现,用户自己都没搞懂自己想要啥!比如客户说“我要一个好用的APP”,“好用”到底是啥意思?加载快?界面简单?还是功能多?他也说不清楚。

这也是为啥会有原型模型,这个模型本质就是先画个简单的界面、做个半成品,让客户先看看,看完再改,避免后期返工。

这里给新手一个小建议,用比较直白的话来说:把客户,或者提需求的产品经理,当成“不懂技术的傻子”。别跟他说“接口”“表结构”“逻辑”这些专业词,就用最接地气的话聊。

比如客户说要“统计销量”,你就问:“是只看每天的总销量,还是要分产品、分区域看?要不要导出Excel?能不能手动修改数据?”

多问几句,把模糊的需求变具体,后期能少走很多弯路。

当然,需求工程师也不是万能的。要是碰到涉及开发范围的疑问,比如“这个统计功能要对接第三方接口,能不能实现?”,就会喊研发工程师过来一起评估。要是团队比较小,没专门的需求工程师,这活儿就会落到研发负责人或者老工程师身上。毕竟他们懂技术,能判断可行性。

总结一下,需求分析做完,一定要输出三个核心结论:能不能实现(可行性)、要花多少功夫(多少人做多久)、最后要做成啥样(交付件),缺一不可。

关键提醒:开发模型≠管理模型,别死套理论​

按V模型的理论来说,需求评估完,确认能做,就该进入设计阶段了。但新手一定要记住一个关键,V模型只是开发模型,管的是“怎么开发”,不是“怎么管理”。也就是说,理论归理论,实际干活的时候,还得看进度、看资源。

举个你们肯定碰到过的例子,需求评估完,预估要两个研发干一个月,但现在你们团队正在赶当前版本的其他需求,天天加班都忙不完,哪有精力搞新需求的设计?所以这种情况下,就不会马上进入设计阶段,得等当前版本的需求开发完、测试通过,腾出人手了,才会开始新需求的设计。

这也是很多新手困惑的地方,为啥我照着开发模型干活,总觉得不对劲、不顺畅?不是模型没用,是你忽略了一个软件产品的开发,不只有“开发”这一件事,还有产品管理、资源分配、进度把控这些杂事。

比如UP模型(统一过程模型),就专门加了发布里程碑的环节,把产品管理的内容融入进去了,比V模型更贴近咱们实际的开发生命周期。不过这个模型相对复杂,小团队一般用不上,新手先吃透V模型就够了。

设计阶段:先搭骨架(系统设计),再填肉(详细设计)​

闲话说完,咱们接着聊设计阶段。这一步是新手最容易忽略,但最影响后续开发的环节,千万别觉得“设计麻烦,不如直接写代码”。前期设计不到位,后期改bug能改到你怀疑人生。

系统设计,说白了就是“搭骨架”,是架构层面、粗粒度的设计,一般由系统工程师或者系统架构师来干。

核心是想清楚,要实现这个需求,需要用到哪些硬件、软件?内部的组件怎么配合,比如后端的服务和前端的页面怎么联动?外部要对接哪些东西,比如第三方接口、数据库?

这里要区分两种情况。如果是全新开发一个软件产品,或者要加一个新组件、用新架构,那系统设计就非常重要。相当于盖房子先搭框架,框架搭歪了,后续再怎么砌墙都没用。

但如果是在现有产品上加一个小需求,比如“给登录页面加个‘忘记密码’的按钮”,基本不涉及系统架构的变更,这一步就可以简化,不用写复杂的文档。

但新手要注意,哪怕是小需求,系统设计这一步也不能完全跳过。因为V模型里,后续的系统测试,就是照着系统设计文档来测的。

你得写清楚,这个小需求在架构层面要实现啥功能、有啥约束,比如“忘记密码按钮只能点击3次,超过3次锁定”。不然测试人员不知道怎么测,后续很容易出现分歧。

系统设计搞定后,就进入详细设计阶段。这一步就轮到咱们研发人员上场了,也是和新手日常工作最相关的一步。

详细设计就是填肉,把系统设计的“骨架”填满。

比如设计接口怎么写,接口地址、请求方式、返回参数;数据库的表结构,要建哪些表、每个字段是什么类型;具体的实现逻辑,比如“忘记密码后,验证码有效期10分钟”;界面长啥样,按钮放哪里、字体多大。每一个细节都要想清楚、写明白。

后续的编码工作,全靠这份详细设计文档。你照着文档写代码,就不会跑偏;要是文档写得模糊,你写着写着就会发现,自己不知道该怎么继续,甚至写出来的代码和别人的对接不上。所以新手刚开始干活,一定要养成“先设计、再编码”的习惯,别急于求成。

设计评审:别自己瞎琢磨,多找别人看看​

这里插一句,需求分析、系统设计、详细设计做完后,输出的文档都要做“评审”。说白了就是找几个人看看,有没有问题、要不要调整。评审没有固定的标准,全看团队大小和需求复杂度。

小团队、简单需求,几个人凑在一起,面对面看文档。比如研发、产品、测试各来一个,你说你的设计思路,别人提提意见,比如“这个接口设计得太复杂,不如简化一下”,改一改就完事了,不用搞太复杂。

大团队、复杂需求,就会比较正式。QA会全程监督,发起好几轮评审流程,每个人都要在系统上提交意见,改完还要再评审,直到所有人都认可。这也是为了避免后期出现大问题,毕竟人多力量大,能发现很多你自己忽略的细节。

编码+测试:写完代码不算完,测通才是硬道理​

设计评审通过,确认可以开工了,研发人员就可以着手编码了。这就是咱们每天最核心的工作:写代码。

编码的时候,有两个小提醒给新手。

第一,遵守团队的规矩,比如代码规范,变量怎么命名、注释怎么写;Git规范,提交代码的时候怎么写备注、怎么分支管理。别自己随心所欲写,不然别人接手你的代码会崩溃,你自己后期维护也麻烦。

第二,别光顾着写代码,抽空写单元测试。单元测试就是你自己测自己写的代码,比如你写了一个“计算销量”的函数,就写个测试用例,看看输入100、输出是不是100,有没有bug。

说到单元测试,这里要吐槽一句。国内很多公司为了“赶进度、提效率”,不强制研发写单元测试,导致很多新手都不知道单元测试是啥。编码写完直接提交,跳过单元测试,直接进入集成测试。这种做法短期看是快,长期来看,很容易留下隐藏的bug,后期排查起来更费时间。

新手最好养成写单元测试的习惯,哪怕简单写几个,也能减少后期的返工。

集成测试:和同事联调,确保代码能配合运行​

编码完成,或者大体完成后,就进入集成测试阶段。说白了,就是“联调”,属于编码的后期工作。

你一个人写的代码没问题,不代表和别人的代码配合起来没问题。比如你写的后端接口,和前端页面对接的时候,能不能正常返回数据?和其他同事写的组件联动的时候,会不会报错?这些都要在集成测试阶段验证。

集成测试很灵活,一般是研发人员之间自己联调。比如后端找前端,“我接口写好了,你那边测测能不能调通”,测的时候发现问题,当场改,不用写复杂的文档、不用提问题单,怎么高效怎么来。

系统测试vs集成测试:别搞混这两个环节​

很多新手分不清集成测试和系统测试,觉得两者差不多。其实差别很大,我用大白话给大家分清楚。

集成测试:研发人员自己搞的,不讲究形式,不用写测试用例,核心是“联调通、能运行”,只要和其他组件配合起来没问题就行。

系统测试:要正式很多,研发人员得先写“系统测试用例”,比如“输入正确的账号密码,能登录成功”“输入错误的密码,会提示‘密码错误’”。然后研发人员照着用例一步步测,发现bug要提问题单,研发修复后,刷新版本,再重新测,直到所有用例都通过,才算完成。

简单说,集成测试是自己人内部验收,系统测试是按规矩正式验证,两者缺一不可。

验收测试:最后一关,等着测试人员“挑错”​

系统测试通过后,就进入最后一步:验收测试。这一步,真正的测试人员,TC,才会正式介入。

测试人员会参考研发写的系统测试用例,再结合需求分析文档,写一份“验收测试用例”。然后发布一个“验收版本”,部署到专门的测试环境,一步步验证功能。

是不是符合需求?有没有bug?界面是不是和约定的一样?发现bug,就提问题单,研发修复,刷新版本,再测,反复几轮,直到所有验收测试用例都通过,才算验收合格。

验收合格后,这个需求就算开发完成了。要么直接发布给客户用,要么合入主线版本,和其他需求一起发布。

讲到这里,大家应该能发现,测试工作不是“等研发写完代码再干”,而是贯穿整个开发过程的。

从需求分析、设计评审,到编码、联调,都有测试的影子。很多新手觉得“测试是测试人员的事,和我没关系”,其实不然。你写的代码质量越高,测试阶段的bug就越少,后期返工就越少,自己也能少加班。

再聊热门的Scrum:不是模型,是高效干活的框架​

聊完V模型,咱们再聊聊现在最火的Scrum。很多互联网公司都在说“我们用敏捷开发”,其实大多时候,他们用的就是Scrum框架。

先给新手澄清一个误区,在之前的文章中我们也提到过,Scrum不是一个“开发模型”,而是一个“工作框架”。

说白了,它不规定你“先设计再编码”,还是“先编码再设计”,而是给你一套工作方法,让团队能高效协作、快速交付功能。

核心就是快、灵活、能及时调整。换成大白话,跟着Scrum的规矩干活,能快速开发、快速交付,不用等所有东西都设计完美再动手,边做边改,效率更高。

Scrum核心角色:搞懂自己该干啥​

Scrum框架里,有四个核心角色,新手一定要认清楚,不然很容易搞混自己的定位。

  1. 开发团队(Dev Team):核心中的核心,就是咱们所有研发人员,加上测试人员(TC)。负责具体的开发、测试工作,比如写代码、改bug、联调。
  2. 产品负责人(PO):对接需求的人,相当于“需求代言人”。负责接收客户、公司的需求,给需求排序,比如“这个需求紧急,先做;那个需求不紧急,往后放”。然后安排给每个“迭代”,告诉团队“这一轮要做啥”。
  3. Scrum Master(SM):相当于“管家”,不写代码、不提需求。核心工作就是保证Scrum框架能正常落地,比如组织会议、协调资源、解决团队遇到的问题。比如团队有人请假,没人接手工作,SM就去协调。确保团队能按时完成迭代任务。

关键概念:迭代(Sprint)——固定时间内搞定一批需求​

这里再解释一个新手常听到的词,迭代(Sprint)。

简单说,迭代就是“一个固定的时间段”,比如两周、一个月。团队在这个时间段内,集中精力完成一批固定的需求,时间一到,就交付成果。

不管有没有做完,都要停下来总结,然后开始下一个迭代。比如团队定了两周一个迭代,这两周就只做PO分配的3个需求,做完就交付,没做完的就放到下一个迭代。

Scrum里不用专门设计?真相是这样​

聊到这里,新手可能会有疑问,和V模型比起来,Scrum里好像没有专门的系统设计、详细设计步骤,难道不用设计吗?

不是不用设计,而是Scrum的核心假设和V模型不一样。

V模型认为要先把所有东西设计完美,再动手开发,而Scrum认为没人能一开始就把所有东西设计完美,设计应该跟着需求、代码、用户反馈,一点点进化。

具体怎么操作?给大家讲一个真实的场景,新手一看就懂。​

迭代开始前,PO会先梳理“产品待办列表”,就是所有要做的需求。明确这一轮迭代要做哪些需求,然后做一个“概要设计”。

不用写复杂的文档,大概说说每个需求要怎么做、拆分多少个小任务。比如“用户登录功能,拆成‘账号密码验证’‘验证码发送’‘忘记密码’3个小任务”,不用涉及具体的接口、表结构。

然后SM会组织迭代计划会,研发团队、PO、SM都参加。确认这一轮迭代的目标,比如“完成3个核心需求,交付可运行的版本”,还有每个人的工作任务。

比如“A负责登录接口,B负责前端页面,C负责测试”。这个时候,研发团队会提前沟通好系统设计的核心思路,比如“登录接口用POST请求,对接MySQL数据库”,在会议上确认一下,没有问题就开工。

迭代开始后,研发人员才会慢慢做详细设计。比如写接口文档、设计表结构,然后开始编码。编码的同时,测试人员也会同步准备测试用例,不用等编码完全完成再动手。

Scrum日常流程:每天10分钟站会,高效不啰嗦​

编码完成后,研发人员自己先测一测,自验证。没问题就交给测试人员做验收测试。

迭代期间,每天都会开一个“每日站会”,时间很短,一般10-15分钟,大家都站着说。目的就是不让你说废话,每个人只说三句话:“昨天做了啥”“今天要做啥”“遇到了啥问题”。

比如你说“我昨天写完了登录接口,今天要对接前端,遇到的问题是第三方接口调不通”,SM就会协调人帮你解决,确保大家进度一致,没有隐藏问题。

迭代时间一到,不管需求有没有做完,都会停下来开迭代评审会。展示这一轮的成果。

比如“我们完成了登录、注册两个功能,大家可以看看”,收集PO、测试人员的意见。比如“登录界面太丑,要改一改”。然后再开“迭代回顾会”,总结这一轮的问题。比如“需求拆分太粗,导致后期返工”“每日站会开得太久,浪费时间”,商量下一轮怎么改进。

避坑提醒:别把Scrum搞成“中华田园敏捷”​

这里要给新手提个醒,Scrum看起来很灵活、很高效,但对团队的要求很高。全靠PO和SM把控节奏,这两个角色必须有足够的经验和能力。

团队成员也要有很强的自律性,比如分配的任务要按时完成,遇到问题要及时说,不能藏着掖着。如果是大型团队,还会引入QA全程监控,确保流程不跑偏。

尤其是在国内,很多团队用Scrum,最后都变成了中华田园敏捷。这是咱们行业内的自嘲,说白了就是“伪敏捷”,只学了Scrum的“形”,丢了它的“神”。

比如,老板拍板说“这个需求必须下周上线”,不管团队能不能完成,强制加班;每天开站会,开成了“汇报会”,每个人滔滔不绝说半天,浪费时间;只模仿“迭代”“站会”这些形式,却不注重质量。

比如不做设计、不写测试用例,只求快,上线后一堆bug,然后甩锅给研发“你们代码写得差”。

这种中华田园敏捷,本质就是披着敏捷的外衣,干着赶工、甩锅、失控的活儿。

管理粗放,外行指挥内行,最后受伤的还是咱们研发人员,天天加班改bug,却看不到成果。

所以新手找工作的时候,也可以留意一下。如果公司说我们用敏捷开发,但连迭代计划会、迭代回顾会都不开,只知道让你加班赶进度,那大概率就是中华田园敏捷,慎重选择。

国内很多真正用敏捷的团队,为了避免这种失控的情况,SM都会由实职人员来担任。比如部门领导担任部门级SM,团队经理担任团队SM。毕竟他们有话语权,能协调资源、把控节奏,才能避免流程失控。

新手总结:开发模型是工具,别死记硬背,灵活用就好​

说到最后,只给大家介绍了两个经典的模型,其他模型还需要大家自己去进一步的学习、运用。

给新手们一个核心总结,也是咱们这篇文章的重点。开发模型(或框架)不是“纸上谈兵”,而是用来解决实际问题的工具。你不用死记硬背每个步骤的定义,也不用纠结“哪个模型更好”,关键是结合自己的工作场景,灵活运用。

比如你在小团队,需求变化少,那就用V模型的思路,先搞懂需求、做好设计,再编码测试,稳扎稳打;如果你在互联网公司,需求天天变,那就跟着Scrum的节奏,迭代交付、快速调整。

另外,新手不用急于求成,刚开始可能还是会分不清步骤、用不好模型,没关系。多结合自己的工作,比如你今天写了一段代码,就回头想想,这段代码对应的是哪个阶段(编码阶段)?前期有没有做详细设计?后期有没有做测试?慢慢对应、慢慢总结,你就会发现,这些方法论其实就在你身边,能帮你少走很多弯路、提高工作效率。

后续文章,我们还会在学习系统架构的基础,不断通过拾遗的形式,继续用大白话拆解大家没搞懂的东西,帮大家彻底吃透架构相关的方法论,再也不被专业术语搞懵。大家如果有更多的问题,欢迎后台留言。

在此也奉上我们最美好的祝愿:

🧨🏮🧧🍊 愿新的一年,0 Error 0 Warning,更要 0 病痛 0 疲惫。祝各位同行键盘敲得响亮,腰颈挺得笔直,发量与体能同在,代码和健康双全。🧨🏮🧧🍊

白话架构(5)—— 从敏捷到DevOps:软件研发模型的终极进化,解锁高效交付密码

· 阅读需 44 分钟

肯·施瓦伯:敏捷不是没有流程,而是让流程服务于价值交付,而非价值交付服从于流程。

上一篇我们梳理了瀑布模型及其衍生模型的进化史——从被误读的瀑布模型,到强化测试的V/W模型,再到聚焦风险的螺旋模型,每一步创新都在对抗研发中的“不确定性”。

但随着技术发展,更多类型的项目要进行开发交付,以及21世纪互联网时代的到来,用户需求迭代加速、市场竞争日趋激烈,“线性流程”“阶段化交付”早已无法满足快速响应的需求。

软件研发模型也自然开启了新一轮“革命”——从构件化组装到敏捷迭代,再到 DevOps 的全流程打通,核心目标只有一个:更快、更稳、更灵活地交付有价值的产品。

今天我们就顺着时间线和技术依赖关系,聊聊那些颠覆传统的先进研发模型,看看它们如何重塑现代软件研发的底层逻辑。

前奏:构件组装模型,打破“重复开发”的桎梏​

在敏捷模型爆发之前,软件行业面临一个普遍痛点:不同项目之间大量重复开发基础功能,效率低下且质量参差不齐。

这一问题在20世纪80-90年代的大型企业中尤为突出,比如早期SAP为制造业客户开发ERP系统时,不同工厂的“库存台账登记”功能本质逻辑一致,却因缺乏复用机制,每个项目都要重新编写代码,不仅延长了项目交付周期,还增加了后期跨项目维护的难度。

为了解决这类问题,20世纪90年代初,构件组装模型(Component-Based Development, CBD)应运而生,它是连接传统阶段化模型与现代敏捷模型的关键桥梁。

其核心推动者之一是卡莉斯·鲍德温(Carliss Baldwin), 她是哈佛商学院荣誉退休教授、管理经济学家,与 金·B·克拉克(Kim B. Clark) 共创模块化系统理论,为组件化开发、平台生态与组织创新提供跨学科理论基础,是连接技术架构与商业战略的核心学者 。

她不仅提出了构件组装模型,还提出了构件标准化接口的核心思想。有意思的是,她最初的灵感来源并非软件开发,而是汽车制造业的“模块化生产”,将汽车零件的复用逻辑平移到了软件领域,意外开启了软件构件化的新时代,

图:卡莉斯·鲍德温

构件组装模型的核心逻辑,是复用即效率:将软件系统拆解为一个个独立的、可复用的构件(比如登录模块、支付接口、数据加密组件等),这些构件具备标准化接口、可独立开发测试、可跨项目复用的特性;开发新项目时,无需从零编码,而是像“搭积木”一样,将现有成熟构件组合起来,再开发少量个性化模块,最终快速组装成完整产品。

这里的构件,既可以是企业内部积累的、能实现特定功能的代码块(也就是常说的“模块”),也可是现成的二方、三方组件。不管是模块还是组件,它们都是能直接使用、具备特定功能的代码集合(比如早期的JavaBean、COM组件)。

国内的金蝶K/3 ERP系统就大量采用了构件组装模型,将财务核算、供应链管理等模块拆分为标准化构件,支持企业按需组合部署。

这里要特别区分构件组装模型与上一篇提到的RAD模型,二者虽都强调“复用”和“快速交付”,但核心逻辑差异显著。

RAD模型以快速原型迭代+可视化工具为核心,复用的多是成熟开发工具和通用组件,侧重快速交付可用产品,无需提前搭建完整构件库;而构件组装模型以标准化构件为核心,复用的是经过沉淀的、可跨项目通用的功能模块,需提前搭建企业级构件库,侧重“长期复用效率”和“系统可维护性”。

简单来说,RAD是临时借力快速交付,构件组装模型是长期沉淀高效复用。

图:构件组装模型

构件组装模型的核心流程可概括为4步:

  1. 设计构件组装
  2. 建立构件库
  3. 构件应用程序
  4. 测试与发布

构件组装模型的优点十分突出:

  1. 基于构件完成项目组装,具备良好的可扩展性,能够有效提升整体开发效率(易扩展)
  2. 支持构件的复用性开发,可大幅减少重复工作,显著降低项目开发成本(易重用,降低成本)
  3. 构件设计粒度更精细,开发操作更灵活,支持团队成员并行开发,提升协作效率(粒度小,更灵活,团队并行)

但它也存在明显局限性:

  1. 构件拆分对开发或架构经验要求较高,若划分不合理,会直接降低构件的可重用性
  2. 构件的复用过程中,可能会对性能等其他核心指标产生负面影响
  3. 第三方构件的质量缺乏统一保障,易对整体项目质量造成潜在风险

值得一提的是,构件组装模型的“复用思想”,不仅为后续敏捷模型的“迭代交付”奠定了技术基础,也成为DevOps中“基础设施即代码(IaC)”“组件化部署”的核心雏形。

过渡:统一过程(UP),结构化与迭代化的融合​

20世纪90年代中后期,随着构件技术的成熟和需求变更的加剧,传统线性模型已完全无法适配复杂软件项目,而纯粹的迭代模型又缺乏标准化流程,导致大型项目管理混乱。

在这种背景下,统一过程(Unified Process, UP)应运而生,其核心代表是 Rational Unified Process(RUP),核心推动者是伊瓦尔·雅各布森(Ivar Jacobson)、格雷迪·布奇(Grady Booch)和詹姆斯·朗博(James Rumbaugh)。

这三位被称为UML三巨头,他们原本各自有自己的软件开发方法论。

图:格雷迪·布奇,詹姆斯·朗博,伊瓦尔·雅各布森

伊瓦尔·雅各布森,提出面向对象软件工程(OOSE)方法论,核心目标是通过用例驱动实现复杂系统的高效开发,被爱立信、诺基亚等通信企业用于电信核心系统研发。

格雷迪·布奇,提出Booch方法(用他自己名字命名👍),聚焦面向对象的分析与设计,帮助团队梳理系统架构与模块关系,IBM早期大型机软件项目曾广泛采用。

詹姆斯·朗博,提出对象建模技术(OMT),核心是通过建模简化复杂需求,摩托罗拉、惠普等企业将其用于嵌入式系统和硬件配套软件研发。

为了整合行业共识,三人放弃了“门户之见”,“化敌为友”联手打造了UP模型。更有趣的是,他们最初的合作契机是一场“学术辩论”,在辩论中发现彼此的理念高度互补,最终从“对手”变成了“战友”,共同推动了UP模型的普及。

UP模型的本质,是“结构化流程+迭代化交付”的融合体——它保留了传统模型(如瀑布模型、V模型)的阶段化管控优势,又引入了迭代交付的灵活性,解决了“大型项目如何有序迭代”的难题。

华为U2020基站管理系统,就采用RUP(UP核心代表)模型完成研发,通过核心架构先行和多轮迭代,实现了对全球不同运营商网络环境的适配。

图:华为基站

UP模型核心特征是二维结构,其中时间维度将项目生命周期明确划分为4个核心阶段,每个阶段对应专属的里程碑,确保项目推进有章可循。

具体来看,生命周期阶段与对应里程碑的匹配及描述如下:

  1. 目标里程碑(对应初始阶段):核心目标是明确项目愿景与可行性,确认“做什么、能不能做”;完成项目启动评审,标志着项目方向与可行性已达成共识
  2. 架构里程碑(对应细化阶段):核心目标是完成核心需求梳理与系统核心架构设计,明确“怎么做的核心方向”;通过架构评审,标志着系统核心架构与需求范围已固化
  3. 能力里程碑(对应构建阶段):核心目标是完成所有功能模块的开发与集成测试,确保产品功能完整可用;通过系统测试验证,标志着产品已具备预设的核心业务能力
  4. 发布里程碑(对应交付阶段):核心目标是完成产品部署上线与用户验收,实现产品成功落地;完成用户验收,标志着产品已正式交付用户使用

在UP模型的全生命周期中,架构师扮演着核心枢纽角色,其工作核心聚焦三点,贯穿项目各阶段:

  1. 协同需求与管理人员:主动与需求人员深度对接,精准拆解和转化业务需求,确保架构设计贴合业务目标;同时与管理人员密切协作,同步架构规划、技术风险及资源需求,平衡项目进度、成本与质量,保障架构落地的可行性
  2. 细化软件架构:基于项目愿景和核心需求,搭建系统整体架构框架,细化模块划分、接口标准及技术实现方案,覆盖架构的可扩展性、稳定性与安全性设计,为开发团队提供清晰的技术指引
  3. 保持架构概念完整性:在项目迭代过程中,严格把控架构设计的一致性,监督架构落地执行,规避“架构漂移”;针对需求变更或技术难题,在调整架构时坚守核心设计理念,确保整体架构的连贯性与统一性,不偏离初始设计愿景

UP模型是传统阶段化模型向现代敏捷模型过渡的关键产物,它的迭代交付、核心架构先行、持续反馈等思想,直接影响了后续敏捷模型的发展,尤其是Scrum、FDD 等模型的阶段划分和管控逻辑,都能看到UP模型的影子。

爆发:敏捷时代降临,以“用户价值”为核心的迭代革命​

敏捷核心:从《敏捷宣言》到四大经典实践模型​

2001年,软件行业正被传统瀑布模型的僵化流程所困扰——“先写全文档、再按阶段开发”的模式,面对互联网时代快速变化的用户需求完全失灵,很多项目要么因文档滞后跟不上需求迭代,要么因前期规划失误中途夭折。

当时有17位来自不同领域的软件大牛,有的深耕企业级软件研发,有的专注创业项目交付,他们都曾在项目中深受其苦,甚至为了满足客户催更需求,只能偷偷绕开繁琐流程搞“小步迭代”,却还要面临行业“不专业”的质疑。

正是这份共同的痛点,让他们齐聚犹他州——原本是一场小型软件技术沙龙的参与者,沙龙结束后,有人提议找个地方放松交流、吐槽避坑,便就近选中了郊外一家不起眼的滑雪小屋。

图:滑雪小屋

没有正式会议的流程束缚,没有西装革履的拘谨,围坐在温暖的壁炉旁,大家彻底打开话匣子,从项目失败的血泪史聊到私下实践的迭代技巧,越聊越有共鸣。这场原本只是发泄情绪的“吐槽大会”,最终演变成一场行业变革的共识碰撞。

大家一致认为,需要一套全新的研发理念打破传统桎梏,于是用短短两天时间敲定了《敏捷宣言》的核心内容,正式宣告敏捷时代的到来。

图:敏捷宣言

这份宣言颠覆了传统研发逻辑,明确个体互动高于流程工具、可工作软件高于详尽文档等核心观点,而这个简陋的滑雪小屋,也成为了软件研发模型进化史上的标志性“圣地”。

敏捷不是单一模型,而是一套以用户价值为核心、快速响应变化、持续迭代交付的研发理念,在此基础上衍生出多个具体实践模型,其中最具代表性的是 XP、FDD、Scrum和水晶方法。它们彼此独立又相互补充,适配不同类型的项目和团队。

XP:最“极致”的敏捷实践,聚焦代码质量与快速迭代​

XP(Extreme Programming,极限编程)是由肯特·贝克(Kent Beck)在20世纪90年代末提出的敏捷模型,核心目标是在快速迭代中保证代码质量,适合小型、高效、跨职能的开发团队,典型应用场景为互联网产品、交互式软件(比如早期的社交APP、Web应用)。

图:肯特·贝克

肯特·贝克堪称“敏捷实践狂人”,他在提出XP模型前,曾为 Chrysler 汽车公司开发软件(Chrysler Comprehensive Compensation系统,简称C3),当时客户需求变更频繁,传统开发模式完全失控,他干脆“破罐破摔”,摒弃了繁琐的文档,推行“结对编程”“测试驱动”等极致实践,没想到项目竟然顺利交付。

早期的 Mozilla Firefox 浏览器部分功能模块研发,也通过XP的快速迭代和测试驱动,快速响应用户反馈并修复漏洞。

XP模型的核心实践可概括为四大核心价值观+十二大实践,四大价值观即沟通、简单、反馈、勇气;十二大实践则包括:规划游戏、小型发布 、隐喻、简单设计、测试驱动开发、重构、结对编程、集体代码所有制、持续集成、每周 40 小时工作制、现场客户、编码标准。

XP模型的优点:极致灵活,能快速响应需求变更;全程聚焦代码质量,降低后期维护成本;客户深度参与,减少需求理解偏差。

缺点则是:对团队能力要求极高,结对编程、TDD等实践需要团队长期磨合;过度依赖客户反馈,若客户需求不清晰,易导致迭代方向混乱;不适用于大型复杂项目和高可靠性要求的核心系统(比如航天软件、银行核心交易系统)。

FDD:以“特征”为核心,平衡敏捷与结构化​

FDD(Feature-Driven Development,特征驱动开发)由杰夫·德卢卡(Jeff De Luca)和彼得·科德(Peter Coad)在1999年提出,它是敏捷模型中最“结构化”的一种,核心逻辑是“以用户可感知的‘特征’为单位,进行迭代开发”,适合中大型团队和复杂业务系统(比如企业级CRM、电商平台)。

图:杰夫·德卢卡

图:彼得·科德

彼得·科德是个极具传奇色彩的人物,他不仅是FDD模型的核心创始人,还是一位畅销书作家,其著作《Object-Oriented Analysis》影响了一代程序员。更有意思的是,他提出FDD的灵感,来自于一次为大型零售企业开发CRM系统的经历。

当时他接手的项目团队超50人,服务的零售客户在全国有上百家门店,需求杂且变更多,今天要加“会员积分兑换”功能,明天要改“门店库存同步”逻辑。

一开始用传统敏捷迭代模式推进,结果团队直接陷入“各自为战”的混乱。开发门店模块的工程师不知道会员模块的进度,做报表统计的开发者频繁被需求变更打断。

更搞笑的是,有一次两个小组同时开发“客户信息查询”功能,最后写出了两套完全不兼容的代码,上线前测试才发现问题,白白浪费了两周时间。

彼得·科德看着一团乱麻的项目进度,急得连续几天泡在客户门店里找灵感。有天他看到门店导购员按“接待客户、下单结算、售后回访”的流程工作,每个环节都是客户能清晰感知的“小事”,突然灵光一闪:既然线下工作能按用户可见的环节拆分,软件开发为什么不行?

于是他立刻召集团队,把复杂的CRM系统拆解成“会员注册”“订单查询”“库存预警”等一个个用户能直接感知的“特征”,每个特征明确负责人和交付时间,没想到原本混乱的团队瞬间找回节奏,之前卡了一个月的功能模块,按特征拆分后两周就顺利交付。

这次“踩坑后的顿悟”,也成了他后续完善FDD模型核心框架的关键灵感来源。

而后美国联邦快递的物流追踪系统也应用了FDD模式,通过拆分“包裹下单”“轨迹查询”“签收确认”等用户可见特征,实现了千人团队的有序迭代。

图: FDD 模型

FDD模型里的特征,是指用户能快速感知的最小功能单元(比如“用户登录”“订单查询”“支付退款”),每个特征的开发周期通常控制在2周内。

FDD的核心流程分为5个阶段:

  1. 开发整体模型:梳理业务领域知识,建立整体业务模型
  2. 构建特征清单:将整体业务模型拆解为一个个可开发的特征,形成特征清单
  3. 规划特征开发顺序:根据业务优先级,规划每个迭代的特征开发计划
  4. 按特征迭代开发:每个迭代围绕选定的特征,执行“设计→编码→测试→集成”的完整流程
  5. 持续构建与集成:每个特征开发完成后,及时集成到主干,确保系统整体可用

FDD模型的核心优势,是平衡了敏捷的灵活性和结构化的管控性:既保留了迭代交付的快速响应能力,又通过“整体模型先行”“特征清单规划”,避免了敏捷模型易出现的“无序迭代”问题;同时,每个特征的开发流程标准化,便于中大型团队协作。

缺点则是:前期需要投入时间梳理整体业务模型和特征清单,启动周期相对较长;对业务领域知识要求较高,若团队缺乏业务积累,易导致特征拆解不合理。

Scrum:最普及的敏捷框架,聚焦“迭代管理”与“团队协作”​

Scrum 是由杰夫·萨瑟兰(Jeff Sutherland)和肯·施瓦伯(Ken Schwaber)在1995年提出的敏捷框架(注意:Scrum 是框架而非严格意义上的“模型”,可灵活适配不同项目场景),核心目标是通过高效的团队协作和迭代管理,快速交付用户价值。

图:肯·施瓦伯、杰夫·萨瑟兰

这里有个容易被误解的点:Scrum 的诞生时间(1995年)比2001年《敏捷宣言》的签署早了6年,并非先有“敏捷”理念才有 Scrum 实践,而是 Scrum 等早期迭代实践,为后续敏捷理念的成型奠定了核心基础。

简单来说,Scrum 是敏捷理念的先行实践者,而《敏捷宣言》是对 Scrum、XP 等分散迭代实践的“理念统一与命名”。

如今,Scrum 已成为全球最普及的敏捷实践,广泛应用于互联网、电商、金融、教育等多个行业,无论是小型创业团队还是大型企业,都能灵活落地。

这里还有个鲜为人知的趣事:杰夫·萨瑟兰最初是一名战斗机飞行员,他将空军的“快速响应、协同作战”理念平移到了软件开发中。比如 Scrum中的每日站会,灵感就来自于飞行员的战前简报,要求快速同步信息、暴露问题,不做冗余讨论;而迭代目标则对应飞行员的作战任务,确保团队聚焦核心目标。

图:Scrum框架

Scrum 的核心逻辑是:基于固定迭代周期(Sprint),通过角色、事件、 artifacts(产物/制品)的标准化,实现高效协作与快速迭代。

其核心组成部分包括:

  1. 核心角色:产品负责人(PO)负责梳理需求、制定优先级;Scrum Master(SM)负责保障 Scrum 流程落地,清除团队障碍;开发团队(Dev Team)负责迭代内的开发、测试、交付工作
  2. 固定事件:Sprint计划会(确定迭代目标和工作内容)、每日站会(15分钟,同步进度、暴露问题)、Sprint评审会(迭代结束后,向客户/ stakeholders演示成果并收集反馈)、Sprint回顾会(复盘迭代过程,优化流程)
  3. 核心产物:产品待办列表(Product Backlog,梳理所有需求)、Sprint待办列表(Sprint Backlog,迭代内要完成的工作)、增量(Increment,迭代结束后交付的可运行产品版本)

Scrum 按一个迭代来看,主要活动就包括:待办事项列表(需求)梳理、Sprint计划会、每日站会、Sprint评审会议、Sprint回顾会。

Scrum 的最大优势,是灵活性极强,可适配不同规模、不同类型的项目;流程标准化,团队协作效率高;通过固定迭代和持续复盘,能快速优化研发流程。

缺点则是:对产品负责人和Scrum Master的能力要求极高,若角色职责不到位,易导致迭代失控;过度依赖团队自律,大型团队落地时需要额外的管控机制;需求变更过于频繁时,会影响迭代目标的稳定性。

水晶方法:最“轻量”的敏捷模型,适配“个性化团队”​

水晶方法(Crystal Methods)由阿利斯泰尔·科伯恩(Alistair Cockburn)在1998年前后逐步提出并实践,比2001年签署的《敏捷宣言》早了3年左右,和Scrum、XP类似,它也是敏捷理念的重要“先行实践”之一。

图:阿利斯泰尔·科伯恩

作为敏捷模型中最“轻量”“灵活”的一种,其核心理念是没有最好的流程,只有最适合团队和项目的流程。

即根据项目规模、团队能力、业务复杂度,定制个性化的敏捷实践,无需严格遵循固定流程。阿利斯泰尔·科伯恩被称为敏捷界的哲学家,他提出水晶方法的核心初衷,是反对“敏捷形式主义”。

阿利斯泰尔·科伯恩在走访全球200多个软件团队后发现,优秀的开发团队都像“水晶”一样,看似有通透的核心逻辑(聚焦价值交付),但又各自有独特的形态(适配团队的个性化流程),既纯粹又多样。

更有意思的是,他认为水晶“需要精心打磨但无需过度雕琢”,这和他的理念不谋而合——敏捷流程该精简高效,而非搞复杂的形式主义,于是便给这套方法取名水晶方法。

阿利斯泰尔·科伯恩还发现,不同规模、复杂度的项目,对流程规范的需求天差地别,5人小团队和50人大型团队,不可能用一套流程,强行套用只会适得其反。

为了让团队能快速对号入座,他给不同的水晶方法添加了颜色命名,寓意“每个团队都有自己的水晶特质,无需刻意模仿他人。

水晶方法的颜色分类,本质是“按需匹配流程复杂度”的直观体现,不同颜色对应不同的项目场景。

比如透明水晶(Crystal Clear),适配2-8人的小型团队、简单项目(如创业原型开发),流程极简,几乎没有固定规则,只保留“频繁交付”“及时沟通”等核心动作。

黄色水晶(Crystal Yellow),适配10-20人的团队、中等复杂度项目(如小型电商APP),会增加简单的文档和评审环节。

橙色水晶(Crystal Orange),适配20-40人的团队、较高复杂度项目(如企业级办公系统),流程会更规范,增加风险管控和跨角色协作机制。

红色水晶(Crystal Red),适配40人以上的大型团队、高复杂度项目(如大型金融系统),流程最严谨,需明确的角色分工、完整的文档和多轮评审。

图:各色水晶

简单来说,颜色越深,代表项目规模越大、复杂度越高,流程规范程度也越高,核心是“不搞一刀切,让流程适配项目,而非项目适配流程”。其核心原则包括:频繁交付、反思改进、渗透式沟通、专注价值、安全与信任。

早期的Twitter(推特)原型研发阶段,团队仅5人,采用水晶方法(透明水晶)快速验证核心社交功能,无需繁琐流程即可快速调整产品方向。而国内的小红书早期社区版本,创业团队通过水晶方法灵活适配用户反馈,快速迭代内容推荐、评论互动等核心功能。

总结来看,敏捷系列模型的核心突破,是将研发的核心从“流程驱动”转向“用户价值驱动”,从“一次性交付”转向“持续迭代交付”,彻底解决了传统模型“响应慢、变更难”的痛点。而随着敏捷实践的普及,新的问题又随之出现:迭代交付后,部署上线效率低、运维与开发脱节、线上问题反馈不及时——这就催生了研发模型的终极进化:DevOps。

终极进化:DevOps,打通“开发-测试-运维”全流程闭环​

2009年,帕特里克·德博瓦(Patrick Debois)首次提出DevOps概念,将开发(Development) 与 运维(Operations) 两个原本独立的领域融合,核心目标是“打破部门壁垒,实现开发、测试、运维全流程自动化、协同化,快速、稳定地将产品交付到用户手中”。

图:帕特里克·德博瓦

帕特里克·德博瓦被称为DevOps之父,而他提出 DevOps 的契机,堪称“一场意外的吐槽”。

2007年,他受比利时政府部门的委托,协助数据中心迁移,他需要跨开发团队和运维团队工作。而两个团队互相指责,开发说运维“部署太慢”,运维说开发“代码质量差”,他夹在中间苦不堪言,于是开始思考“如何让两个团队高效协作”。

2009年,他模仿 Velocity 大会在比利时举办了一个为期两天的 DevOpsDays。人们从世界各地蜂拥而至,除了开发工程师和运维工程师,还有各种IT管理人员和工具爱好者。两天的会议已经结束后,参与 DevOpsDays 的人们把这次会议的内容带回到了世界各个角落,开启了 DevOps 的新时代。

DevOps 不是对敏捷模型的替代,而是敏捷理念的延伸与升华。敏捷解决了“开发环节如何快速迭代”的问题,而 DevOps 则解决了“迭代成果如何快速、稳定上线”的问题,形成了“开发→测试→部署→运维→反馈→优化”的全流程闭环。其核心价值观是自动化、协同化、持续改进,核心实践可概括为“CI/CD流水线+持续监控+反馈优化”。

图:DevOps

DevOps 的核心实践环节:

  1. 持续集成(CI):开发者每天多次将代码提交到主干,通过自动化构建、自动化测试(单元测试、集成测试),快速验证代码正确性,避免代码集成冲突
  2. 持续交付(CD):将通过CI验证的代码,自动化部署到测试环境、预生产环境,经过自动化测试和人工验证后,随时可部署到生产环境
  3. 持续部署(CD):在持续交付的基础上,将预生产环境验证通过的代码,自动化部署到生产环境,实现“代码提交→上线”的全自动化
  4. 持续监控:上线后通过监控工具(比如Prometheus、Grafana),实时监控系统性能、可用性、用户体验,及时发现线上问题
  5. 反馈与优化:将监控数据、用户反馈、线上问题及时同步给开发团队,通过快速迭代优化产品和系统,形成持续改进的闭环

DevOps 典型应用场景为互联网产品、云原生应用、需要高频迭代的业务系统(比如电商平台、社交APP、金融交易系统)。

除了亚马逊、谷歌、微软等科技巨头的核心业务(亚马逊电商平台一天可完成上百次上线,谷歌搜索的算法迭代均基于 DevOps 实践),国内的阿里双11交易系统也通过 DevOps 实现了海量流量下的高频迭代与稳定运维,保障了交易峰值的系统可用性;而美团外卖的订单调度系统,通过 DevOps 持续集成、持续部署,快速优化调度算法,适配不同时段、不同区域的订单峰值需求。

DevOps 的核心优势:

  1. 打破部门壁垒,开发、测试、运维协同效率大幅提升,减少沟通成本
  2. 全流程自动化,减少人工操作失误,提升上线效率和系统稳定性
  3. 高频迭代+快速反馈,能快速响应市场变化和用户需求
  4. 持续监控与优化,降低线上问题发生率,提升用户体验

DevOps 的落地门槛相对较高:需要企业具备完善的自动化工具链(代码管理、构建工具、测试工具、部署工具、监控工具);需要团队具备“开发+运维”的复合能力(即“全栈工程师”素养);需要企业层面的文化支撑,打破“开发只管编码、运维只管稳定”的传统思维。

但一旦落地见效,就能为企业带来极致的研发效率和业务竞争力。

总结:软件研发模型的进化逻辑,从未改变​

从20世纪50年代的类瀑布实践,到90年代的构件组装模型、UP模型,再到21世纪的敏捷系列模型和DevOps,软件研发模型的进化史,本质上是一部“不断适配业务需求、不断提升交付效率与质量”的历史。

我们可以清晰地看到一条核心进化脉络:从流程驱动到价值驱动,从阶段化交付到持续迭代交付,从部门隔离到全流程协同,从人工操作到自动化智能。每一种新模型的诞生,都不是对前一种模型的否定,而是对前一种模型的补充与优化。

瀑布模型的结构化管控思想,融入到了UP模型和敏捷模型;敏捷模型的迭代思想,延伸出了 DevOps 的持续交付理念;构件组装模型的复用思想,成为DevOps 云原生应用的核心基础。

没有“万能”的研发模型,只有“适配”的研发模型:

  • 需求明确、高可靠性要求的关键项目,适合瀑布模型、V模型;
  • 中大型复杂业务系统,适合UP模型、FDD模型;
  • 小型团队、高频迭代的互联网产品,适合Scrum、XP模型;
  • 需要快速上线、稳定运维的云原生应用,适合DevOps。

下一篇,我们将回归到软件生命周期,从软件的立项开始,逐步进入系统架构的世界。

关注我,带你从源头读懂软件架构的底层逻辑,解锁高效研发的密码~

白话架构(4)——从瀑布到螺旋:60年软件研发模型进化史,藏着每个程序员的工作密码

· 阅读需 27 分钟

巴利·玻姆:软件工程的本质,是在不确定性中寻找确定性的艺术。

作为软件工程师的我们,有没有在那一刹那,思考过这个问题:为什么有的项目能按时上线零bug,有的却卡在需求变更里反复返工?

答案,藏在软件研发模型的进化史里。

上一篇我们聊了软件行业的造神者,今天这篇聚焦和瀑布模型强相关的研发模型——从被误读的瀑布模型,到能应对高风险项目的螺旋模型,再到至今仍在悄悄用的RAD模型,每一种模型的诞生,都是程序员和项目失控的博弈史。

开篇暴击:被全行业误读的瀑布模型,诞生初衷竟是“预警缺陷”​

1970年,温斯顿·罗伊斯(Winston Royce)在论文里写下了瀑布模型的核心框架,但他万万没想到:自己写这篇论文的目的,是警告大家这个模型的缺陷(比如线性流程扛不住需求变更),结果却被全行业当成了“研发圣经”。

图:温斯顿·罗伊斯

为啥会被误读?核心是时代刚需:当时的软件项目需求简单,行业急需一套标准化流程规范混乱的开发行为。于是,这个本是“负面案例”的模型被推上神坛,瀑布模型(Waterfall Model)的名字正式敲定——而类似的线性开发实践,其实早已在行业里悄悄用了十几年。

瀑布模型的核心逻辑特别好懂:像瀑布一样单向倾泻,每个阶段彻底完成后才进入下一个,环环相扣不回头。核心阶段就6个:需求分析,设计,开发,测试,部署,维护。完美适配“需求100%明确、几乎不变更”的大型工程。

图:瀑布模型

但说出来你可能不信,它的雏形早在第一代计算机时代就有了。

溯源:比1970年早14年,世界首个大型计算机网络就用了“类瀑布流程”​

瀑布模型不是突然冒出来的,而是从大型项目实践里“长”出来的。

1950年代初到1963年,美国空军搞了个大项目——SAGE半自动地面防空系统,这是世界上第一个大型实时计算机网络。为了保证这个“国之重器”不出错,团队用了一套“先明确需求、再设计、后开发测试”的线性流程,这就是最早的“类瀑布实践”。

图:防空导弹示意图

这里还有个有趣的小插曲:SAGE系统的核心——AN/FSQ-7计算机,是由 IBM 全权负责开发、构建和维护的。

作为20世纪50年代全球最大的计算机项目,SAGE 堪称 IBM 的“成长加速器”:1952年到1955年期间,这个项目为 IBM 贡献了80%的计算机业务收入;到1958年,参与该项目的 IBM 员工更是超过7000人。更关键的是,SAGE项目催生了大量技术创新,而 IBM 后续将这些创新成果广泛融入到其他计算机产品中,进一步巩固了自身在行业内的地位。

更关键的是,1956年6月29日,赫伯特·D·贝内特(Herbert D. Benington)在“数字计算机高级编程方法研讨会”上,专门以 SAGE 系统为例,写了篇《Production of Large Computer Programs》,第一次系统讲了大型软件的阶段化生产流程——这是目前有文献记载的、最早的类瀑布实践,比罗伊斯1970年的论文早了14年。

图:《Production of Large Computer Programs》 截图

后来,这套流程成了“大型关键项目标配”:IBM 704/709大型机的配套软件、NASA水星计划和双子座计划的载人航天软件、UNIVAC 系列商用软件,全用了瀑布模型。

这些项目有个共性:需求由军方或政府拍板,几乎不可能变;团队动辄几百上千人;交付的是不能出半点错的关键系统——这正好是线性流程的“舒适区”。

就连《人月神话》的作者弗雷德·布鲁克斯(Fred Brooks),在领导 IBM System/360 操作系统开发时,也用了需求→设计→实现→测试的线性流程。虽然没叫瀑布模型,但他强调的文档驱动和阶段评审,后来都成了瀑布模型的核心特征。在前文中我们知道 IBM System/360 难产几年才发布的故事,但正是从它开始,软件的研发模型才具象化,也促使了经典著作《人月神话》的诞生。

致命缺陷爆发:瀑布模型的4个“坑”,逼出了后续所有模型创新​

瀑布模型能稳住大型关键项目,但随着软件行业发展,它的缺陷越来越明显,几乎成了“项目翻车重灾区”:

  1. 错从源头起,补救全白搭:需求分析阶段的一点偏差,会像滚雪球一样贯穿整个流程,直到交付才发现,这时再改已经来不及了(需求分析的偏差会一直向后续阶段传导);
  2. 变更等于“推倒重来”:开发中途要改需求或设计?成本高到离谱,往往得从头返工(难以适应需求变化);
  3. 用户体验“盲盒”:产品原型要等到开发后期才能看到,中间过程没法验证用户感受,等发现问题已经晚了(等待最终产品周期长);
  4. 文档拖累效率:对文档要求极严,大量时间花在写文档上,反而耽误了开发进度(输出大量文档,增加时间、人力成本)。

为了填这些坑,行业开始了一波又一波的模型创新——第一个站出来的,就是带反馈的瀑布模型。

瀑布模型的初代优化:从单向流转到原型验证​

带反馈的瀑布模型:打破单向却未解决核心问题​

20世纪70年代末,带反馈的瀑布模型(Modified Waterfall Model)出现了。它的改进很直接:在相邻阶段之间加了“双向反馈通道”——比如设计时发现需求有问题,能回退到需求分析阶段改;编码时发现设计有缺陷,能退回设计阶段调整。

这打破了传统瀑布“只能往前走、不能回头”的绝对限制,但核心还是线性推进,文档评审要求也没减。

可惜改进有限:只能相邻阶段回退,如果测试阶段才发现需求层面的大问题,跨阶段回退还是得大量返工;而且“需求前期冻结”的核心问题没解决,还是扛不住需求变更。

就在这时,另一种更灵活的模型站了出来——原型模型(Prototype model)。

1977 年原型模型:用快速原型搞定模糊需求​

1977年,巴利·玻姆(Barry Boehm,后面会多次提到的模型创新大神)系统化提出了原型模型(Prototype model)。苹果 Lisa 系统原型开发、早期交互式桌面应用、CRM系统原型验证,都用了这个模型。

图:巴利·玻姆

它的核心逻辑特别简单:先快速做一个可运行的产品原型,拿给用户看、让用户试,通过反复迭代验证需求。对于需求模糊、需要用户频繁确认的交互式软件,这简直是“救星”。

原型模型又分为抛弃型原型和演化型原型。

前者用于需求验证(比如项目开工前做一个 Demo),后者则将原型逐步迭代演化为最终产品(比如先做了个微信,包含基本聊天功能,再慢慢加上朋友圈等功能)。

原型模型的优点很突出:能快速澄清模糊需求,减少理解偏差;用户全程参与,后期需求变更风险大幅降低;早期就能验证产品方向,避免走弯路。

但它缺点也明显:

  1. 容易“重功能轻质量”,为了赶进度可能忽略代码规范和性能问题,导致后期维护困难
  2. 如果原型迭代没节制,容易导致项目范围失控,工期延误
  3. 不适用于高复杂度、高可靠性要求的核心系统(比如嵌入式软件、航天软件)

瀑布带原型模型:需求阶段前加 “缓冲垫”​

20世纪80年代初,行业又想到了“组合拳”——把原型法和瀑布模型结合,搞出了瀑布带原型模型(Waterfall with Prototype)。

它的改进点很精准:在瀑布模型的需求分析阶段前,加了一个“原型开发环节”。先快速做个低保真或高保真原型,和客户确认清楚需求,再进入后续的线性开发流程。

这个模型早期在银行账务系统、企业库存管理系统等 MIS 项目里用得很多,完美解决了传统瀑布“需求模糊、前期确认不足”的痛点。

但局限性依然存在:如果原型阶段没覆盖所有需求问题,后续开发还是会出现和传统瀑布一样的缺陷。所以随着更优模型出现,它很快就退出了主流。

1980 年关键年:两款核心模型的双生突破​

V 模型:瀑布的 “测试强化版”,成为研发基础范式​

1980年是软件过程模型发展的“关键年”,这一年诞生了两个影响深远的模型,第一个就是V模型(Verification and Validation Model)。

保罗·洛克(Paul Rook)首次提出V模型的核心概念,到1990年代逐步完善成行业标准。它最典型的应用场景,是军工、航空航天等对质量要求极高的嵌入式软件项目——比如美军机载控制系统、欧洲空客航电软件。

图:空客飞机

V模型的核心创新,是把瀑布模型的“线性阶段”改成了“左侧开发+右侧测试”的对称V型结构,核心逻辑就一句话:测试活动和开发活动同步规划、提前介入。

图:V模型

本质上,V模型就是瀑布模型的“测试强化版”,保留了线性推进的核心框架,重点解决了传统瀑布“测试滞后”的问题。

但它还是没跳出线性的桎梏:

  1. 需求变更还是要从源头回退,灵活性极差
  2. 测试虽然提前规划了,但实际执行还是在编码之后,没做到“边开发边测试”
  3. 阶段间依赖太紧,一个阶段延迟,后续所有测试环节都得拖

不过别小看V模型,它虽然不完善,却成了软件研发流程的“基础范式”——核心思想甚至融入了敏捷、DevOps 等现代研发模式,至今还在被广泛应用。

增量模型:分模块交付,突破线性局限​

1980年的第二个关键模型,是巴利·玻姆提出的增量模型。

它的标志性项目包括美国国防部 DARPA 的软件项目(早期人工智能系统、军事指挥系统),后来又广泛用于大型企业级软件、ERP系统(比如SAP早期R/3系统)。

图:DARPA

增量模型的核心逻辑,是把整个软件产品按功能拆成多个“增量模块”,每个模块都走一遍“需求→设计→编码→测试→交付”的迷你瀑布流程。然后按优先级高低,先开发核心模块、先交付,再一步步开发次要模块,最后把所有模块整合起来,形成完整产品。

这个创新直接突破了传统瀑布的线性局限,带来了三个核心优势:

  1. 用户能提前用核心功能,降低项目整体风险
  2. 需求可以在后续增量模块中逐步细化,能适配部分需求变更
  3. 前期模块暴露的问题,能在后续模块中快速修正,减少整体返工成本

当然缺点也很明显:对模块拆分能力要求极高,如果模块间耦合度高,会频繁出现依赖冲突,协调成本飙升;前期必须明确整体架构和功能划分,架构设计错了,所有模块都受影响,后期改起来极难;如果交付节奏没规划好,用户体验会很不连贯。

所以它更适合技术成熟、风险较低的项目。

1986年,螺旋模型:把“风险控制”做到极致的王者​

1986年,巴利·玻姆又在《IEEE Computer》发表论文,正式提出螺旋模型(Spiral Model)——这是一个把“风险控制”放在核心位置的模型。这次,巴利·玻姆成为了螺旋模型之父。

巴利·玻姆还有一个有趣的故事。在 TRW 公司时,玻姆团队为规范软件流程,花一年时间制定了 20 项政策和 300 页标准,核心是推广瀑布模型,还设计了类似驾照考试的 40 道 “软件流程测试题”,员工答对 35 题以上才能参与项目开发。

后来面对用户密集型决策支持系统,瀑布模型弊端凸显,团队想改用原型法却遭抵制。

员工直言 “在关键设计评审前写原型代码,既违规又不道德”。

玻姆最终推动公司转向风险驱动的流程体系,兼顾瀑布的严谨与原型的灵活,这个故事也成了软件工程中 “流程僵化与文化变革” 的经典案例。而这个事件也推动了螺旋模型的最终出世。

螺旋模型的典型应用场景,是大型、高风险、高复杂度的软件项目:比如航天飞机控制系统、核电站监控系统、早期大型操作系统 UNIX 的部分模块。

图:航天飞机

螺旋模型堪称“集大成者”,融合了三个核心优势:瀑布模型的结构化流程、增量模型的迭代交付、原型法的风险预判。

它把软件开发过程抽象成“螺旋式上升的循环”,每个循环都包含4个步骤:制定计划→风险分析→工程实现(迷你瀑布/原型开发)→评审。每一圈循环代表一个增量版本,产品越迭代越完善,最后交付完整版本。

图:螺旋模型

它的核心优点全围绕风险展开:提前识别技术、需求、管理等层面的风险,避免后期爆发造成不可控损失;迭代过程中能灵活调整策略,支持需求大幅变更;结合原型法,降低需求模糊和技术实现的不确定性。

但它的门槛也极高:流程逻辑复杂,对项目管理能力要求苛刻,需要专业的风险分析团队和丰富经验,小型项目用它会成本太高、效率太低;而且循环什么时候终止没有明确标准,如果客户评估维度模糊,很容易导致项目范围无限扩大、工期延误。

快速交付为王:RAD模型,至今仍在悄悄被使用​

在巴利·玻姆推动模型创新的同时,1980年代末到1990年代初,詹姆斯·马丁(James Martin)正式提出并系统化了快速应用开发模型(RAD)。

RAD 的核心目标就是“快速交付可用产品”,典型项目是需要快速上线的企业级应用、Web 应用——比如早期电商网站、CRM 系统。它能落地,全靠可视化开发工具和组件化技术(比如早期的 VB、Delphi 开发工具)。

本质上,RAD 是增量模型、原型法和组件化开发的结合体,核心流程是“需求规划→用户设计(原型迭代)→构造系统(组件化编码/测试)→交付部署”,核心强调四点:用户全程参与、快速原型迭代、组件化复用、自动化工具支持。

它的改进特别贴合“效率需求”:

  1. 大幅减少文档工作量,用可运行原型替代书面文档,沟通效率翻倍;
  2. 组件化开发+自动化工具(代码生成器、自动化测试工具),大幅提升开发效率,缩短周期;
  3. 用户全程参与原型迭代,减少需求理解偏差。

缺点也很突出:过度依赖可视化工具和组件化技术,没有成熟组件可复用的话,效率会大幅下降;对团队协作和技术水平要求高,需要跨职能团队紧密配合;不适用于高复杂度、高定制化项目(比如嵌入式软件、核心算法开发),只适合业务逻辑简单的场景;原型迭代太快,容易导致代码质量差、后期维护难。

但这里有个有趣的点:即使到了2026年,RAD模型依然在被广泛使用,哪怕很多开发者自己都不知道。

比如开发企业内部OA、CRM系统,或者用若依这类框架做定制化项目——本质上就是复用现成组件快速搭建,这就是标准的RAD模型。你以为是自己的“小技巧”,其实30多年前就已经被定义好了。

V模型的升级版:W模型,把“并行测试”做到极致​

20世纪90年代中后期,V模型广泛应用后,测试环节的局限性又凸显出来——虽然规划提前了,但执行还是滞后。为了解决这个问题,W模型(Double V Model)应运而生。

W模型就是“双V拼接”,是行业对V模型的集体优化,主要用在金融、电信等对质量和进度都有严格要求的项目里——比如银行核心交易系统、电信计费系统。

它的核心改进,是把V模型“开发与测试并行”的理念,从“规划层面”延伸到了“执行层面”,形成“开发V型+测试V型”的对称结构,实现“开发阶段与测试阶段全程并行”。

但它还是没跳出线性框架,需求变更的返工成本依然很高;而且全程并行对团队协作要求极高,沟通不畅的话,很容易出现测试和开发脱节,反而增加成本。

不过W模型的“全程并行测试”思想,后来也被敏捷、DevOps吸收,成了研发质量保障的底层方法。现在它虽然不是普通公司的首选,但在高质量管控场景里依然是“标准流程”——比如银行核心交易系统(毕竟“一分钟几百万上下”,容不得半点差错)、华为的基站管理软件,还有那些甲方明确要求“测试必须并行”的高要求项目。

结尾:60年进化史,本质是“对抗不确定性”的历史​

从1950年代的类瀑布实践,到后来的V模型、螺旋模型、RAD模型,这60年的软件研发模型进化史,本质上是一部“对抗不确定性”的历史——对抗需求的不确定、技术的不确定、风险的不确定。

没有完美的模型,只有适合的模型:

● 瀑布模型和V模型适合需求明确的项目 ● 螺旋模型适合高风险、大型项目 ● 增量模型适合技术成熟、低风险项目 ● 原型模型适合需求不明确,客户参与改进的项目 ● RAD模型适合快速交付的组件化项目

这些开发模型,如果你要参加软考之类的考试,一定要以他们的特征来进行记忆。

这些模型的核心思想,早已融入现代研发模式里——哪怕你现在用的是敏捷、DevOps,其实也能看到瀑布、V模型、增量模型的影子。

下一篇,我们将继续深入软件架构系列,聊聊那些从这些基础模型演化而来的现代研发模型,看看它们如何解决新时代的研发难题。

关注底部微信公众号程序员爱读书,带你从源头读懂软件架构的底层逻辑~

白话架构(3)- 软件时代的造神者:从PC革命到AI浪潮,这些改变世界的天才你认识几个?

· 阅读需 14 分钟

战国《鹖冠子》有云:“欲知来者察往,欲知古者察今。”

在前两篇架构系列文章中,我们追溯了计算机的起源,梳理了几代计算机的迭代脉络。今天,我们把目光聚焦于软件浪潮中的核心推动者——那些以代码为刃、以热爱为炬的“英雄式”人物。

正是他们的孤勇与专注,在软件蛮荒时代劈开了一条通路,构建起如今数字世界的基石。

白话架构(2)- 从30吨“电老虎”到掌心设备:四代计算机的迭代史诗

· 阅读需 16 分钟

戈登·摩尔:摩尔定律终将失效,但创新不会停止……未来需要材料、架构、算法的协同突破。

在前一篇文章中,我们追溯了计算机的起源,见证了数字时代的萌芽。今天,我们将顺着时间线,走进四代计算机的演化历程——从体积庞大的电子管计算机,到如今融入生活的个人电脑,每一次迭代的背后,都是技术与创新的双重突破,更是架构体系不断完善的过程。

白话架构(1)- 一切始于大爆炸:现代计算机与软件的起源史诗

· 阅读需 15 分钟

达芬奇:“学习如何看。现实中的一切都相互关联”

我们所在的宇宙如何起源?目前科学界最主流的观点是大爆炸宇宙论——一切都源于那一声惊天动地的“嘭”。

而你或许想不到,现代计算机与软件的诞生,也藏着一场大爆炸:从核爆研究中的偶然相遇,到定义行业的经典架构,再到软件开发模式的混沌与觉醒,每一步都环环相扣,最终构筑起如今的数字世界。

1929 年,爱德文·鲍威尔·哈勃(Edwin Powell Hubble,就是冠名哈勃望远镜的那位科学家)总结了红移现象,之后爱因斯坦也来到哈勃工作的威尔逊天文台进行了红移现象的观测。在此基础上,到了 1948 年前后,乔治·伽莫夫(George Gamow)第一个建立了热大爆炸的观念。

二战期间,大名鼎鼎的曼哈顿计划,哈勃并没有直接参与,但他在二战期间为美国海军研究局(ONR)提供咨询,研究雷达技术对天文学观测的干扰问题。在哈勃研究雷达技术时,可能就在他隔壁房间,有一个人正在忙着研究原子弹。

宇宙大爆炸与核爆研究:冯·诺依曼的跨界联结​

关于宇宙起源,1929 年爱德文·鲍威尔·哈勃(没错,就是哈勃望远镜的冠名者)总结了红移现象;之后爱因斯坦也专程前往哈勃工作的威尔逊天文台,亲自观测这一现象。在此基础上,1948 年前后,乔治·伽莫夫首次提出了热大爆炸的核心观念。

而同一时期的二战战场,另一场“爆炸”相关的研究正在秘密进行——曼哈顿计划。哈勃虽未直接参与,但二战期间他为美国海军研究局(ONR)提供咨询,专注于解决雷达技术对天文学观测的干扰问题。有趣的是,或许就在他隔壁的房间,另一位大佬正忙着攻克原子弹的核心难题。

一次成功却又非常失败的应用开发

· 阅读需 7 分钟

2024年5月,朋友 @东方赞 得到了一批显卡,搭建了多套大模型,为了解决模型应用问题,他调研了当时比较火的一些应用,并重点使用和分析了 Sider AI 和 ChatBox。

最后得出结论,目前没有一个应用能很好的满足:既能对接大模型,又能自定义模型提示词,还能流程化地解决问题。于是我们展望了一下这个需求,梳理出一个核心特性:让多个 AI 模型群聊,流程化、通力解决问题。

解决Graal Native Image使用FileAppender编译报错

· 阅读需 3 分钟
阿呜
系统架构师

在 Micronaut 项目中,使用了 Logback 输出日志。在添加了RollingFileAppender 后,编译 Native Image 就会报错了。

反复搜索后,发现问题原因是:编译 Native Image 也会使用 logback 进行日志输出,这个时候就会打开日志文件句柄,然后编译器发现有文件句柄被打开了,编译就被中止了。

按 GitHub 上大佬的建议,解决文案是定义一个延迟加载的 FileAppender。

Micronaut Native Image 编译支持 AWT 图片绘制

· 阅读需 18 分钟
阿呜
系统架构师

当我们不论使用 Micronaut 框架还是其他框架时,如果项目中使用了 AWT 相应特性(仅特性,非 Swing 应用),比如生成图片,在我们将 Java 应用编译为 Native Image 本地应用后,可能就会报出很多和 AWT 相关的异常,导致生成图片相关功能无法使用。

Quarkus 框架给出了官方的解决方案,直接按官方方案使用插件和制作基础镜像即可。

本文将给出一个 Micornaut 框架的完整的指南和项目示例,说明如何配置可以正确正确编译出支持 AWT 特性的项目。

新年里的一些碎碎念

· 阅读需 7 分钟

甲辰龙年基本已经过去,等到正月十年元宵节过后,春节就正式结束了。

在过去的一年里,各行各业都遇到了很多瓶颈。身在软件研发行业中,能感受到更多的飘摇。新的一年,我们要怎么做呢?

Micronaut 实战1——Micronaut 概述

· 阅读需 10 分钟

Micronaut 的英文名字由两部分拼接而成,“micro” 是“微小”,代表微服务,“naut”是船,代表的是载体。两部分的字面意思合并起来,可以理解为微服务的载体、微服务的运载之船。

PAC4J 新手入门,之四(更多概念)

· 阅读需 4 分钟

客户端、授权器与安全配置​

在之前的示例中,我们直接对接 pac4j,并让项目运行起来了。在 Pac4jConfig 中,我们最先的配置的即是客户端 Client。

        GitHubClient gitHubClient = new GitHubClient("a85f19ea0f51face127a", "84bf0695ea2a62674b8d5961a02a4c793bf23e2a");

GiteeClient giteeClient = new GiteeClient("da28980047eb2c732b8bcee4be567c6a4f38c6459587063f2607084c9c33b957",
"4cd81eac1dae28b698044ed5b55e2580da94aca7d872e11e5b47d6c8a3b0a26d");

PAC4J 新手入门,之三(自定义 OAuth2.0 客户端)

· 阅读需 10 分钟

认证协议概述​

我们常见的认证协议,包括 OAuth、SAML、CAS 和 OpenID Connect 等。在这些协议中,OAuth 协议只定义了基本的协议架构,但没有明确要求 API 如何指定,因而针对不同的协议提供厂商,需要开发不同的客户端进行对接。这些客户端最大的差异在于用户 API 响应的数据定义千差万别,所以自定义客户端最主要的实现是对用户数据的解析。

本篇我们以对接 Gitee 的 OAuth2.0 为例,实现自定义客户端。

PAC4J 新手入门,之二(框架引入)

· 阅读需 8 分钟

对接目标及 pac4j 依赖​

我们以对接 GitHub 进行实战,能从项目指定路径 /login/github 跳转 GitHub 认证后,获取登录用户的相关信息在界面展示,其他 API 配置为不受此认证限定。

文档工具怎么选?一次性告诉你

· 阅读需 6 分钟

一个好的软件,需要一个好的文档,一个好的文档,需要一个好的工具。工欲善其事,必先利其器。

在我们写文档之前,选择一个好的工具,将会使用我们的工作事半工倍。

如何写好文档

· 阅读需 10 分钟

你的产品有多好并不重要,因为如果它的文档不好,人们就不会使用它。即使他们因为别无选择而不得不使用它,如果没有好的文档,他们也不会有效地使用它或按你希望的方式做。

几乎每个人都明白这一点。几乎每个人都知道他们需要好的文档,大多数人都试图创建好的文档。但大多数人都失败了。

PAC4J 新手入门,之一(概述及准备)

· 阅读需 5 分钟

什么是 pac4j​

pac4j 是一个简单而强大的安全框架,用于 Java 验证用户、获取用户配置文件和管理授权,以保护 web 应用程序和 web服务。

它提供了一套全面的概念和组件。它适用于大多数框架/工具,并支持大多数认证和授权机制。它的开源授权协议为 Apache 2。

一猪三吃,看看这个项目就够了(之一)

· 阅读需 13 分钟

在上一系列,对 RuoYi(若依)的单体项目比较简单地进行了探秘。虽然 RuoYi 的单体项目有很多不足,但是瑕不掩瑜,RuoYi 还是一个在小项目、验证项目、紧急项目时,可用的基础框架项目。本系列将会品鉴一个更有意思的项目:pig。

最火后台管理系统 RuoYi 项目探秘,之四

· 阅读需 20 分钟

上篇中,我们对 Shiro 框架做一个简单的扩展了解,稍微了解了一些 Shiro 的概念及运行逻辑,然后我们发现了在用户登录成功后,RuoYi 对用户授予了角色和菜单,这两个数据是如何来的,又是怎么样使用的,本篇将会进行探究。

最火后台管理系统 RuoYi 项目探秘,之三

· 阅读需 12 分钟

上篇中,我们初步探究了 RuoYi 项目是如何进行登录信息传输、验证码校验、密码校验,以及密码存储安全性方案。我们了解到,整个的验证实现是围绕 Shiro 框架进行的,而数据的传输安全性,RuoYi 是没有考虑的,如果我们做的是要求安全等级比较高的项目,需要考虑采用 https 协议,并对关键数据进行加密后传输,一般会使用非对称密码算法进行加解密。

本篇,我们主要会针对 Shiro 框架做一个简单的扩展了解,然后再初窥 RuoYi 的菜单、权限功能。

最火后台管理系统 RuoYi 项目探秘,之二

· 阅读需 18 分钟

上篇中,我们初步观察了 RuoYi 的项目结构,并在最后实际运行起了项目。我们也发现了作者不好的代码习惯,作为反例,我们应该要养成良好的编码习惯。本篇开始,我们会按照 Web 界面逐一对具体子项目的实现的功能进行探秘。

最火后台管理系统 RuoYi 项目探秘,之一

· 阅读需 16 分钟

我们正在探秘各种比较火热的后台管理相关的开源项目,探秘结果将以系列文章的形式分享。希望你能在这些文章中学习别人的优点,也能看到别人的不足,进而可以提升自我的技术能力或技术态度,不论是提升了什么,只要你有收获即可。

“你若不离不弃,我必生死相依”,是一句非常痴情的话,也常被人化用于孩子的名字,寄托父母美好的期望。

今天要探的这个最火后台管理系统 RuoYi(若依),便是作者化用女儿的名字命名的项目。

云上使用 Redis?十件事必知!

· 阅读需 14 分钟

本文翻译自 Using Redis on Cloud? Here are ten things you should know。

我们很难操作大规模的有状态的分布式系统,Redis 也一样不能例外。托管数据库承担了许多繁重的工作,让我们生活更加轻松。但你仍然需要一个良好的架构,并在服务器(Redis)和客户端(应用程序)上应用最佳实践。

本文涵盖了一系列与 Redis 相关的最佳实践、技巧和窍门,包括集群可伸缩性、客户端配置、集成、指标等。虽然我会不时引用 Amazon MemoryDB 和用于 Redis 的 ElastiCache ,但大多数情况(即使不是全部)都适用于 Redis 集群。

Maven仓库发布组件

· 阅读需 10 分钟

一般,我们如果开发了一个工具组件,肯定想将它发布以供其他人使用。在公司内部,我们可以将其发布到私有仓库,在互联网环境,我们一般将其发布到 maven 中央仓库。以下以我们最近开发的java工具 flyRafter 进行介绍,如何将一个组件发布到 maven 中央仓库。

Elasticsearch 从入门到学会之一(什么是Elasticsearch)

· 阅读需 6 分钟

官方概要介绍如下:

Elasticsearch 是位于 Elastic Stack 中心的分布式搜索和分析引擎。Logstach 和 Beats 促进采集、合计以及充实你的数据并在 Elasticsearch 中存储它们。Kibana 允许你去交互式的探索、可视化和共享对数据的见解,以及监视这个栈(Elastic Stack)。Elasticsearch 是索引、搜索和分析的神奇所在。

GitHub Pages Jekyll 代码高亮

· 阅读需 2 分钟

本文介绍Jekyll代码高亮

GitHub Pages目前使用的Jekyll 3.0,和我们博客相关的特性就有:

  • 仅支持kramdown解析Markdown
  • 仅支持Rouge作为Markdown代码语法高亮

多项目部署为同一个GitHub Pages

· 阅读需 4 分钟

由于GitHub 的约定,一个账户只能拥有一个GitHub Pages,那么,如果你有多个想部署的静态网站(博客和文档等),它们是互相隔离的,如何用同一个GitHub账户进行部署呢?

从之前如何搭建GitHub Pages的系列文章用GitHub Pages搭建博客(一),我们知道Jekyll或者Hexo实现的静态网站的配置中,常常要指定一个当前网站的目录。

双十一,聊一聊浪漫

· 阅读需 4 分钟

2020年的“双十一”又要来到。很多直男朋友又要陷入被女朋友、被老婆抱怨不懂浪漫的时刻。直男们纷纷感到很委屈:啥是浪漫啊? 我并不喜欢“直男”这个语汇。因为有“直”必有“弯”,虽然这不可否认,但当直男总被冠上“不懂浪漫”的标签时,不正是想表明“弯男”更懂浪漫么?可女性会和“弯男”在一起吗?答案是显而易见的。

八卦一下&也谈《国内首个.NET 5框架》

· 阅读需 5 分钟

前几日,博客园上出现了一篇文章《国内首个 .NET 5 框架 Fur 斩获 1000 stars,1.0.0-rc.final.20 发布》。此文一出,立即引发了吃瓜程序员的好奇,大家纷纷好奇:国产框架到了一个新的高度了吗?

用GitHub Pages搭建博客(六)

· 阅读需 5 分钟

本篇介绍GitHub Pages网站加速

在上一篇提到如何对GitHub Pages配置自定义域名。其实,不论GitHub Pages的默认域名还是自定义域名,都使用了GitHub的CDN进行加速,虽然速度还行,但总还是觉得有点慢。

用GitHub Pages搭建博客(五)

· 阅读需 3 分钟

本篇介绍GitHub Pages自定义域名

在**用GitHub Pages搭建博客(二)**中介绍到,默认的GitHub Pages域名就是仓库地址,即:

账号名.github.io

用GitHub Pages搭建博客(四)

· 阅读需 5 分钟

本篇介绍配置网站参数及发布文章

GitHub Pages一般使用的Jekyll,配置项基本都设置在_config.yml文件中,在此文件中,按参数描述进行配置即可。此处以上一篇使用的Jekyll主题为例进行介绍。

用GitHub Pages搭建博客(一)

· 阅读需 2 分钟

GitHub官网介绍 GitHub Pages

官网是这样介绍的:

Websites for you and your projects.

给你和你的项目的网站。

Hosted directly from your GitHub repository. Just edit, push, and your changes are live.

从你的GitHub仓库中直接托管。只用编辑、发布,你的修改直接生效。

《边城》与编程

· 阅读需 3 分钟
阿呜
系统架构师

  沈从文先生写了一篇小说《边城》,讲湘西的故事,以兼具抒情诗和小品文的优美笔触,描绘了湘西地区特有的风土人情;借船家少女翠翠的纯爱故事,展现出了人性的善良美好。

  由于“边城”与“编程”的谐音,程序员之间,也会偶尔会调侃一句:沈从文先生可是咱们编程界的祖师爷。