对冲基金小镇 鬼城_未来系统，代码寿命和网络鬼城

对冲基金小镇 鬼城

In this one-on-one episode of the Versioning Show, Tim and David discuss how compatible today’s technologies will be with future systems, how long software should last, project organization and progressive enhancement, the curly question of whether a piece of software retains its identity even with an entirely new codebase, and web ghost towns (#webGhostTown).

在Versioning Show的这一一对一节目中，Tim和David讨论了当今技术与未来系统的兼容性，软件应持续多长时间，项目组织和逐步增强，以及软件是否保留其原有功能的问题。即使使用全新的代码库和网络幽灵小镇(#webGhostTown)，也可以确保身份。

Visit the Versioning Show Home Page

访问版本控制显示主页

Subscribe on iTunes | Subscribe on Stitcher | View All Episodes

在iTunes上订阅 | 订阅Stitcher | 查看所有剧集

显示笔记 (Show Notes)

• #webGhostTown hashtag on Twitter

  #webGhostTown标签在Twitter上

• Tim’s project restaurantmenubuilder.com. (GitHub repo: RestaurantMenuGenerator)

  蒂姆(Tim)的项目restaurantmenubuilder.com 。 (GitHub仓库： RestaurantMenuGenerator )

• lean startup

  精益创业

• Gang of Four

  四人帮

• Apollo launch code on GitHub

  阿波罗在GitHub上启动代码

• webpack

  网络包

• RICG Responsive Images for WordPress

  WordPress的RICG响应式图像

• Jacob’s Ladder

  雅各的梯子

• Google Play Music

  Google Play音乐

• Say hello on Twitter: @mdavidgreen | @tevko | @versioningshow | @sitepointdotcom

  在Twitter上问好： @mdavidgreen | @tevko | @versioningshow | @sitepointdotcom

对话重点 (Conversation Highlights)

I don’t want to create a web ghost town. I don’t want to create large swaths of projects and libraries and frameworks that worked super well for a short time, but then, as you’re thumbing through the web on your phone, you just come across broken thing after broken thing after broken thing that’s just not relevant, not maintained anymore

我不想创建网络鬼城。 我不想创建大量的项目，库和框架，它们在短时间内都可以很好地工作，但是随后，当您在手机上浏览网页时，您会遇到一堆又一堆的问题无关紧要的东西，不再维护

---

---

That has to do with creating an environment in which a single developer or a small team can be remarkably productive, and produce these intricate and complex pieces of software. That comes at the cost of the abstraction. We’re not really conversant with every detail of what’s going on in our code the way that the folks who wrote the Apollo mission certainly were.

这与创建一个环境有关，在该环境中单个开发人员或小团队可以显着地提高工作效率，并生产这些错综复杂的软件。 这是以抽象为代价的。 我们并不是真的像编写Apollo任务的人那样熟悉代码中所发生的每一个细节。

---

---

I think that if you are going to start asking yourself, “How long should software last?”, you want to make sure of … organization — so that whenever you go back and look at this thing, you can actually know what you were doing at the time.

我认为，如果您要问自己“软件应使用多长时间？”，则要确保…的组织性-这样，每当您回头看一下这个东西时，您实际上就可以知道自己在做什么当时。

---

---

As a developer, you want to approach the software as “This is going to last maybe a year at most before I throw it all away and start over again.” As a user, you want it to be permanent. That is a very telling statement about the state of affairs.

作为开发人员，您希望将软件的使用方式定为“在我将其全部扔掉并重新开始之前，这种过程最多可能持续一年。” 作为用户，您希望它是永久的。 这是关于事态的非常有说服力的声明。

---

---

It’s certainly more satisfying to write clean code — code that you can show to somebody without being embarrassed. And that somebody is going to be you in six months, so you’d better not be embarrassed.

编写干净的代码肯定会更令人满意，因为您可以将代码展示给别人而不会感到尴尬。 而且六个月后有人会成为您 ，所以最好不要让您感到尴尬。

---

---

Code is like the mutant DNA virus thing that is just constantly changing and looking different.

代码就像突变的DNA病毒一样，只是不断变化并且看起来有所不同。

---

---

I typed that semicolon. I did, I did!

我打了分号。 我做到了，我做到了！

成绩单 (Transcript)

Tim: 蒂姆：

Hey, what’s up, everybody, this is Tim Evko …

嘿，大家好，我是Tim Evko……

David: 大卫：

… and this is M. David Green …

…这是大卫·格林(M. David Green)…

Tim: 蒂姆：

… and you’re listening to episode number nine of the Versioning Podcast.

…，您正在收听Versioning Podcast的第9集。

David: 大卫：

This is a place where we get together to discuss the industry of the web from development to design — with some of the people making it happen today, and planning where it’s headed in the next version.

在这里，我们可以聚在一起讨论从开发到设计的网络行业，其中一些人使之成为现实，并计划下一版的发展方向。

Tim: 蒂姆：

Today, it is just David and myself, and we’re going to be talking all about software. Specifically, when you’re building software, how long should that software last?

今天，只有David和我本人，并且我们将谈论软件。 具体来说，在构建软件时，该软件应使用多长时间？

So, we’re going to dive into that. We’re going to bring up some interesting perspectives and points, and yeah, life cycles.

因此，我们将深入探讨这一点。 我们将提出一些有趣的观点和观点，是的，生命周期。

So let’s go ahead and get this version started.

因此，让我们开始安装该版本。

David: 大卫：

If we were going to ask a philosophical question at the beginning of this episode, we’d have to ask it of a piece of software, because the software itself would need to know what version it was.

如果在本集开始时要提出一个哲学问题，我们将不得不问一个软件，因为该软件本身需要知道它是什么版本。

Tim: 蒂姆：

Yeah, and that’s a little bit tough to do.

是的，这很难做到。

David: 大卫：

Instead, since we’re going to talk about this topic: Tim, you brought up this topic. I’m curious what brought this to mind for you.

取而代之的是，由于我们将要讨论这个主题：Tim，您提出了这个主题。 我很好奇是什么让您想到了这一点。

Tim: 蒂姆：

Yeah. So, of course, I have a full-time job. I work on a team building a specific piece of software. It’s an ecommerce platform. It’s a website, and you go and you buy products from it.

是的 因此，我当然有一份全职工作。 我在一个团队中构建特定的软件。 这是一个电子商务平台。 这是一个网站，您可以从中购买产品。

Then I also have open-source projects that I work on on my own. I built a small project to help restaurant owners build menus out of HTML, PDFs and stuff like that. I have side projects inside libraries and I contribute to open-source stuff, and I work on this big, long lasting product at work.

然后，我还有自己开发的开源项目。 我建立了一个小项目，以帮助餐馆老板从HTML，PDF和类似的东西中构建菜单。 我在库中有一些辅助项目，并且为开放源代码做出了贡献，并且我致力于这款大型而持久的产品。

Often times, when working with others and just with working with myself, I tend to think, all right, I want to build this thing to last forever and to work on every device. And that’s a difficult pattern to get your head into — building for the future, to make things future proof. I often ask myself not only what is the right way to go about doing this, but is this even the right frame of mind to have for every specific thing that I’m working on?

很多时候，当我与他人一起工作时，或者只是与我自己一起工作时，我倾向于认为，我想让这个东西永久存在并在每台设备上工作。 这是一个很难进入的模式-为未来而建设，使事情成为未来的证明。 我经常问自己，不仅这样做的正确方法是什么，而且对于我正在从事的每一项特定工作，这甚至是正确的心态吗？

If I’m working on a quick library for dragging and dropping orange divs on a screen, do I, or should I, intend on making that thing super progressively enhanced and working on every single device and able to last into 2100 when we have the internet directly in our brains.

如果我正在开发一个用于在屏幕上拖放橙色div的快速库，那么我还是应该打算逐步增强该功能并在每台设备上都可以使用，并且当我们拥有2互联网直接在我们的大脑中。

David: 大卫：

I think it’s going to be up to the folks in 2100 to figure out how to access all of this stuff. I was just listening to a podcast recently. They were talking about the situation that NASA got itself into when it sent all of the data back from the original lunar probes.

我认为将由2100年的人们来决定如何访问所有这些东西。 我最近只是在听播客。 他们在谈论NASA从原始月球探测器发回所有数据时陷入的困境。

They were taking these huge photographs, and it was digital data, and it was sent back, and of course it was stored on the top-of-the-line, reel-to-reel tapes that they could possibly afford, and they made sure that it was as archived as it could be. But because the technology got completely out of date, they got themselves into a situation where there was only one copy on tape of this information apparently stored in whale oil, because that’s a thing.

他们正在拍摄这些巨大的照片，然后将其作为数字数据发送回去，并且当然将它们存储在他们可能负担得起的顶级卷对卷磁带上，确保它已尽可能存档。 但是由于该技术已经完全过时，他们陷入了这样的境地，即磁带上仅存储了显然是存储在鲸油中的该信息的一个副本，因为这是一回事。

Then the only way that they could play it back was fortuitously one employee had personally purchased reel-to-reel tape players that could play back this kind of tape, and stored it in a barn somewhere. And they had to dust it off and get these things working again.

然后，他们可以播放的唯一方法是，幸运的是，一名员工亲自购买了可以播放这种磁带的卷到卷磁带播放器，并将其存储在某个谷仓中。 而且他们必须清理掉灰尘并使这些东西重新工作。

The idea that anything is going to last forever starts to look a little bit iffy when we realize that some of the most sophisticated technology that we have put into place to try to store and retrieve data just from the last 20, 30 years is already impossible to retrieve.

当我们意识到我们已经采用了一些最复杂的技术来尝试存储和检索过去20、30年的数据时，一切都会永远持续下去的想法开始变得有些疑惑。检索。

Tim [3:48]: 蒂姆[3:48]：

That is both a very interesting story and an excellent point, because the technology 10, 20, 30 years from now — maybe even just 5 years from now — might look completely foreign to someone. Right now we write in JavaScript, and maybe that changes in 20 years. Maybe all these libraries and things that we’ve been building are just not going to be that in a certain amount of time.

这既是一个非常有趣的故事，又是一个很好的观点，因为从现在起10年，20年，30年(甚至距现在仅5年)的技术对于某人可能完全陌生。 现在，我们用JavaScript编写代码，也许这会在20年后发生变化。 也许所有这些库和我们一直在构建的东西在一定时间内都不会变成那样。

So then, I guess my question becomes, what do you build for? Because I have this innate sense of I want things to last as long as they need to. If I’m building something, and ten other people suddenly decide we want to also work on this thing, what frame of mind am I supposed to be in from the get-go, from the beginning. Before I write my first line of code, what should my goal for the lifetime of this project be?

那么，我想我的问题就变成了，您要做什么？ 因为我有这种与生俱来的感觉，我希望事情能够持续到需要的时间。 如果我正在构建某个东西，而其他十个人突然决定我们也要从事此事，那么从一开始我就应该处于什么样的心态。 在编写第一行代码之前，这个项目的整个生命周期的目标是什么？

David: 大卫：

It’s an interesting point. There’s the lean startup concept, where you basically build for the foreseeable current future and then adapt as you go. I think that you and I, as engineers, both have this desire to build something as beautifully as possible.

这是一个有趣的观点。 有精益创业的概念，您基本上是在可预见的未来中进行构建，然后随即进行适应。 我认为您和我，作为工程师，都渴望尽可能地创造出精美的东西。

The beauty of the code that we write is an important thing to us. Part of that is the beauty of being able to step back into code that you wrote six months ago or six years ago, and understand it, and have it operate, and have it adapt properly to what’s going on.

我们编写的代码之美对我们来说很重要。 其中的一部分在于能够回到六个月或六年前编写的代码，并理解它并使其运行并使其适应于所发生的事情，这是其优点。

I think it’s a challenge to come at it purely from an engineering perspective, because the issue that we’re talking about, it comes down to both a design issue and a business issue, I think. Because the use case is really a critical thing to consider. It depends on what you’re building and what the audience is supposed to be.

我认为，仅从工程角度来看这是一个挑战，因为我认为我们正在谈论的问题既可以归结为设计问题，也可以归结为业务问题。 因为用例确实是要考虑的关键问题。 这取决于您正在建设什么以及应该是什么样的听众。

Tim: 蒂姆：

That’s very true. So I’m thinking, let’s start off with, we have a project in mind. We have something that we want to build. What’s something that we can both agree on — regardless of the goal or the intended use of the thing — is important in terms of the lifetime of the project or the organization? I would say that important would be, all right, yeah, if for some reason I come across this code again in a year, at the very least, I want it to ascribe to a specific design pattern to ensure its readability and organization.

没错 所以我在想，让我们开始吧，我们正在考虑一个项目。 我们有一些要构建的东西。 在项目或组织的生命周期中，无论是目标还是预期用途，我们都可以达成共识的事情很重要？ 我要说的是，很重要，是的，如果出于某种原因，我至少一年后再次遇到此代码，至少我希望它归因于特定的设计模式，以确保其可读性和组织性。

David: 大卫：

That does make sense.

确实有道理。

Tim: 蒂姆：

Then I would say, because design patterns change, and so some people will say, “Oh, this decade it’s all about procedural code, and this decade it’s all about functional code.” At the very least, even if that does change, I can recognize a procedural versus object-oriented versus functional pattern when I see one.

然后我会说，因为设计模式会发生变化，所以有人会说：“哦，这十年与程序代码有关，而这十年与功能代码有关。” 至少，即使情况确实发生了变化，当我看到一个过程，面向对象还是功能的模式时，我仍然可以识别它。

So I can say, all right, if I stick to a specific pattern throughout the lifetime of this project, even if I go back ten years and say, What was I thinking? We totally don’t write code like this anymore. At the very least, I can recognize that, right, this code has a specific design pattern it ascribes to, and if I wanted to add or adjust, I can do that because it’s not all over the place.

因此，我可以说，如果我在这个项目的整个生命周期中都遵循特定的模式，即使我回到十年前说： 我在想什么呢？ 我们完全不再编写这样的代码。 至少，我可以认识到，对，这段代码具有特定的设计模式，如果我想添加或调整，我可以做到这一点，因为它并不存在。

David: 大卫：

That’s funny. Just even the phrase design pattern starts to make my skin crawl. I start thinking back to the days when I was working in Java (and I’m never working in Java again, trust me), I think it was the Gang of Four who did those design patterns things, and I remember a lot of what I learned in my early days as an engineer did come from design pattern thinking.

那很好笑。 只是短语设计模式开始使我的皮肤爬行。 我开始回想起我在Java中工作的日子(相信我，我再也不再在Java中工作了)，我认为是四人帮派完成了这些设计模式的事情，我记得很多事情我在早期的工程师时代就从设计模式思维中学到了知识。

Then in later years, what I’ve discovered is that one or two patterns will become popular or useful, and then they’ll become renamed and people will start using them in different contexts. I don’t know if people are going to be able to think in terms of design patterns for the long term, when looking back at what they’re doing.

然后在后来的几年中，我发现一种或两种模式将变得流行或有用，然后将其重命名，人们将开始在不同的上下文中使用它们。 我不知道人们回头看看自己在做什么时，是否能够长期考虑设计模式。

What you’re talking about is the archaeology of code at this point, because you’re talking about ten years from now, somebody looking at code that was written today. How are they going to decipher what the intent of the embedded culture that’s in that code, where that comes from? Since design patterns are documented from, what, 20 years ago to now, that’s a good place to start. But I’m wondering: it feels to me like we’re evolving in so many different directions that maybe that’s not adequate.

您正在谈论的是此时的代码考古，因为您谈论的是十年后的今天，有人在看今天编写的代码。 他们将如何解释该代码中的嵌入式文化的意图是什么？ 由于从20年前到现在都记录了设计模式，所以这是一个不错的起点。 但是我想知道：在我看来，我们正在朝着许多不同的方向发展，也许这还不够。

Tim [8:08]: 蒂姆[8:08]：

You definitely have to go further than that. Let’s say, all right, so we have a specific type of way that we want to organize our code so, at the very least, it’s readable. This is just for the thought experiment of writing code that’s supposed to either last long or just be generally durable for as long as it needs to be.

您绝对必须比这更进一步。 可以说，好吧，所以我们有一种特定类型的方式来组织代码，因此至少是可读的。 这仅用于编写代码的思想实验，该代码应该持续很长时间，或者只要需要就可以持久使用。

Then it gets a little bit murky, because we have our code structured in a specific way, but then nobody writes code like just, all right, we start with machine code and then we write everything and we have everything we need just siloed here. People use libraries and frameworks and different tools. That means that it really does start to, right off the bat, depend on (at least to me) it starts to depend on the intent of the project. Because if I’m writing something that is — I don’t know — A UI for a utility company, I probably want that to last as long as possible.

然后它变得有点模糊，因为我们以特定的方式构造了代码，但是没有人像这样写代码，好吧，我们从机器代码开始，然后我们编写了一切，然后我们有了所需的一切。 人们使用库和框架以及不同的工具。 这意味着它确实确实开始(至少对我而言)开始依赖于项目(至少对我而言)。 因为如果我正在写的是(我不知道)公用事业公司的UI，那么我可能希望它持续尽可能长的时间。

But if I’m doing something that’s like a specific Oculus VR site for some product that maybe will only last for five years, then I don’t necessarily have the same goals.

但是，如果我正在为某个产品执行某项特定于Oculus VR网站的工作，而该产品可能仅会持续五年，那么我不一定有相同的目标。

Yeah, I’ve got my design pattern, or the way that I want to structure my code so it’s readable, but after that, when it starts to be, all right, now if I’m going to reach for this library, then I have to think about, is this going to be the thing that no longer makes sense or is usable in the next couple of years? Or if I’m using this specific build tool, if I have to go back to this thing a few months or a few years from now, am I going to have to dust off an old machine so I can run this version of Node that this thing only runs in?

是的，我有自己的设计模式，或者是我想要构造代码以使其可读的方式，但是在那之后，当它开始存在时，好吧，现在，如果我要去这个库，那么我必须考虑，这是否将不再有意义或在未来几年内可用？ 或者，如果我使用的是特定的构建工具，或者从现在开始几个月或几年后又要回到这个问题上，我是否必须清理旧机器，以便可以运行该版本的Node这东西只在里面跑吗？

Yeah, if you’re planning these things out, you pretty much have to start considering it right off the bat. I thought maybe we could list some of the things we’d agree upon. We could get set, right up until we had to decide what the intent of the project was. But it seems like almost immediately you have to do that.

是的，如果您正在计划这些事情，那么您几乎必须立即开始考虑。 我认为也许我们可以列出一些我们同意的事情。 我们可以开始准备，直到必须决定项目的意图。 但是，似乎几乎必须立即这样做。

David: 大卫：

Especially the way that the libraries and frameworks, they change versions constantly, their dependencies change versions constantly. You need to lock in a particular stack, with exactly the set of dependencies, with exactly the set of versions. You get locked in that way, then you don’t have the opportunity to advance and take advantage of new technologies and new tools.

尤其是库和框架不断更改版本，其依赖项不断更改版本的方式。 您需要使用完全相同的依赖项和完全相同的版本集来锁定特定的堆栈。 您将以这种方式被锁定，那么您将没有机会前进并利用新技术和新工具。

Then you also get locked out of changes in the browsers, the changes in the environment. If you’re developing for browsers, you and I doing front-end work, we would be thinking in terms of developing for browsers. It’s the same thing with server technology, and with any context: that that context can change right from under your feet.

然后，您还被锁定在浏览器的更改，环境的更改之外。 如果您正在为浏览器进行开发，并且您和我都在做前端工作，那么我们会考虑为浏览器进行开发。 服务器技术和任何上下文都是相同的：上下文可以从您的脚下直接更改。

Unless you are on the same machine with the same operating system in the same stack of software — the same versions of all of those pieces and nothing has been updated, and all of the users of your software are also in that same context — the long-term implications are just impossible to predict. There are only certain contexts in which you can really restrict that.

除非你是在同一台机器使用相同的操作系统软件放在同一堆栈上-已更新所有这些作品并没有什么的相同版本，并且所有软件的用户也都在同一背景下-长长期影响是无法预测的。 在某些情况下，您可以真正限制它。

I’m thinking, for example, of the medical insurance industry, the government contracting, the banking industry, a lot of these areas. Microsoft had trouble getting these companies to upgrade past the old versions of their operating system, because they were locked in to those older versions. It ended up being a situation where, as I recall, everybody was screaming for Microsoft to finally end-of-life Internet Explorer 6. Microsoft couldn’t do it, because so many of their customers were locked into these versions of the software that they would have had to re-engineer their entire platforms in order to support a new operating system.

例如，我在考虑医疗保险业，政府合同制，银行业等许多领域。 微软很难让这些公司升级到旧版本的操作系统，因为它们被锁定在那些旧版本中。 最终，我回想起每个人都在向Microsoft尖叫，要求最终终止Internet Explorer6。Microsoft无法做到这一点，因为他们的许多客户都被锁定在这些版本的软件中，他们必须重新设计整个平台才能支持新的操作系统。

Tim: 蒂姆：

That’s almost the scary thing for me to think about, because when I’m thinking about building software, or even just building something on the front end, how do you approach that for saying, all right, if this thing is important enough to need to last for a very long time, that means that I really have to take into consideration the types of tools and frameworks that I’m using. Because, again, if I need to update it, I could get into some trouble where I just might not be able to.

对于我来说，这几乎是一件令人恐惧的事情，因为当我考虑构建软件，甚至只是在前端构建某些东西时，如果这件事足够重要，那么您如何处理这个问题呢？持续很长时间，这意味着我确实必须考虑所使用的工具和框架的类型。 因为，再次，如果我需要更新它，我可能会遇到一些我可能无法解决的麻烦。

But, not to stray too far away from the original question, how long should software last? It seems like we’re getting into this area where, due to the pace of how quickly the web changes, it seems very difficult to write software that can truly last long.

但是，不要偏离原始问题太远，软件应使用多长时间？ 似乎我们正在进入这个领域，由于网络变化的速度，似乎很难编写可以持续很长时间的软件。

David [12:21]: 大卫[12:21]：

Yet, the other thing that’s happening simultaneously is we’ve got the open source community. Because of the open source community, we’re in a situation where software can be released a decade ago, and because people are constantly updating it, and there’s a whole swarm of people crowd programming this, it can be maintained and kept up to date and adapted and forked to support all of these different environments — so that what is currently in existence, supporting whatever environments people want, may have very little relation to what was originally published as the beginning of an open-source project. Yet it’s still the same piece of software.

但是，同时发生的另一件事是我们有了开源社区。 由于存在开源社区，我们处于一种可以在十年前发布软件的情况下，并且由于人们不断地对其进行更新，并且有一大群人对此进行了编程，因此可以对其进行维护和更新。并进行了改编和分叉以支持所有这些不同的环境—因此，现有的，支持人们想要的任何环境的内容可能与最初作为开源项目的开始发布的内容之间没有任何关系。 但是它仍然是同一软件。

So when you talk about the lifespan of software, you have to realize that it’s morphing, and it’s evolving constantly, as long as it’s alive. And that’s the only way that it can stay alive.

因此，当您谈论软件的寿命时，您必须意识到它在不断变化，并且只要它还存在，它就会不断发展。 这是它可以存活的唯一方法。

Tim: 蒂姆：

Yeah, it would have to be that way. I was looking at Apollo launch code that was on GitHub. I think it was this week it was released on GitHub. It was amazing. It was absolutely amazing, just to look at — this thing landed a thing on the moon. That’s amazing.

是的，一定是那样的。 我正在查看GitHub上的Apollo启动代码 。 我认为这是本周在GitHub上发布的。 太神奇了 。 这是绝对惊人的，只是为了看看-这件事情登上月球的事情。 棒极了。

But code back then, I feel, was a little bit different from code today — at least in the space that I operate. Because now if it were just, all right, I’m writing a simple JavaScript program, I could totally see that. Now I’m writing my JavaScript, and then I’m having webpack transpile into ES6, and then I’m having those split up into different components. Then that’s going to be server rendered, and we have this framework doing this thing. That to me seems a little bit more difficult, because you can still save that code, but when it comes time to run it, you have to hope that all of these different intricacies still work.

但是，我觉得当时的代码与今天的代码有些不同-至少在我操作的空间上。 因为现在，如果可以，我正在编写一个简单JavaScript程序，因此完全可以看到。 现在，我正在编写JavaScript，然后将webpack转换为ES6，然后将它们拆分为不同的组件。 然后将由服务器呈现，并且我们有这个框架来做这件事。 在我看来，这有点困难，因为您仍然可以保存该代码，但是当需要运行该代码时，您必须希望所有这些不同的复杂性仍然有效。

David: 大卫：

You introduce an interesting point there with the transpiling too, because, frankly, you could have the transpiler evolve, and the code itself stays exactly the same, but constantly have it transpiled to match whatever the current environment would need to be. In which case, it would just be about maintaining the semantics of your own code in a way that is consistent with the way that the transpiler expects it to be. Then rely on the transpilers to maintain the currency of the code.

您在转译中也介绍了一个有趣的观点，因为坦率地说，您可以让转译器进行演化，并且代码本身保持完全相同，但是不断进行转译以匹配当前环境需要的任何东西。 在这种情况下，将仅以与编译器期望的方式一致的方式维护您自己的代码的语义。 然后依靠编译器来维护代码的货币。

Tim: 蒂姆：

I think we’re discovering something very interesting here: that when you’re asking yourself, “How long should this software last?”, the answer is that it’s never going to last forever, of course. I think we’ve also realized that when you do ask yourself, “How long should this software last?”, it really depends on not just what the software provides, but what type of software it is. If we’re talking about something for the front end, that is going to have a different lifetime than an OS or a browser.

我认为我们在这里发现了一些非常有趣的东西：当您问自己“该软件应使用多长时间？”时，答案是，它永远不会永远持续下去。 我认为我们也已经意识到，当您问自己“该软件应使用多长时间？”时，它的确不仅取决于软件提供的内容，还取决于软件的类型 。 如果我们在谈论前端的东西，那将与操作系统或浏览器的生命周期不同。

David: 大卫：

Makes a good case for prototype engineering as well. One of the things I’ve resisted at some companies that I’ve worked at is the idea of bringing in a prototype engineer to do pre-development on things, because I know often what is the prototype will end up becoming the production code. It won’t be resilient enough, or it won’t be performant enough.

也为原型工程提供了很好的案例。 我在一些工作过的公司中一直抵制的事情之一就是引入一个原型工程师来进行事前开发，因为我经常知道什么是原型最终会成为生产代码。 它的弹性不足，或者性能不足。

On the other hand, the point that you’re making, front-end code needs to adapt, needs to change so quickly, that it’s arguable that maybe there’s a place for the idea that with the code that you’re writing for the front end should be viewed as prototype code until you get a performance block. At which point, then you need to go in and make things more performant. Of course, that also negates the issues of security, because front-end code certainly opens up a lot of security holes. You can’t have prototype code doing that type of thing.

另一方面，您要指出的一点是，前端代码需要适应，需要如此快速地更改，以至于可能存在这样的想法：您为前端编写的代码在获得性能块之前，应将end 视为原型代码。 在这一点上，那么您需要进行改进，使性能更高。 当然，这也消除了安全性问题，因为前端代码无疑会打开很多安全漏洞。 您不能使用原型代码来执行此类操作。

Tim [16:00]: 蒂姆[16:00]：

Yeah, especially in high-security industries like banking and insurance. That’s interesting. So, building software, asking ourselves how long it should last, I’m starting to think that two things, a) it’s never going to be very long, but b) if you want it to last very long, you do have to be concerned about dependencies and tooling.

