My name is Ryan, and I hate jargon. I hate jargon because I am ill-equipped to remember it, but the reason why I still write decent code is that I am well equipped to understand the concepts which these jargon words point to.

我的名字叫瑞安(Ryan)，我讨厌行话。 我讨厌行话，因为我没有足够的能力去记住它，但是我仍然写得体的代码的原因是我有能力理解这些行话所指向的概念。

In this article, I will talk about three things that go together (testing, architecture, and legibility), and when you should start to care about them. While this is partly a subjective question, there actually exists a fairly concrete answer to this question and I need not use big scary words to explain it.

在本文中，我将讨论结合在一起的三件事(测试，体系结构和易读性)，以及何时应该开始考虑它们。 尽管这在一定程度上是一个主观的问题，但实际上对此问题存在一个相当具体的答案，我不需要用大胆的措辞来解释它。

This article covers:

本文介绍：

• Why some people do not bother with tests, architecture, and writing legible code, and when this is a reasonable thing to do

  为什么有些人不理会测试，体系结构和编写清晰的代码，以及何时这样做是合理的事情

• How the scale and complexity of your program can give you a clear intuition on when you should care about that stuff

  程序的规模和复杂性如何使您清楚何时应该关心这些内容

• What the actual benefit of applying this stuff is in clear terms and examples

  应用这些内容的实际好处是在明确的术语和示例中

• A quick series of questions you can ask yourself to make the decision easier您可以问自己一系列快速的问题，以使决策更加容易

为什么有人说不？(Why Do Some People Say No?)

If you have had the misfortune of trying to learn about software architecture or testing your code, then you have probably been met with:

如果您不幸尝试学习软件体系结构或测试代码，那么您可能会遇到：

• Endless testing libraries无休止的测试库
• Endless opinions on which libraries to use关于使用哪些库的无休止的意见
• Endless opinions on test coverage关于测试范围的无休止的意见
• Endless debate on whether test driven development is mandatory or a complete waste of time关于测试驱动开发是强制性的还是完全浪费时间的无休止的辩论

• Endless debates on the best software architecture for all situations (pro tip: it doesn’t exist)

  关于适用于所有情况的最佳软件体系结构的无休止的辩论(提示：不存在)

• And so on…等等…

In complete fairness, if the only thing you care about is turnaround time and how much money you make, then I absolutely admit that software architecture, testing, and legibility might be a waste of such resources. Make no mistake, there are cash cow applications out there which were built using the big ball of mud architecture and inadvertently bug tested by the users. So the person who reads that may reasonably say, if I do not need it, it is just a waste of billable hours and a great deal of studying.

公平地说，如果您唯一关心的是周转时间和收入，那么我绝对承认，软件体系结构，测试和易读性可能浪费这些资源。 没错，这里有很多摇钱树应用程序，这些应用程序是使用泥泞的体系结构构建的，并且用户不经意地测试了错误。 因此，阅读该书的人可能会合理地说，如果我不需要它，那只会浪费可计的时间和大量的学习。

Secondly, some of you reading this are beginners. You write very small applications (which is good, keep doing that!) where your goal is to learn a few things. Do you really need to use a test driven, designed by contract, multi-layered, clean architecture to build a simple calculator? Again, if I was to say you need to, then I am probably full of something that starts with an “s” and ends with “hit.” It depends on why you are writing the program.

其次，你们当中有些人是初学者。 您编写了很小的应用程序(这很好，请继续这样做！)，您的目标是学习一些知识。 您是否真的需要使用由合同设计的多层干净架构的测试驱动器来构建简单的计算器？ 同样，如果我是说你需要的话，我很可能充满了东西，开始以“S”，并结束与“命中”。 这取决于您编写程序的原因。

I am really selling you on these things, am I not?

我真的在这些东西上卖给你，不是吗？

为什么我仍然说是 (Why I Still Say Yes)

I am going to explain exactly what is going on here in an analogy that is very simple and probably familiar to anyone who studied elementary algebra. Do you remember when your teacher asked you to solve something like this…:

我将以一个非常简单的类比来解释这里到底发生了什么，对于学习基础代数的任何人来说可能都很熟悉。 您还记得您的老师要求您解决类似问题的时候吗……：

