1. 1

    This sounds like a release! :)

    1. 1

      Oops, didn’t realise there was a tag for that.. added now ?

    1. 4

      What other strategies have you found for effectively reporting problems to large companies?

      1. 3

        Also in high demand if anyone has good ones: What strategies have you found for large companies to effectively receive problem reports?

        1. 3

          Blog posts and HN seem to be the only way ;-)

          Disqus ignored this issue until I blogged it and a Google employee has now responded to my forum thread about this issue since I blogged this too!

        1. 5

          This is a problem wherein developers don’t build in bug reporting or don’t make bug reporting easy because it’s seen as something that should only be used for beta testers or in-house.

          This number is unknowable, but I can imagine there are plenty of people who find weird bugs or edge cases in Facebook, Youtube, whatever, but because there isn’t an obvious way to report the bug; they just never do.

          As evidenced by app stores, there are lots of regular people who will write detailed accounts of bugs they are experiencing. Only instead of getting an email about it, you get it in the form of a public rant and a one-star rating.

          1. 6

            Have you ever run a popular public service with a bug reporting address? I created security@[business].com on our About page so whitehats could privately report security problems. We immediately got dozens of support emails per day from users who wanted to unsubscribe from mailing lists, etc. It’s intractable. The signal to noise ratio is unbelievably low.

            1. 3

              This is definitely a problem, but I think it can be reduced. For example, if the same page that had that email address on it made it clear how to unsubscribe, maybe it’d be used for that less?

              I understand it’s hard supporting lots of people - for example if there was a contact email address at the bottom of every YouTube page it’d become quite expensive to triage; but I don’t believe making it impossible to contact anyone to report what might be serious issues is the best (or only) fix.

          1. 8

            I have a connection at YT. I was able to repro, so I sent it along. Fingers crossed!

            1. 2

              Thanks!

            1. 10

              Oh wow, I just tested it, he’s right. How on earth did this get through QA?

              1. 6

                My question exactly! I’m not surprised people aren’t convinced it’s a real bug until the test it; it’s pretty crazy :(

                1. 4

                  How do you know that it did get past QA? A QA Engineer’s job is to report on software quality, not to decide whether or not to ship a product. There could be a reported failure of a test case specifically for this issue, followed by an administrative decision to release the product with the failure anyway.

                  You might be tempted to ask ‘how on Earth did this get past the Developer who wrote it?’, but you can’t really assume that it got past that person either. Software is complex, and a small change made by someone else at a later date, somewhere far away in the code tree, could have an unintended effect on code that worked just fine when it was first written and tested.

                  It would be interesting to know what the ultimate root cause of the problem was. Its too bad that outsiders don’t usually get to see that information, because there can be a lot to learn from it.

                  1. 10

                    A QA Engineer’s job is to report on software quality, not to decide whether or not to ship a product.

                    If the QA department doesn’t own the release, then they aren’t Quality Assurance, they’re merely Quality Information Reporting Staff or something.

                    I guess I’ve only worked at places where the QA org owns the release, so your comment really surprised me. There have been places that had NO QA at all explicitly, and those had as bad of quality as you would expect.

                    1. 7

                      That’s the ideal situation, but is it common? Releases dates and feature lists are often very “political”, and at many places QA isn’t allowed an outright veto as a result. In games, for example, QA can at best argue for a release date to slip or alternately for scope to be cut given time/resources, but since release dates slipping or features promised in trailers not materializing are both seen as bad PR and seriously impact the entire marketing strategy, someone fairly high up in management would have to OK it, and there’s often substantial pushback. Management would weigh QA’s input as just one of many sets of pros/cons, and it ends up being a judgment call which is less-bad of the options available at that point: “miss the Christmas season”, “ship for the Christmas season but without promised features”, or “ship for the Christmas season with promised features, but they’re horribly buggy”.

                      Of course you can say games are “just entertainment”, but this tale from SGI, among others, sounds pretty similar.

                      1. 3

                        That’s the ideal situation, but is it common?

                        I don’t know if it’s common (I suspect not), but where I work we do this! When I (as team leader) am happy with a release (all important items for that version complete, code reviews done, etc.) my responses is always that it’s ready to go when QA say so.

                        That said, we’re talking about YouTube here. I would be both surprised and disappointed if they chose to ship things with with QA having raised bugs like this one. My guess is that they didn’t know about this and something wasn’t tested thoroughly.

                      2. 1

                        I’m sorry to hear that you’ve only worked at places like that. It’s like working with teams that don’t use source control, or that never do unit tests, or that can’t version a release, or that have no QA at all. Sometimes you’ve got to do it, but it is generally agreed that it isn’t a recipe for long term success.

                        A Quality Assurance team is an information reporting staff. Its right there in the name.

                        ‘assure’ - 1. tell someone something positively or confidently to dispel any doubts they may have.

                        Some organizations think they can create a team that can force a high quality release by finding and eliminating all of the bugs, a team that refuses to ship until the bugs are all gone - a Quality Ensurance team.

                        ensure - 1. make certain that (something) shall occur or be the case

                        Forming a QE team is a bad gambit. The only way for them to be certain of a bug not going into production is to never ship code. If they do ship code, they become the scapegoat at the first sign of trouble. (“How on Earth did this get past the quality team?”) Its an inherently conflicted group.

                        Without going into a long dissertation on it, your business will be a lot better off, and you’ll ship better quality software if you have an honest quality reporting team (a QA team) providing actionable data up the chain of command.

                        1. 2

                          The Capers Jones view of the world (inspections, static analysis, formal testing..) has lead to some of the highest quality software I’ve ever been a part of, and it has the research data to back it up.

                          Your straw man about having a bad culture in a company for how they treat QA in light of total engineering failure (bugs) is one that I have never experienced. I’d love to hear more about your experience and why you feel so strongly on QA not owning releases, or I may be confused about what bothers you so much about QA ownership of releases.

                  1. 17

                    An alternative to Disqus is Isso, which is self-hosted.

                    1. 4

                      One of the great things about Disqus is that you can use it on a “static” blog. My blog (the one hosting this article) is just GitHub pages with posts written in markdown. This has the advantage of being simple and free (and easily to cache/distribute on CDN etc.) but has drawbacks of not being able to have custom code like that.

                      When my blog was hosted on AppEngine I had self-hosted comments; but Disqus seemed like a much better option. Not so sure about that now though!

                      1. 6

                        I’ve gone back and forth on that, but the solution my current blog is a note at the bottom of each post saying:

                        Comments welcome: mjn@anadrome.org
                        

                        This outsources the infrastructure to email, which already works, with the obvious drawback that the barrier for many people to emailing someone is higher than that for posting a comment. Although that might not be purely a drawback. :-) Another difference of course is that email is private, while some comments might be interesting to other readers, too. I partly remedy that by occasionally posting (attributed) updates at the bottom of a post if someone sends in something I think might be interesting for other readers, as in this example.

                        Besides not wanting to mess with running either a first- or third-party commenting system, the other motivation is that on a personal blog I feel some desire to keep it as a place for my own writing, not as a general third-party discussion forum attached to every page. So if someone sends in relevant comment I’m happy to post it (or a paraphrase), but I don’t necessarily want comments from random people arguing about tangents to be posted underneath my essays.

                        1. 6

                          I’ve thought about not having comments directly (esp. when HN/Reddit/here usually get more comments than directly on the blog), but I do still think they add value. Not only do I get “Thanks!” now and then which lets me know people are finding my posts useful, but there’s often good discussion between people there.

                          I don’t get a lot of bad comments, so the only reason to remove them would be to get rid of the scripts but I think (hope) Disqus cares enough about its reputation that they’ll fix this and be more careful in future.

                          1. 3

                            The discussion between commenters on one thread can lead to discovery of new ideas for those people or blog author. That’s essentially what happens here, on HN, etc. Doesn’t happen with email since the readers don’t know of each others' presence much less interesting comments.

                        2. 3

                          Can vouch for isso for static sites; I have been using it myself for years on my blog - but alas I don’t get the traffic to generate any comments anyway. The only JavaScript on there is isso and Google Analytics.

                          1. 2

                            Oh, based on the above I figured this was self-install and wouldn’t work for static sites. If it can be used directly from their site though, there’s nothing to stop them making the same mistake in the future? =D

                          2. 1

                            I’m doing the same thing. I have static Jekyll blog, although now on Netlify rather than GitHub Pages because then I can use https with my custom domain.

                            I built and hosted my own IndieWeb Disqus alternative though. And it’s open for others to use: https://webmention.herokuapp.com/

                            It uses WebMention (which btw now is a W3C Proposed Recommendation), which removes the need for embedding any authentication mechanisms like Facebook. Instead everyone writes the comments on their own blogs instead and pings my service which then retrieves the comment. I then use a javascript that looks for links to comment pages within my blog and embeds any comments (and any new comments in realtime) inline through basic progressive enhancement (and thus it’s all easily curlable despite the javascriptiness)

                            And there’s other similar services that one can easily self-host. There’s even people who do automatic commits to their static page of any received comments, both from WebMention and through comments form. Been thinking of eventually experimenting with that as well and make my WebMention endpoint talk to my Micropub endpoint (another standard that’s now going through W3C) to submit any received mentions: https://github.com/voxpelli/webpage-micropub-to-github Some are already doing that with their respective endpoints.

                            1. 2

                              I have static Jekyll blog, although now on Netlify rather than GitHub Pages because then I can use https with my custom domain.

                              My blog (hosting this article) is actually custom domain over SSL on GitHub pages (using CloudFlare to add the SSL). It’s not ideal, but was easy to add to the existing GitHub Pages site rather than migrating!

                              It uses WebMention (which btw now is a W3C Proposed Recommendation), which removes the need for embedding any authentication mechanisms like Facebook. Instead everyone writes the comments on their own blogs instead and pings my service which then retrieves the comment.

                              I’d never heard of this, this sounds really interesting - I shall have to read up! Thanks! :-)

                          1. 3

                            without installing Linux

                            You’re already running Linux. ChromeOS is just a Linux distro with a patched kernel (like most Linux distros nowadays).

                            1. 2

                              You’re already running Linux

                              It’s probably obvious I know this given in the post we use Bash, download the Linux version of Go and execute a bunch of Linux/Bash commands ;)

                              ChromeOS is just a Linux distro

                              There’s a huge difference between using ChromeOS as-is and installing a Linux distro a Chromebook. It might not be obvious to anyone that doesn’t use a Chromebook in dev mode, but it’s incredibly limited. Most people using Chromebooks in dev mode install some sort of Linux (doing so via Crouton seems very popular). There’s no package manager and most of the stuff you’d expect to be there is missing (eg. the Rust setup script fails because file is missing and setting it up manually fails due to no C compiler, which so far I’ve not managed to satisfy). Nobody builds binaries for ChromeOS Linux.

                              1. 1

                                Let’s get our definitions straight. A Linux distribution is a software distribution around a Linux kernel. No package manager required to qualify. No minimum userland requirements either.

                                Nobody builds binaries for ChromeOS Linux.

                                https://skycocker.github.io/chromebrew/

                                1. 1

                                  I never said ChromeOS was not Linux. My article says “without installing Linux”. “Having a Chromebook” does not mean you have “installed Linux”.

                                  The other stuff I added was just FYI about why making something work in dev-mode without installing Linux is actually interesting and is not just the same as making something work in Linux.

                                  By “nobody builds binaries for” I meant “people that build software don’t build binaries for” not that third parties don’t do it. I trust a binary I download from rustlang.org (who are building binaries used by many thousands of people) much more than a third party making binaries that are used by a handful.

                            1. 3

                              If you’re going to go into Dev mode, is there a reason not to use something like Crouton? It seems pretty nice to me, and I have a few different environments on my little Chromebook…

                              1. 3

                                Just that it’s a bunch of baggage. Why install Linux if you don’t need to?

                                I did actually have Crouton installed until I powerwashed yesterday (had a weird issue with downloads vanishing). I like to keep things minimalistic - easier to get things back to how they are if anything goes wrong (and, less to go wrong!).

                                1. 2

                                  I like to keep things minimal and clean, so the ability to nuke chroots when they get hairy is pretty nice to me. I wouldn’t want to be experimenting with Go, and mess it up (say if I’m mucking about with the core), and then have to start all over in my native environment… crouton seems to make it easier to “get back to things […] if anything goes wrong”, at least in my mind.

                                  I would say I do the same for work tho: I have a per-client per-assessment VM/hyve, and I nuke them when done (makes data clean up easy as pie), so it may just be an extension of that.

                                  1. 3

                                    Yeah, I can totally understand all that (I liked using Crouton for testing stuff out), but for some stuff (eg. if it’s just downloading an archive with an executable binary like this one) it seems like overkill.

                                    I’m not against it, there just needs to be enough of a benefit to justify the (albeit rather small) overhead.

                                    1. 2

                                      I think that’s pretty fair; it’s actually spurred me to try a native, non-chrooted Go on my chromebook sometime this week (I’m working on some static analysis tools for it anyway, so it’s a good place to try). Definitely not my normal route, but why not try it?

                              1. 10

                                It’s an understatement to say that this resonates with me. Yesterday was frankly a shit day for me, and about half of it was a write-off, precisely because I was dealing with software bugs. When you encounter a rapid series of them it’s incredibly disruptive to productivity and more than a little demoralising. Here’s a select sample of some of what I saw:

                                • My primary Linux development VM completely died with a thoroughly corrupted ext4 filesystem during a dpkg update. The root filesystem went read-only with “deleted inode referenced” messages in the kernel log. Rebooted it after a little poking around and it won’t even get past GRUB Rescue. Appears to be a corrupt superblock and who know’s what else. Unsure if it’s the hypervisor (VMware) or the kernel to blame. Either is entirely plausible.
                                • Several hangs in Remote Desktop Manager while exiting RDP sessions. I’ve dealt with this sporadically for well over a year and finally decided to spend some time trying to debug it. Appears to be a race condition between two threads in the RDP ActiveX control it embeds. It’s probably more likely to be a bug in the .NET Interop assemblies.
                                • Updating a finance application would hang during the MSI update. Originally thought it was the finance app, but later found out it appears to be a thread in one of the MSI processes making WMI calls crashing. Today I found out that WMI itself seemed to be in an unstable state thanks to callbacks registered by an Intel service that’s part of the Ethernet drivers that wasn’t responding to them. Essentially WMI calls were getting stuck on RPC calls that would never complete. This disaster goes deeper, but suffice to say, just getting to this point took wait chain analysis in a debugger across several processes. I will say that my experience with Intel software is that it’s a digital dumpster fire.
                                • Crash in WinDbg thanks to a buffer overflow in an extension DLL (irony not lost on me)
                                • Crash in Outlook somewhere in the UIAutomationCore library while writing an email
                                • Crash in Word somewhere in the WWLib library

                                This is one day, and not even a complete recount. It’s not just closed-source stuff, open-source stuff is often equally terrible. I’ve spent this morning rebuilding my VM post it’s total destruction yesterday, and while these days I’m more skeptical of VMware, it wouldn’t be the first filesystem I’ve lost due to rubbish, poorly tested code in the Linux kernel.

                                Most people don’t have the skills to debug buggy applications. It takes time and is frequently very difficult. Particularly when it’s not your application. If you do try and get to the bottom of the issue, prepare more often than not to enter a rabbit hole that would make Alice herself cry. Yes, this is a rant, but for those of us who try to maintain stable systems and do the same for all of those systems we manage (or develop software for), the current state of software quality is frankly appalling.

                                1. 6

                                  My impression is that Linux quality has fallen a lot in recent years. Since switching to FreeBSD I’ve been much happier and my purely subjective impression is that it’s better/more reliable code.

                                  1. 5

                                    Reading your post reminded me of the time I lost most of a day trying to figure out why our application was entirely broken a few days after I’d upgraded a component, despite me thoroughly testing it.

                                    It turned out to be a bug in only the paid-for version of PostSharp, which you “got for free” on a Monday:

                                    https://plus.google.com/113181962167438638669/posts/QF5pDB4XY6F

                                    It took a lot of people telling them how stupid this was on twitter before they finally agreed to change how this works to avoid inconsistent builds across different days :(

                                    1. 1

                                      Addendum: For any SysAdmins here, consider configuring all of your client systems to report crash events. On Windows this is fairly easy: setup a Windows Event Collector on a suitable server and deploy subscriptions to clients to push “Application Crash” events. Check the pulled events now and then, or on small networks, maybe even email on each new crash event.

                                      It’s frequently insightful, genuinely useful, and horrifying. You’ll also find way more crashes than you likely realised, as you’ll see all the crash events for background processes (services, etc…) that won’t typically present a crash dialogue to the user.

                                    1. 1

                                      He seems to have some points, but I don’t really like how he calls libraries like Angular “fly-by-night”.

                                      Also, I think React probably has some bad points just like any other language. Just showing that other frameworks have bad points doesn’t mean the one you advocate does not.

                                      Lastly, while he shows the difficulties these other frameworks have, he doesn’t actually show how React or Dart solves these problems.

                                      1. 6

                                        IMO, many devs could use a healthy dose of irreverence, if only to break the status quo.

                                        The author advocates for a simpler approach to programming. Rather than suffering CoolFramework.js' weird query syntax, why not just do what it was trying to do in the first place manually? This may require you write a bit more code, yes. It’s not as sexy. It’s akin to poring over an ORM’s docs for hours trying to write one weird query when you probably could write it in straight SQL and have it be cleaner.

                                        1. 2

                                          I’m planning to; we;we’re prototyping both React and Dart (which we’d like to use in a similar way to React). I didn’t block because I’m stuck for a solution, I was just dumping my thoughts on the frameworks that are becoming “mainstream”, which I think aren’t pushing web devs in a good direction :(

                                          1. 5

                                            I hear you, I’ve penned thoughts on this topic as well:

                                            http://callcc.io/for-the-love-of-frameworks/

                                            http://callcc.io/a-culture-of-easy/

                                            There’s an alarming level of intellectual deference to frameworks. It’s like devs assume that if you throw enough “best practices” at a problem then it eventually results in a best solution. This is harmful because it acts as a cognitive killswitch of writing better code, often by an implicit appeal to groupthink.

                                            The worst part is it’s difficult to call out this laziness without being labeled negative or whiny. This, to me, is the biggest indicator that there’s a problem: the utter lack of introspection.

                                            1. 1

                                              The worst part is it’s difficult to call out this laziness without being labeled negative or whiny

                                              I can agree with this; see comments on Reddit! ;)

                                        2. 3

                                          Sorry, the “fly-by-night” comment was meant to be tongue-in-cheek, but I guess that’s not very obvious ;(

                                          I probably should’ve included a React sample; but my post was mainly about what we’re doing wrong; I wasn’t really advocating a solution (it’s easy to point out flaws, harder to solve them!).

                                          1. 1

                                            Sorry, the “fly-by-night” comment was meant to be tongue-in-cheek, but I guess that’s not very obvious ;(

                                            Ah ok, understood. Don’t take it too personally, maybe my sense of humor is just out of whack. ;)

                                            I probably should’ve included a React sample; but my post was mainly about what we’re doing wrong; I wasn’t really advocating a solution (it’s easy to point out flaws, harder to solve them!).

                                            I think a React or Dart sample may have been beneficial, even if only for contrast.

                                            I would like you to know that I actually enjoyed reading the article, and I agree with the points you make. I just wanted to point out what I found to be some inconsistencies. Reading my last comment, I think maybe I was too harsh – I did not mean to come off that way. Sorry.

                                            1. 2

                                              Ah ok, understood. Don’t take it too personally, maybe my sense of humor is just out of whack. ;)

                                              It’s my fault. I write my blog posts as if readers know who I am; it’s rare they’re read by thousands of total strangers who don’t know my personality! Of course, I’m not going to change it; it’s my blog; get your own! ;)

                                              Reading my last comment, I think maybe I was too harsh

                                              I didn’t take it that way at all; I think the comment was entirely fair!

                                              I really wish I’d detailed React better in the post; because so many people are reacting the way I did when I first saw it. I posted this on twitter:

                                              https://twitter.com/DanTup/status/469823421925576704 Is this how you would choose to write a TODO app? So much noise and bizzare syntax/funcs/properties :/ #React

                                              It looked horrific to me. However, after one of the Facebook guys told me “Give it 5 minutes”, I had a real quick play with it; and I was very quickly sold. I’m a big fan of functional programming, and this really struck a chord (component rendering feels very much like a pure function, which has many advantages).

                                              I encourage everyone to play with React for 5 minutes; first impressions are very misleading!

                                              1. 1

                                                i’m personally holding out hope for the combination of clojurescript and react. clojurescript really does seem to fix all the surface ugliness of working with javascript/react, and as you say, the actual react core is very solid and well designed.

                                        1. 1

                                          The client side bits remind me of Java applets and liveconnect. Like if you compiled any language into java bytecode and just made it interface with the DOM/BOM through plumbing. That’s a “common” VM and intermediate format.

                                          I think the problem with the argument (and not to pick on the author… it’s a broadly discussed topic) is that implementers would have their own versions of this common vm. Their own versions of this plumbing. “Write once, run anywhere” fell short of its vision partly because of so many implementation differences.

                                          If the big thing is to get typing into the client, or not depending on what makes sense for your app maybe the thing is to get a future version of javascript to have typing, or not. Kinda like strict or not… albeit with a much huger dev push behind it to pull it off.

                                          1. 1

                                            It’s not just about typing; it’s also about choice and sharing code.

                                            Choice: On the server we have choices, and people pick different languages - there are merits to them all, whether they’re technical, based on familiarity, or even just available libraries.

                                            Sharing: Often we have to repeat logic in both the client and on the server. If our server is running language X, why must we re-implement that logic in JavaScript, or worse still, send the data back to the server for processing?

                                            I don’t think different VM implementations would be a big problem. Mono seems to be doing pretty well; and you never know, people might share code (until recently, Chrome used WebKit for rendering)!

                                          1. 2

                                            So the reason we have so many languages on the backend is because as developers we have 100% control over the backend. We own the server-side so we have luxury of doing what ever we want on that domain.

                                            We don’t own the client-side, Microsoft/Google/Opera/Apple/KDE/etc own the client-side. So imagine if we had this plethora of client side languages that varied between each browser/system vendor and each had their own different implementation quirks? We’d end up screaming out for a common language between all the browsers, we’d end up screaming out for Javascript. Sure it may be dirty and quirky but I love Javascript because it’s the standard open client side language.

                                            1. 4

                                              We wouldn’t have different interpretations of languages if we had a common VM. Browser vendors wouldn’t interpret the different languages; only the intermediate format. Similar to the JVM and CLR; these seem to work well.

                                              (Though I don’t underestimate the effort involved in this, even before you consider having multiple companies involved!)

                                              1. 1

                                                So we’d have to standardise on the intermediate language for the VMs? I think you’d see the similar situation that currently plagues Mono, it’s playing catch up to Microsoft’s CLR. Imagine if we had Microsoft/Apple/Google on different levels of the VM implementation?

                                                1. 3

                                                  So what? We have Microsoft/Apple/Google on different levels of JavaScript implementations currently, too. Having a VM would improve a lot of things, while making existing things not worse than they are.

                                                  1. 3

                                                    This is no different to JavaScript; but at least with a dedicated VM, it’s decoupled from the language, so it wouldn’t need to change every time someone wanted a new feature; it would become stable! :)

                                                    1. 1

                                                      Excellent point, I think I got carried away. I agree a VM approach would be an excellent solution, I’m just concerned with a cross platform VM that isn’t controlled by one company.

                                              1. 3

                                                There’s little info on what’s coming in the next version of F#; yet we know quite a lot of language features coming in the new versions of VB and C#. It feels like C# and VB are charging forwards at a much faster rate than F#. Do we want to get off the fast train and board the slow train?

                                                I haven’t used any .Net language, but in any way is this because F# is already so flexible it doesn’t need much? I am a user of Ocaml and Ocaml simply doesn’t need to change much. Most of the value added when it comes to new versions of Ocaml is things behind the scenes. Sometimes nice little syntax additions but for the most part they aren’t a big problem. Compared to a language like Python or Java, where every new interesting thing you want the language to do generally requires a new version of the language, Ocaml allows users to do quite a bit of growing without modifying the language.

                                                1. 2

                                                  That’s true in some ways (in fact, many of th announced vNext C# features are to add things F# already does, or make functional concepts easier); but there are still a huge bunch of things posted at http://fslang.uservoice.com/ that would make sense to add.

                                                  That said; these are language features. If you look at tooling support, then F# is far behind (not just for not being part of Roslyn, but the VS editor is basically a text editor and little more). There’s no word on any improvements there either :o(

                                                  It all makes me wonder how much investment F# is going to get over the coming years compared C#. As more functional ideas come to C#; where will we be in 5 years time? Will C# do most of what we want from F#, but have tooling support that is light years ahead?

                                                1. 1

                                                  Sending this to my boss, it’s so true :(

                                                  Sometimes people think the cost of doing a new feature is the only cost; but simply maintaining it for years to come takes time. If you keep letting your product get bigger and bigger, it’s going to cost more just to “do nothing” to it.