是的，尤其是在银行和保险等高安全性行业中。 那很有意思。 因此，构建软件，问自己应该持续多长时间，我开始认为有两件事，a)永远不会很长，但是b)如果您希望它持续很长时间，则必须关注依赖关系和工具。

David: 大卫：

Mh-hmm. We as engineers I think need to be prepared to answer those questions from an engineering perspective, but clearly there’s a whole set of related questions that need to come from the business side and from the design side of the company, to determine whether or not it’s even relevant to concern ourselves with the lifespan of the software.

嗯 作为工程师，我认为我们需要做好从工程角度回答这些问题的准备，但是很显然，有一整套相关问题需要从公司的业务方面和设计方面来确定。甚至与软件的使用寿命有关。

We as engineers again need to be able to point out that there are costs and benefits and tradeoffs associated with making these decisions having to do with the lifespan of a piece of software, so that when somebody who’s funding a project has to make the decision about where those tradeoffs go, they’ll have adequate information, but there’s a lot to consider.

作为工程师，我们再次需要指出，做出这些决定与成本，收益和权衡取舍都与软件的寿命有关，因此，当为某个项目提供资金的人不得不做出有关该决定的决定时，那些权衡取舍的地方，他们将有足够的信息，但还有很多需要考虑的地方。

Tim: 蒂姆：