2x + 4 = 8; Solve for x

2x + 4 = 8; 解决x

…and the teacher asked you to show your work? Hopefully for a few of you, you just realized exactly where I am going when I make the argument that scale and complexity determines the effectiveness (net benefit) of testing, software architecture, and legibility.

…老师要求你展示你的作品？ 希望对你们中的一些人来说，当我提出规模和复杂性决定测试，软件体系结构和易读性的有效性(净收益)的论据时，您才确切地意识到了我的发展方向。

For those who do not see where I am going, I will break it down a bit more. I was that kid asking the teacher: “Why should I show my work when I can just think of the answer instantly in my head?” Unfortunately I did not have a good teacher, and I was not given the VERY CLEAR REASON why I should practice working through the steps of solving an equation; even when I do not need to.

对于那些看不到我要去的人，我将对其进行分解。 我当时是个小孩子，问老师： “当我脑海中瞬间想到答案时，为什么要展示自己的作品？” 不幸的是，我没有一个好老师，我也没有得到非常清楚的理由，为什么我应该练习解决方程式的步骤。 即使我不需要。

Some day lads and lassies, you will run into an equation which you simply cannot solve in your head. Yes, even the “smart kids” still eventually run into problems too complicated to solve instantly, as opposed to incrementally.

有时候，小伙子们和少女们会遇到一个方程式，而这个方程式你根本无法解决。 是的，甚至是“聪明的孩子”最终仍然碰上太复杂即时解决问题，而不是增量。

We now have:

我们现在有：

• A simple way to think about exactly the same conceptual problem expressed in both mathematics and computation (not by accident)一种简单的方法来思考在数学和计算中完全相同的概念问题(并非偶然)
• Some kind of objective ceiling on when saving time by doing things in your head will actually cost you way more than showing your work and proving each step as you go在通过脑子里的事来节省时间时，某种客观的上限实际上比花一些力气证明自己的工作并证明每一步的实际花费

那我的代码呢？(What About My Code Though?)

Below is an actual snippet from an open source project (which is admittedly more of a demo than anything else) of mine. If you are not able to read Kotlin or just not interested in parsing it, just scroll to the bottom where I will summarize the point of this example.

下面是我的一个开源项目的实际片段(公认的更多是演示，而不是其他任何内容)。 如果您不能阅读Kotlin或对解析它不感兴趣，只需滚动到底部，我将在此处总结本示例的要点。

/** * * On start basically means that we want to render the UI. This depends on whether the user is * anonymous, or registered (logged out or in), and if they are in public or private mode * a. User is anonymous (always private in that case) * b. User is registered, private mode * c. User is registered, public mode * * a: *1. Check isPrivate status: true *2. Check login status in backend if necessary *3. parse datasources accordingly *4. draw view accordingly */@Testfun `On Start anonymous`() = runBlocking {every { vModel.getIsPrivateMode() } returns true    every { vModel.getUserState() } returns null    coEvery { anonymous.getNotes(noteLocator) } returns Result.build { getNoteList }    logic.onChanged(NoteListEvent.OnStart)

    verify { vModel.getIsPrivateMode() }verify { vModel.getUserState() }verify { view.showList() }verify { adapter.submitList(getNoteList) }coVerify { anonymous.getNotes(noteLocator) }}/** * b: *1. Check isPrivate status: false *2. Check login status in backend if necessary *3. parse datasources accordingly *4. draw view accordingly * */@Testfun `On Start Registered Private`() = runBlocking {every { vModel.getIsPrivateMode() } returns true    every { vModel.getUserState() } returns getUser()    coEvery { registered.getNotes(noteLocator) } returns Result.build { getNoteList }    logic.onChanged(NoteListEvent.OnStart)    verify { vModel.getIsPrivateMode() }verify { vModel.getUserState() }verify { view.showList() }verify { adapter.submitList(getNoteList) }coVerify { registered.getNotes(noteLocator) }}/** * error: *1. Check isPrivate status: false *2. Check login status in backend if necessary *3. parse datasources accordingly *4. draw view accordingly * */@Testfun `On Start Error`() = runBlocking {every { vModel.getIsPrivateMode() } returns true    every { vModel.getUserState() } returns getUser()    coEvery { registered.getNotes(noteLocator) } returns Result.build { throw SpaceNotesError.RemoteIOException }    logic.onChanged(NoteListEvent.OnStart)

    verify { vModel.getIsPrivateMode() }verify { vModel.getUserState() }verify { view.showEmptyState() }verify { view.showErrorState(MESSAGE_GENERIC_ERROR) }coVerify { registered.getNotes(noteLocator) }}/** * For empty list, leave the loading animation active. */@Testfun `On Start a with empty list`() = runBlocking {every { vModel.getIsPrivateMode() } returns true    every { vModel.getUserState() } returns getUser()    coEvery { registered.getNotes(noteLocator) } returns Result.build { emptyList<Note>() }    logic.onChanged(NoteListEvent.OnStart)    verify { vModel.getIsPrivateMode() }verify { vModel.getUserState() }verify { view.showEmptyState() }verify { adapter.submitList(emptyList<Note>()) }coVerify { registered.getNotes(noteLocator) }}