It seems that today’s modern development environment is very much angled towards developer productivity and ease of use and quick prototyping. A lot of libraries and tools and frameworks have emerged to make that a reality.

当今的现代开发环境似乎与开发人员的生产力，易用性和快速原型制作密切相关。 已经出现了许多库，工具和框架来实现这一目标。

On the opposite side of that, it seems to me like the existence of a whole bunch of new tools and libraries and frameworks, because there are so many, will shorten the life time, or the time that your software is relevant and usable for a large group of people. It seems like the existence of a lot of tools and libraries and frameworks will shorten that lifetime. Does that even matter? Is that something that developers should be concerned about?

相反，在我看来，似乎有一堆新工具，库和框架的存在，因为有太多的新工具，库和框架会缩短生命周期，或者缩短您的软件对某个产品有意义并可用的时间。大群人。 似乎许多工具，库和框架的存在将缩短其寿命。 这有关系吗？ 这是开发人员应该关注的事情吗？

David: 大卫：

I’m going to say that I agree with you, because I do think that it does matter as to your second point. To your first point, what that makes me think about is the level of abstraction that we get from what is actually produced versus what we’re writing. You were mentioning transpiling before, and transpiling is just one piece of it, because not only are we transpiling, we’re pulling in libraries, we’re pulling in frameworks.

我要说的是我同意你的观点，因为我确实认为这对你的第二点很重要。 首先，让我想到的是我们从实际产生的内容到编写的内容所得到的抽象水平。 您之前曾提到过转堆，而转堆只是其中的一部分，因为我们不仅在进行转堆，还在引入库，也在引入框架。

We’re building on top of this huge house of cards of code and context that we really don’t know everything about what we’re doing. If we could possibly know everything that’s going into a typical codebase these days, we’d all be geniuses. We’d all have heads that are so huge that it wouldn’t be able to fit on our bodies, because there’s so much to keep track of.

我们建立在庞大的代码和上下文卡片之上，我们真的不知道我们在做什么。 如果我们今天能知道典型代码库中的所有内容，那我们都是天才。 我们所有人的脑袋都太大了，以致无法贴合在我们的身体上，因为有很多东西需要跟踪。

Tim: 蒂姆：

Yeah.

是的

David: 大卫：

That has to do with creating an environment in which a single developer or a small team can be remarkably productive, and produce these intricate and complex pieces of software. That comes at the cost of the abstraction. We’re not really conversant with every detail of what’s going on in our code the way that the folks who wrote the Apollo mission certainly were.

这与创建一个环境有关，在该环境中单个开发人员或小团队可以显着地提高工作效率，并生产这些错综复杂的软件。 这是以抽象为代价的。 我们并不是真的像编写Apollo任务的人那样熟悉代码中所发生的每一个细节。