The implementation details here are both literally and figuratively not interesting. However, the way I went about writing this code really is quite interesting (to me at least):

这里的实现细节从字面上和比喻上都没有意思。 但是，我编写该代码的方式确实很有趣(至少对我而言)：

The first thing I wrote was a plain language description of what happens:

我写的第一件事是对所发生情况的简单描述：

On start basically means that we want to render the UI. This depends on whether the user is anonymous, or registered (logged out or in), and if they are in public or private mode

开始时基本上意味着我们要呈现UI。 这取决于用户是匿名用户还是已注册(注销或登录)的用户，以及用户处于公开模式还是私有模式

The second thing I wrote was was a simple way of differentiating the different possible event streams that can occur for this single Unit/User Story/Whatever:

我写的第二件事是一种区分此单个Unit / User Story / Whatever可能发生的不同可能事件流的简单方法：

a. User is anonymous (always private in that case) b. User is registered, private mode c. User is registered, public mode

一种。 用户是匿名的(在这种情况下始终是私有的) b。 用户注册为私有模式c。 用户注册，公共模式

The third thing I wrote for each event stream was an itemized list of pseudo-code steps necessary to solve the problem:

我为每个事件流编写的第三件事是解决问题所需的伪代码步骤的逐项列出：

a:1. Check isPrivate status: true2. Check login status in backend if necessary3. parse datasources accordingly 4. draw view accordingly

答：1。 检查isPrivate状态：true2。 必要时检查后端的登录状态3。 相应地解析数据源4.相应地绘制视图

I even wrote a comment for an edge case where we successfully retrieve the user’s notes, but that list is empty:

我什至为一个边缘案例写了一条评论，其中我们成功检索了用户的笔记，但该列表为空：

For empty list, leave the loading animation active.

对于空列表，请保持加载动画处于活动状态。

The fourth thing I wrote was the tests themselves:

我写的第四件事是测试本身：

@Testfun `On Start anonymous`() = runBlocking {every { vModel.getIsPrivateMode() } returns true    every { vModel.getUserState() } returns null    coEvery { anonymous.getNotes(noteLocator) } returns Result.build { getNoteList }    logic.onChanged(NoteListEvent.OnStart)

    verify { vModel.getIsPrivateMode() }verify { vModel.getUserState() }verify { view.showList() }verify { adapter.submitList(getNoteList) }coVerify { anonymous.getNotes(noteLocator) }}

The last thing I wrote was the actual code which implements these test cases, after I ran them to make sure that they were well formed. They should fail because of the verification statements not evaluating to true, which we should expect from an unimplemented unit. Again, just skip over this if reading large blocks of code in unfamiliar languages is not your thing (fair enough):

我写的最后一件事是执行这些测试用例以确保它们格式正确之后的实际代码。 由于验证语句未评估为真，因此它们将失败，这是我们应该从未实现的单元中获得的期望。 再说一次，如果您不喜欢用不熟悉的语言来阅读大量代码(足够公平)，请跳过此步骤：