Tim: 蒂姆：

I think that is the core of my question there, and that’s the core of the topic for this episode. I’m thinking to myself, I don’t want to create a web ghost town. I don’t want to create large swaths of projects and libraries and frameworks that worked super well for a short time, but then, as you’re thumbing through the web on your phone, you just come across broken thing after broken thing after broken thing that’s just not relevant, not maintained anymore — because we’ve built for ourselves this environment of rapid iteration, quick things because of all this abstraction, but again, at the cost of this is built to work now. Again, I’m not really sold on the does this super matter right now for us part? It’s a creeping suspicion that in a couple of years, we will get to this web ghost town state.

我认为这是我的问题的核心，也是本集主题的核心。 我在想自己，我不想创建网络鬼城。 我不想创建大量的项目，库和框架，它们在短时间内都可以很好地工作，但是随后，当您在手机上浏览网页时，您会遇到一堆又一堆的问题无关紧要的东西，不再维护了–因为我们已经为自己构建了这种快速迭代的环境，由于所有这些抽象，因此可以快速构建事物，但是又一次牺牲了代价，现在就可以工作了。 再说一次，我对这个超级重要的东西真的不满意。 令人毛骨悚然的怀疑是，几年后，我们将到达这个网络鬼城州。

David [19:50]: 大卫[19:50]：

It’s definitely something people need to keep in mind. I think if I were architecting a new project for a large client right now, it would be one of the key critical questions that I would ask. Because you have to choose from the available technologies, and you have to be compatible with all of the available environments that are relevant for a particular project. In order to do that, you need to build on top of this huge infrastructure, and you need to know just how much control you have over that and how relevant that is to whatever company you’re working for.

人们绝对需要牢记这一点。 我想如果我现在正在为一个大客户设计一个新项目，那将是我要问的关键关键问题之一。 因为您必须从可用技术中进行选择，并且必须与特定项目相关的所有可用环境兼容。 为了做到这一点，您需要在这个庞大的基础架构之上构建，并且您需要知道您对此拥有多少控制权，以及与您所工作的任何公司的相关性。

I suppose in that sense, it’s fortunate that for most commercial applications, the lifespan — you shouldn’t be thinking more than a year or two out, because the context is going to change so much in a year or two. Whereas in certain industries where security or the infrastructure is very critical, they freeze that. In that case, the variables we’re talking about go away because that’s all been frozen for the users, and they’re forced to use IE 6 until 2011 or whatever, because it’s mandatory for them to be able to control every element.

从这种意义上讲，我想很幸运，对于大多数商业应用程序来说，寿命–您不应该考虑超过一两年，因为情况将在一两年内发生很大变化。 在某些对安全性或基础架构至关重要的行业中，它们却冻结了这一点。 在那种情况下，我们正在谈论的变量会消失，因为所有这些变量都已冻结给用户，并且他们被迫使用IE 6直到2011年或其他任何时候，因为对他们来说，控制每个元素是强制性的。

Tim: 蒂姆：

Yeah, very good points. I do definitely hope that, while it feels like the Wild West right now in terms of technologies and capabilities and what people build to provide those abstractions, that we don’t get the opposite of that, which is like web ghost towns. I’m just going to coin that phrase now, so everybody start using it, web ghost town. That’s a thing.

是的，很好。 我确实希望，尽管就技术和功能以及人们为提供这些抽象而构建的东西而言，现在感觉就像是狂野的西部，但我们不会与之相反，就像网络鬼城一样。 我现在要用这个词来形容，所以每个人都开始使用它，网络鬼城。 就是这样

David: 大卫：

Hashtag!

井号！

Tim: 蒂姆：

Yeah, I think one way to help this from not becoming a problem, again, if you’re listening and you don’t feel like this will ever be a problem, that we’re just going to continue to iterate on technologies and nothing’s ever going to fall by the wayside, that’s cool.

是的，我想有一种方法可以帮助您避免问题，再次，如果您正在听，并且您觉得这永远不会成为问题，那么我们将继续迭代技术，而没有任何事情永远会掉到一边，这很酷。

But, if that even were a possibility, I do feel like the idea of progressive enhancement helps a lot. Because if I’m building something to cater to the device with the least capabilities right now, that means that I’m not going to be relying on a specific foundational thing working exactly as it needs to right now. Instead I’m relying on just the general grain of the web to do what it does best, and that’s what really powers the thing that I’m building. Then everything else on top of that is just another layer of convenience.

但是，即使有可能，我也觉得逐步增强的想法很有帮助。 因为如果我要构建某种功能来满足当前功能最少的设备的需求，那意味着我将不再依赖于某个特定的基础功能来完全满足当前的需求。 取而代之的是，我仅依靠一般的网络来做自己最擅长的事情，而这才是真正推动我正在构建的事物的动力。 然后，除此之外的其他一切只是另一层便利。

David: 大卫：

That’ll help as long as you’re not writing for the Commodore Amiga.

只要您不为Commodore Amiga写作，那便会有所帮助。

Tim: 蒂姆：

I think that if you are going to start asking yourself, “How long should software last?”, you want to make sure of two things. Thing number one, organization — so that whenever you go back and look at this thing, you can actually know what you were doing at the time. I’ll be the first person to say, if I looked at code I wrote even three years ago, I would probably — I don’t know — pass out or something, because we all look at code that we wrote a long time ago and just hate ourselves for it.

我认为，如果您要开始自问：“软件应使用多长时间？”，您需要确保两件事。 第一，组织-这样，每当您回过头来看看这件事时，您实际上都可以知道您当时在做什么。 我将是第一个说的人，如果我看一下三年前写的代码，我可能会-不知道-会失败，因为我们都看了很久以前写的代码并为此而讨厌自己。

David: 大卫：

Absolutely.

绝对。

Tim: 蒂姆：

We do our best with what we have. Now, if I’m starting a new project, I’m going to focus intently on organization and progressive enhancement. I’m hoping that will allow the software that I’m writing to last as long as it needs to.

我们竭尽所能。 现在，如果我要开始一个新项目，我将专注于组织和逐步增强。 我希望这将使我所写的软件能够持续到需要的时间。

David: 大卫：

And as long as it needs to is the second point, because that’s the question that lives both inside and outside of engineering. Engineering needs to be able to give people a clear answer as to what context they need to prepare for as things are changing in the environment. But ultimately, whoever is commissioning a piece of software is the one who knows how long it needs to last and what audience needs to be served by it.

而且只要它需要的是第二点，因为这是一种生活内外和工程以外的问题。 工程需要能够为人们提供明确的答案，说明随着环境变化，他们需要准备什么环境。 但是，最终，谁来调试一个软件，谁就会知道软件需要持续多长时间，以及需要向哪些受众提供服务。

It’s appropriate for us to develop software with the idea in mind that it’s going to live a certain length of time. And if it needs to be adopted by a new project, or it needs to become the backbone of something that’s going to develop next, it’s important to structure code in a clean way so that we can understand it in the future.

对于我们来说，开发软件时要牢记一定时间，这是适当的。 而且，如果它需要被新项目采用，或者需要成为下一步开发的基础，那么以干净的方式构造代码以使我们将来可以理解它很重要。

Tim [23:39]: 蒂姆[23:39]：

It’s interesting, too, because it’s often the business goal to determine how long this thing needs to last. What I found a lot in an engineering team is when an executive or a stakeholder says, “We need this thing,” it’s also your job to say, “Listen, they could come back tomorrow or six months from now and say, we also need this extra thing. We want this thing to do two extra things that we didn’t say in the beginning.”