class NoteListLogic(dispatcher: DispatcherProvider,                    val noteLocator: NoteServiceLocator,                    val userLocator: UserServiceLocator,                    val vModel: INoteListContract.ViewModel,                    var adapter: NoteListAdapter,                    val view: INoteListContract.View,                    val anonymousNoteSource: AnonymousNoteSource,                    val registeredNoteSource: RegisteredNoteSource,                    val authSource: AuthSource)    : BaseLogic(dispatcher), CoroutineScope, Observer<NoteListEvent<Int>> {//...override fun onChanged(event: NoteListEvent<Int>?) {    when (event) {        is NoteListEvent.OnNoteItemClick -> onNoteItemClick(event.position)        //...        is NoteListEvent.OnStart -> onStart()        //...    }}

private fun onStart() {    getListData(vModel.getIsPrivateMode())}

fun getListData(isPrivateMode: Boolean) = launch {val dataResult = getPrivateListData()

    when (dataResult) {        is Result.Value -> {            vModel.setAdapterState(dataResult.value)            renderView(dataResult.value)        }        is Result.Error -> {            view.showEmptyState()            view.showErrorState(MESSAGE_GENERIC_ERROR)        }    }}suspend fun getPrivateListData(): Result<Exception, List<Note>> {    return if (vModel.getUserState() == null) {        anonymousNoteSource.getNotes(noteLocator)    }    else {        registeredNoteSource.getNotes(noteLocator)    }}

Now that we have some actual code to look at, what is the point? By following the process above, where the 5th thing I actually did was to write the code, I had actually saved myself a lot of time.

现在我们要看一些实际的代码，这有什么意义？ 按照上面的过程，实际上我做的第五件事是编写代码，实际上我节省了很多时间。

Again, to use our earlier analogy, the student may put up a hand and say: How the hell did all of that do anything but take extra time?

同样，使用我们以前的类比，学生可以举手说：到底该怎么做，除了花费额外的时间？

We shall go into that presently.

我们现在将讨论这一点。

— J. Krishnamurti

— J. Krishnamurti

实际利益 (The Actual Benefits)

What if I was to tell you, that by starting with human readable abstract descriptions of some aspect of my program, gradually adding detail by including itemized steps and event outcomes, and creating a logically provable test of whether my code actually does what it is supposed to do, I have made a complex implementation simple to write?

如果我要告诉你，那是从对程序某些方面的易于理解的抽象描述开始，通过逐项列出步骤和事件结果来逐步增加细节，并创建一个逻辑上可验证的测试，以验证我的代码是否真正执行了预期的操作要做，我使复杂的实现变得容易编写？

Perhaps so simple that it took me less time overall to follow that process than if I had just blindly jumped in and free wheeled the implementation.

可能是如此简单，以至于我花了更少的时间来总体上执行该过程，而这比我只是盲目地投入并随意实施该过程要少得多。

Perhaps by catching most of my logical/clerical errors of a single unit ahead of time in JVM tests (locally or on a Continuous Integration server), which can be automated and run faster than building and deploying the whole application to a device, I am saving myself a tremendous amount of time?

也许是通过在JVM测试中(本地或在Continuous Integration服务器上)提前捕获了单个单元的大多数逻辑/文书错误，该测试可以自动化并且比将整个应用程序构建和部署到设备上要快，因此为自己节省大量时间？

Perhaps, because I have the memory of a goldfish and cannot remember what I wrote two hours ago, a user story, pseudo-code description, and passing test (hopefully), means that I, or the next person to maintain this project do/does not even need to remember what I did hours ago?

也许是因为我记忆中的一条金鱼，不记得我两个小时前写的内容，所以，一个用户故事，伪代码描述和通过测试(希望)意味着我或下一个维护该项目的人会做/甚至不需要记住我几个小时前所做的事情？

Are you picking up what I am putting down here? If not, one of us has failed.

您要收拾我在这里放的东西吗？ 如果没有，我们中的一位失败了。

概要 (Summary)

Here is non-linear flow chart (if such a thing exists?) of questions to ask yourself before you decide to write a monolithic piece of garbage, or an over-engineered calculator:

这是在决定编写整体垃圾或过度设计的计算器之前要问自己的非线性流程图(如果存在这种情况？)：

• Is your primary goal to ship something that is made really quickly and hopefully functions well enough that it won’t tank with bad reviews? Skip the testing and architecture.

  您的主要目标是要运送出真正快速制造的产品，并希望其功能足以使它不会受到不良评价的影响吗？ 跳过测试和体系结构。

• Are you writing an application which is bloody complicated, and even some of the simpler features (from an outside perspective) must deal with several different IO devices in a single flow? Follow the timeless principles of good software architecture and if nothing else, test the classes which have complex logic.

  您是否正在编写一个非常复杂的应用程序，甚至某些更简单的功能(从外部角度来看)也必须在一次流程中处理多个不同的IO设备？ 遵循良好软件体系结构的永恒原理，如果没有其他要求，请测试具有复杂逻辑的类。

• Are you a student (self-taught like me or otherwise) who wants to learn the timeless principles of good software architecture by building a small application very well? Go for it kid/sir/madam; if you cannot follow these rules in a small application, why the hell would you assume you could follow them in a complex application?

  您是否想通过很好地构建小型应用程序来学习良好的软件体系结构的永恒原理的学生(像我这样的自学者)？ 去吧，孩子/先生/女士； 如果您不能在小型应用程序中遵循这些规则，那么为什么您会假设您可以在复杂的应用程序中遵循这些规则？

• Are you a software teacher who expects an extraordinarily large number of people to be learning from and scrutinizing your code? Well, I know what I would do.

  您是否是一名软件老师，希望有很多人从中学习和审查您的代码？ 好吧，我知道我会怎么做。

社交媒体| 支持 (Social Media | Support)

This article was written by Ryan Michael Kay. I am a self-taught programmer/engineer who creates educational content for on a wide variety of topics, on a wide variety of platforms. The best way to support me is to follow me on various platforms and join in with my developer community (we have hundreds of members!):

本文由Ryan Michael Kay撰写。 我是一个自学成才的程序员/工程师，他在各种平台上为各种主题创建教育性内容。 支持我的最佳方法是在各种平台上关注我，并加入我的开发人员社区(我们有数百名成员！)：

Announcements:https://www.facebook.com/wiseassbloghttps://twitter.com/wiseAss301

公告： https ： //www.facebook.com/wiseassblog https://twitter.com/wiseAss301

Tutorials & Courses:

教程与课程：

Free Tutorials, Live Q&A, Live Coding:https://www.youtube.com/channel/UCSwuCetC3YlO1Y7bqVW5GHg

免费教程，实时问答，实时编码： https ： //www.youtube.com/channel/UCSwuCetC3YlO1Y7bqVW5GHg

Java Desktop Programming w/ JavaFX (Intermediate) — https://skl.sh/31pzCa1

Java桌面编程瓦特/ JavaFX的(中级) - https://skl.sh/31pzCa1

Complete Beginner Introduction To Java Programming (Beginner — Intermediate) — https://skl.sh/3fZbjos

Java编程完整入门指南(初级—中级)— https://skl.sh/3fZbjos

Android Apps With Kotlin & Android Studio (Beginner) — https://skl.sh/2ZU6ZT9

具有Kotlin和Android Studio的Android应用程序(初学者)— https://skl.sh/2ZU6ZT9

Material Design Android Programming w/ Kotlin (Intermediate) — https://skl.sh/2OrwrYZ

带有Kotlin的Material Design Android编程(中级)— https://skl.sh/2OrwrYZ

Connect:

连接：

Discord Group — https://discord.gg/2XVvCW

不和谐集团- https://discord.gg/2XVvCW

Slack Group — https://join.slack.com/t/wiseass/shared_invite/zt-3p7p67p1-ZEvEhlrznbksmvzS0Qtunw

Slack组-https: //join.slack.com/t/wiseass/shared_invite/zt-3p7p67p1-ZEvEhlrznbksmvzS0Qtunw

LinkedIn-https://www.linkedin.com/in/ryan-kay-808388114/

领英-https ://www.linkedin.com/in/ryan-kay-808388114/