这也很有趣，因为确定这件事需要持续多长时间通常是业务目标。 我在工程团队中发现的很多情况是，高管或利益相关者说：“我们需要这个东西”，这也是您的工作：“听，他们可能明天或六个月后回来，并说，需要额外的东西。 我们希望这件事做另外两件事，我们一开始没有说过。”

So this thing needs to last as long as it needs to, as long as it fulfills the goals that we set for it. But it also needs to last maybe longer than that. Maybe we need to build in a specific way that if a stakeholder comes by and says, “We also want it to take pictures of your face when you press this button,” then we’re going to need to add that in.

因此，只要满足我们为之设定的目标，它就需要持续的时间。 但是它还需要持续更长的时间。 也许我们需要以一种特定的方式进行构建，如果利益相关者走过来并说：“当您按下此按钮时，我们也希望它为您的面Kong拍照”，那么我们将需要添加它。

How do you account for that? How do you account for the changing landscape of the lifetime of a product?

您如何解释呢？ 您如何解释产品生命周期中不断变化的局面？

David: 大卫：

I’m going to say that that’s a different question.

我要说的是另一个问题。

Tim: 蒂姆：

That’s fair.

这还算公平。

David: 大卫：

Because we’re talking about how long the software should last overall, and it will adapt and change over time. How flexible a piece of software should be? I can see actually it’s a corollary question, because it relates to how the code will adapt over time, and whether or not software ever goes away in that context. Until a company goes out of business and the software just completely end-of-lifes, at that point, you no longer need to worry about adapting that software to do something else.

因为我们正在谈论的是该软件应在多长时间内持续使用，并且会随着时间的推移而适应和变化。 一个软件应该有多灵活？ 我可以看到实际上是一个必然的问题，因为它与代码将如何随着时间的推移进行适应以及软件在这种情况下是否消失有关。 直到公司停业并且该软件完全寿终正寝，您再也不用担心要将该软件改作其他用途。

Anywhere along the way, you can completely turn around and change what the functionality of a piece of software is and still call it the same software for whatever business reasons. At that point, from an engineering perspective, is it even the same piece of software?

在此过程中的任何地方，您都可以完全改变并更改某个软件的功能，并且无论出于何种业务原因，仍可以将其称为同一软件。 从工程角度来看，那是同一件软件吗？

Tim: 蒂姆：

It’s like a band whose original members have all moved on.

就像一个乐队的原始成员都在前进。

David: 大卫：

That’s very true, but they still play those same songs.

的确如此，但他们仍在播放相同的歌曲。

Tim: 蒂姆：

Yeah, I do think that at the end of the day, software should last as long as it needs to, and to accommodate for that, we build for progressive enhancement and we build the absolute most organized way we can. I think that’s really the only thing that we can do in that sense.

是的，我确实认为，软件归根结底应该会在需要时持续使用，为了适应这一需求，我们会逐步开发增强功能，并且会以绝对有组织的方式进行构建。 我认为这实际上是我们唯一可以做的事情。

David: 大卫：

As engineers, I think we want to write in that way. It’s certainly more satisfying to write clean code — code that you can show to somebody without being embarrassed. And that somebody is going to be you in six months, so you’d better not be embarrassed.

作为工程师，我认为我们想以这种方式编写。 编写干净的代码肯定会更令人满意，因为您可以将代码展示给别人而不会感到尴尬。 而且六个月后有人会成为您 ，所以最好不要让您感到尴尬。

Tim: 蒂姆：

Yeah. I bring this up because the more experience I get in engineering and with development, the more I find myself asking, “All right, what are the intentions for this thing that I’m building? Is this going to exist six months from now?” It seems like most of the cases, it does end up existing for a while, and my intentions might remain the same. They might change, but overall there are those core principles that need to be applied to those things that you’ve built just in case you want to go a little further.

是的 之所以提出这一点，是因为我在工程和开发方面获得的经验越多，就会发现自己问的越多：“好吧，我正在建造的东西的意图是什么？ 从现在开始六个月后这会存在吗？” 似乎在大多数情况下，它确实存在了一段时间，而我的意图可能保持不变。 它们可能会发生变化，但是总的来说，有些核心原则需要应用到您已构建的那些东西上，以防您想走得更远。

David: 大卫：

I have frequently learned from building something one way, completely torn it down and rebuilt it a completely different way. It’s still the same piece of software. I might have used like a different language. I might have used a different framework to do the exact same thing, and each one builds iteratively on the previous one.

我经常从一种方法中学习到一些东西，将其彻底拆除，然后以完全不同的方式重建它。 它仍然是同一软件。 我可能曾经用过另一种语言。 我可能使用了不同的框架来做完全相同的事情，并且每个框架都在前一个框架上进行迭代构建。

It’s an interesting question, because on the one hand, you’re talking about the lifespan of the software itself. On the other hand, you’re talking about the code that goes into the software and how long that code will last. I think if we break down the question into how long will this code survive versus how long will the software survive, then I think we’ve got something more specific.

这是一个有趣的问题，因为一方面，您在谈论软件本身的寿命。 另一方面，您正在谈论软件中的代码以及该代码将持续多长时间。 我认为，如果将问题分解为这段代码可以保留多长时间以及软件可以保留多长时间，那么我认为我们有一些更具体的内容。

Tim: 蒂姆：

That’s very good, because as far as I’ve noticed, code never survives. Code is like the mutant DNA virus thing that is just constantly changing and looking different. When I helped to write responsive images into WordPress, I wrote the original first — I don’t know — three versions of that from when it was just an idea in a PHP file in Sublime Text, to Chris Coyier and I working on it, to forking WordPress with the our RICG repo to actually getting something like in the WordPress repository.

很好，因为据我所知，代码永远无法幸免。 代码就像突变的DNA病毒一样，只是不断变化并且看起来有所不同。 当我帮助将响应式图像写入WordPress时 ，我首先写了原始版本(我不知道)，从Sublime TextPHP文件中的一个想法到Chris Coyier，我一直致力于这三个版本，使用我们的RICG存储库分叉WordPress，实际上可以在WordPress存储库中获得类似信息。

And then, we started to say, “All right, let’s work on a plugin. 50% of my code left.” Then we’re like, “All right, plugin is now approved to be a feature of WordPress in the next 4.0 release.” Then there is 25% of my code. And just before we actually hit the publish button and WordPress was out with our feature in it, there is maybe 1% or half of 1% of my code left in that thing!

然后，我们开始说：“好吧，让我们研究一个插件。 我的代码剩下了50％。” 然后我们就像，“好吧，插件现在已被批准在下一4.0版本中成为WordPress的功能。” 然后是我代码的25％。 在我们真正按下“发布”按钮并且WordPress退出了我们的功能之前，那件事可能还剩下我代码的1％或一半！

David [28:06]: 大卫[28:06]：

I typed that semicolon. I did, I did!

我打了分号。 我做到了，我做到了！

[Laughter]

[笑声]

Tim: 蒂姆：

Yeah, that’s pretty much where it’s at now. It’s like, “You see that comment? I wrote that comment.”

是的，现在差不多了。 就像，“您看到那条评论了吗？ 我写了那条评论。”

[Laughter]

[笑声]

Yeah, you should never really expect code to last that long, but it’s like a Jacob’s Ladder effect. Your code is the next step. What you certainly don’t want is to write a broken step into the software.

是的，您永远不要真正期望代码能够持续那么长时间，但这就像雅各布的阶梯效应。 您的代码是下一步。 您当然不希望在软件中写一个破损的步骤。

David: 大卫：

Absolutely. I think distinguishing between how long the code lives and how long the software lives is useful for thinking about this.

绝对。 我认为，区分代码寿命和软件寿命可以对这一点有所帮助。

Tim: 蒂姆：

Definitely.

绝对是

David: 大卫：

How long the code lives. As you said, the code does not live. The code is very temporary. Code that is more than — it’s different for different contexts — but if it’s more than a year old on the web, it’s probably out of date.

代码可以使用多长时间。 如您所说，该代码无效。 该代码是非常临时的。 代码不止于此-代码因不同的上下文而异-但如果它在网络上使用已有超过一年的历史，则可能已经过时。

Tim: 蒂姆：

Easy, easy, yeah. Because even now, when you look at code a year ago, and it’s like, “Well, I used a bunch of var statements, and I could have used constants.” Constants didn’t exist back then, so there you go.

容易，容易，是的。 因为即使现在，当您在一年前查看代码时，就像，“嗯，我使用了一堆var语句，并且本可以使用常量。” 那时不存在常量，所以就去了。

Yeah, I definitely think that’s an excellent distinction to make is, how long should the code last? And then of course, even with JavaScript, all of your XMLHttpRequests are going to turn into Fetch requests, and AppCache is going to turn into Service Worker, and so on and so forth. If we write code with the idea of this is just a step in the ladder, it might not exist ten days from now, but it gets us a little bit forward, it helps improve the health of the software.

是的，我绝对认为这是一个很好的区别，代码应该持续多长时间？ 然后，当然，即使使用JavaScript，您所有的XMLHttpRequest都将变成Fetch请求，而AppCache会变成Service Worker，依此类推。 If we write code with the idea of this is just a step in the ladder, it might not exist ten days from now, but it gets us a little bit forward, it helps improve the health of the software.

David: 大卫：

“To everything — turn, turn, turn.”

“To everything — turn, turn, turn.”

Tim: 蒂姆：

Yeah, exactly. As long as you do that, you will improve the life of your software. Yeah, it’s important to see the code that you write as just another step, I think.

是的，完全正确。 As long as you do that, you will improve the life of your software. Yeah, it's important to see the code that you write as just another step, I think.

David: 大卫：

It’s an interesting topic, and it’s controversial. And I’m really curious what the listeners are going to think about this because they’re they’re out there, they have different perspectives. I know some of them are coming from the business perspective, some of them are coming from the engineering perspective. Some of them might be coming just from a user’s perspective, about how long they expect their software to last when they get a piece of software or when they get onto a site. How long do they expect that site to be there and remain in a form that is recognizable?

It's an interesting topic, and it's controversial. And I'm really curious what the listeners are going to think about this because they're they're out there, they have different perspectives. I know some of them are coming from the business perspective, some of them are coming from the engineering perspective. Some of them might be coming just from a user's perspective, about how long they expect their software to last when they get a piece of software or when they get onto a site. How long do they expect that site to be there and remain in a form that is recognizable?

Tim: 蒂姆：

That’s interesting, because here we are, claiming to build stuff for the web, and I never even thought of asking that question. I certainly know that when I was using Rdio to listen to all of my music and Rdio went under, that was like a life-changing thing for me. It was like, “No, my music, what’s happening?”

That's interesting, because here we are, claiming to build stuff for the web, and I never even thought of asking that question. I certainly know that when I was using Rdio to listen to all of my music and Rdio went under, that was like a life-changing thing for me. It was like, “No, my music, what's happening?”

I had to make yet another fake 80s playlist, and then I move on to Google Play Music, and I’m thinking to myself, I really hope this lasts forever. I’ve invested into this software. This is where I get my music from. When I go to the gym in the morning, I have this thing that I just know how it works. I don’t have to think about it.

I had to make yet another fake 80s playlist, and then I move on to Google Play Music , and I'm thinking to myself, I really hope this lasts forever. I've invested into this software. This is where I get my music from. When I go to the gym in the morning, I have this thing that I just know how it works. I don't have to think about it.

I think, as a user, I want my software to continue getting better, but I don’t want to go away.

I think, as a user, I want my software to continue getting better, but I don't want to go away.

David: 大卫：

Getting better is also a challenging question for a user, because, as developers, when we make something better, it doesn’t always appeal to the way that the user expects it to behave.

Getting better is also a challenging question for a user, because, as developers, when we make something better , it doesn't always appeal to the way that the user expects it to behave.

Tim: 蒂姆：

Yeah, definitely. That’s true with redesigns. For example, we’ve all known products that have redesigned themselves into a dark cave, where you know products who have changed up their business strategy and split themselves in two and then quickly died.

是的，当然。 That's true with redesigns. For example, we've all known products that have redesigned themselves into a dark cave, where you know products who have changed up their business strategy and split themselves in two and then quickly died.

Aside from the products going under because of money or what have you, I want it to last forever because at this point it’s a part of my life, and that sounds corny to say for a music app. But it’s like a routine, and I’m comfortable with it. I certainly — if I were to actually think about it — I don’t want the engineers there doing anything bad with this thing that I really like. I want it to last.

Aside from the products going under because of money or what have you, I want it to last forever because at this point it's a part of my life, and that sounds corny to say for a music app. But it's like a routine, and I'm comfortable with it. I certainly — if I were to actually think about it — I don't want the engineers there doing anything bad with this thing that I really like. I want it to last.

David [31:48]: David [31:48]:

I think music apps are the perfect example of something like that, because what’s more intimate than the sound that is coming in these tiny little things inside your ear when you close your eyes and it’s in the middle. It’s in your head. It’s one of the things that attracted me to podcasting in the first place, was the level of intimacy that comes with an audio medium like this.

I think music apps are the perfect example of something like that, because what's more intimate than the sound that is coming in these tiny little things inside your ear when you close your eyes and it's in the middle. It's in your head. It's one of the things that attracted me to podcasting in the first place, was the level of intimacy that comes with an audio medium like this.

With music, you’ve got the rhythm and it’s getting into the songs that you remember from your childhood and the things that you work out to, the things that are part of your life. You certainly don’t want some developer somewhere making some change that’s going to change that aspect of your life permanently.

With music, you've got the rhythm and it's getting into the songs that you remember from your childhood and the things that you work out to, the things that are part of your life. You certainly don't want some developer somewhere making some change that's going to change that aspect of your life permanently.

Tim: 蒂姆：

Yeah. I’m just thinking of the graveyard of musical things that I’ve used. The first was LimeWire, and then it was Pandora, but Pandora doesn’t let you pick different songs, and I eventually got tired of that. I moved from that willingly. I did lose a whole bunch of stations that I paid, because it was more of a business model thing than an engineering thing, but there were hang ups with bugs in Pandora, but I decided to move from that.

是的 I'm just thinking of the graveyard of musical things that I've used. The first was LimeWire, and then it was Pandora, but Pandora doesn't let you pick different songs, and I eventually got tired of that. I moved from that willingly. I did lose a whole bunch of stations that I paid, because it was more of a business model thing than an engineering thing, but there were hang ups with bugs in Pandora, but I decided to move from that.

Then it was Grooveshark. I paid for Grooveshark actually. I was a paying member of Grooveshark, and I could listen to all my songs, and I had a million playlists. They were all excellent. Then one day, like that, Grooveshark was gone. They’re like, “Sorry, our lawsuits finally caught up to us.” That was it, it was over. All my music was gone, nothing was backed up.

Then it was Grooveshark. I paid for Grooveshark actually. I was a paying member of Grooveshark, and I could listen to all my songs, and I had a million playlists. They were all excellent. Then one day, like that, Grooveshark was gone. They're like, “Sorry, our lawsuits finally caught up to us.” That was it, it was over. All my music was gone, nothing was backed up.

Then I moved right over to Spotify — which I promptly got immediately out of, because I couldn’t stand the fact that they tied everything to your Facebook account. You pretty much had to go app-only, because their web interface was just a dumpster fire. (If you work at Spotify, I apologize sincerely. It might be the best thing in the world now, but at the time, it just wasn’t my thing.)

Then I moved right over to Spotify — which I promptly got immediately out of, because I couldn't stand the fact that they tied everything to your Facebook account. You pretty much had to go app-only, because their web interface was just a dumpster fire. (If you work at Spotify, I apologize sincerely. It might be the best thing in the world now, but at the time, it just wasn't my thing.)

I moved from that very quickly over to Google Play Music, and now I’ve settled down. I’m paying for that, and I love it, and at this point, I’m just so invested in it that I want it to last forever. That’s how I feel about the software that I use as a user.

I moved from that very quickly over to Google Play Music, and now I've settled down. I'm paying for that, and I love it, and at this point, I'm just so invested in it that I want it to last forever. That's how I feel about the software that I use as a user .

David: 大卫：

So it’s a completely different perspective than you think of it as a developer. As a developer, you want to approach the software as “This is going to last maybe a year at most before I throw it all away and start over again.” As a user, you want it to be permanent. That is a very telling statement about the state of affairs.

So it's a completely different perspective than you think of it as a developer. As a developer, you want to approach the software as “This is going to last maybe a year at most before I throw it all away and start over again.” As a user, you want it to be permanent. That is a very telling statement about the state of affairs.

Tim: 蒂姆：

I also don’t want annoying bugs to drive me away from loving the product. For example, when I think specifically about Google Play Music, if I were changing a song and the browser refreshed and it just forgot what was going on, and that continued to happen, I’d be furious. I’d be really upset with that.

I also don't want annoying bugs to drive me away from loving the product. For example, when I think specifically about Google Play Music, if I were changing a song and the browser refreshed and it just forgot what was going on, and that continued to happen, I'd be furious. I'd be really upset with that.

Of course, that’s a code issue. If you trace the pipeline all the way down to a bad framework or a library being used, or a bad pattern, or someone putting an if statement in the wrong place, or a while loop that never exits, that sucks. That could drive me away from a product, definitely.

Of course, that's a code issue. If you trace the pipeline all the way down to a bad framework or a library being used, or a bad pattern, or someone putting an if statement in the wrong place, or a while loop that never exits, that sucks. That could drive me away from a product, definitely.

From a user’s perspective, it’s all about business decisions. Keep making the right decision so that I can continue to use this product, but then it’s also if this thing gets buggy, if we start to get errors or weird usability concerns, or even from a design perspective, if you do a really bad redesign, as a user I have a stake in that. But I don’t actually think about that, because I just want the thing that I’m using to continue to be working well.

From a user's perspective, it's all about business decisions. Keep making the right decision so that I can continue to use this product, but then it's also if this thing gets buggy, if we start to get errors or weird usability concerns, or even from a design perspective, if you do a really bad redesign, as a user I have a stake in that. But I don't actually think about that, because I just want the thing that I'm using to continue to be working well.

That could stop working well from either business concerns, design concerns or development concerns. If your software is thought of well, and you write your code like a ladder, and each thing is a next step and you write your code well, but you don’t demand that it stays in there forever, clouding up the goodness of your thing, just making sure that your code is good and well designed and quick and iterative, then that is one of the three — business, design, code — one of the three things that’s taken care of.

That could stop working well from either business concerns, design concerns or development concerns. If your software is thought of well, and you write your code like a ladder, and each thing is a next step and you write your code well, but you don't demand that it stays in there forever, clouding up the goodness of your thing, just making sure that your code is good and well designed and quick and iterative, then that is one of the three — business, design, code — one of the three things that's taken care of.

I think as developers, we do want our software to be good, and last as long as it needs to.

I think as developers, we do want our software to be good, and last as long as it needs to.

David [35:33]: David [35:33]:

Well, loosely coupled, modular developments certainly with progressive enhancement: from a development perspective, that’s what we want to build. It’s a separate question though whether that is going to satisfy the business needs of the company as it moves forward and as it has its lawsuits. Or if it’s going to satisfy the developers who created the operating system that’s on your phone that can’t be upgraded and that therefore won’t support the features that were in the previous version that need to be there in order for the software to continue working.

Well, loosely coupled, modular developments certainly with progressive enhancement: from a development perspective, that's what we want to build. It's a separate question though whether that is going to satisfy the business needs of the company as it moves forward and as it has its lawsuits. Or if it's going to satisfy the developers who created the operating system that's on your phone that can't be upgraded and that therefore won't support the features that were in the previous version that need to be there in order for the software to continue working.

It’s difficult to say, “You can’t make something that’s going to be that solid unless you’re constantly adapting it and constantly adapting it.”

It's difficult to say, “You can't make something that's going to be that solid unless you're constantly adapting it and constantly adapting it.”

Tim: 蒂姆：

Very true. Progressive enhancement does solve some of those things, but it doesn’t solve all of those things.

非常真实 Progressive enhancement does solve some of those things, but it doesn't solve all of those things.

David: 大卫：

No, particularly from a business model perspective, because if the business needs something that is going to be added through one of those progressive enhancements in order to satisfy the needs of the investors or the designers, then that just doesn’t get addressed by a progressive enhancement solution.

No, particularly from a business model perspective, because if the business needs something that is going to be added through one of those progressive enhancements in order to satisfy the needs of the investors or the designers, then that just doesn't get addressed by a progressive enhancement solution.

Tim: 蒂姆：

Very true. I think we’ve come full circle into saying when you ask yourself how long software code should last, really what you want to do is realize loosely coupled, modular, clean, well-organized code; that seems like that’s pretty much it.

非常真实 I think we've come full circle into saying when you ask yourself how long software code should last, really what you want to do is realize loosely coupled, modular, clean, well-organized code; that seems like that's pretty much it.

David: 大卫：

From an engineering perspective, perhaps, but I want to hear from our listeners. I want people to give us some feedback about this, because I don’t think it’s a question we’re going to be able to answer in one session. I think that the terms are broad enough that they’re open to a lot of interpretation, and I’m curious if there’s a perspective on this that — we’ve come at it from a number of different angles, but obviously, we couldn’t possibly come at it from every angle. I’m curious if there are angles that people out there would have liked to have heard us focus on a little bit more that we might have missed.

From an engineering perspective, perhaps, but I want to hear from our listeners. I want people to give us some feedback about this, because I don't think it's a question we're going to be able to answer in one session. I think that the terms are broad enough that they're open to a lot of interpretation, and I'm curious if there's a perspective on this that — we've come at it from a number of different angles, but obviously, we couldn't possibly come at it from every angle. I'm curious if there are angles that people out there would have liked to have heard us focus on a little bit more that we might have missed.

Tim: 蒂姆：

Yeah. Please shoot us an email, fire off a tweet, send smoke signals, whatever you do. We will most definitely respond, and we’re looking forward to what you all come up with.

是的 Please shoot us an email, fire off a tweet, send smoke signals, whatever you do. We will most definitely respond, and we're looking forward to what you all come up with.

David: 大卫：

What was that hashtag again?

What was that hashtag again?

Tim: 蒂姆：

#webGhostTown.

#webGhostTown.

David: 大卫：

Web Ghost Town. All right. Tweet us at Versioning Show or use the hashtag #webGhostTown, and we’re going to be looking for those.

Web Ghost Town. 行。 Tweet us at Versioning Show or use the hashtag #webGhostTown, and we're going to be looking for those.

Tim: 蒂姆：

Oh yeah. I’m going to save that in Twitter, and I’m going to look every single day. Don’t let me down. Please just one of you use it!

哦耶。 I'm going to save that in Twitter, and I'm going to look every single day. Don't let me down. Please just one of you use it!

David: 大卫：

Cool.

凉。

---

---

Thank you so much for listening, everybody. We always enjoy getting to talk technology with all of you.

Thank you so much for listening, everybody. 我们总是喜欢与大家交谈技术。

Tim: 蒂姆：

We’d also like to thank SitePoint.com, and our producers, Adam Roberts and Ophelie Lechat. Please feel free to send us your comments on Twitter — @versioningshow — and give us a rating on iTunes to let us know how we’re doing.

We'd also like to thank SitePoint.com , and our producers, Adam Roberts and Ophelie Lechat. 请随时在Twitter( @versioningshow)上向我们发送您的评论，并在iTunes上给我们评分 ，让我们知道我们的情况。

David: 大卫：

We’ll see you next time, and we hope you enjoyed this version.

下次见，我们希望您喜欢这个版本。

翻译自: https://www.sitepoint.com/version-show-episode-9-code-longevity-and-web-ghost-towns/

对冲基金小镇 鬼城