Mike McFunley

Love it. There should be more longevity in software. I've worked at too many projects that was "just" a rewrite of something else, usually due to legacy issues / dropped support (e.g. no support for Flex on iOS, libraries/frameworks no longer being maintained, etc). I'm a big fan of the Go programming language because of this, but also by extension of "boring technology" (https://mcfunley.com/choose-boring-technology). It's hard to be able to make an impact in this regard in the B2C projects I usually have though.

>Boring tech + customer focus will likely beat most competition, regardless of where their offices reside. Reminds me of this classic post: https://mcfunley.com/choose-boring-technology Your addendum on customer service feels spot on too. What good is any software, if its users are unsatisfied.

Just gonna keep linking this til the heat death of the universe: https://mcfunley.com/whom-the-gods-would-destroy-they-first-give-real-… Real-time analytics are worse than useless. At best they are a distracting resource sink, at worst they directly harm the quality of decision-making.

And even if the new _is_ better, it's called the bleeding edge for a reason. I find I bleed all over it - stress, bugs, and time. If it's not worth spending one of your innovation tokens[0] on this new fangled technology, then use the old version that doesn't require the bleeding. [0] https://mcfunley.com/choose-boring-technology

While not strictly build vs buy (eg: technically you still have to "build" a postgres cluster and in house expertise even when buying AWS Aurora) but I generally like the ideas in the classic https://mcfunley.com/choose-boring-technology IMO your product is the only thing you build, as much as possible should buy everything else. There is eventually an inflection point where your product is so mature that the opportunity cost of improving it operationally vs marginal next feature you will eventually save money, but that scale has been growing YoY for a while (AWS mostly gets cheaper every generation so far) .

In a similar vein, the old classic Choose Boring Technology is worth reviewing from time to time. https://mcfunley.com/choose-boring-technology

1. masses of RDD: Resume-Driven Development 2. the delusion that the way google manages 1-3% of global computing power is appropriate for your company which bursts up to < 10 servers under "high" load 2a. though you can quickly get to a place where you do need more control over migrations once your db has a nontrivial size 3. early engineers and bad engineers love complexity. Love it. ps -- lots of these choices come down to the choices of senior people. There are good shops out there! This may resonate with you. https://mcfunley.com/choose-boring-technology

Interesting, thanks for pointing this out! Do you have any insights on how hard it is to implement? I'm not familiar enough with ADSS to tell whether it's worth the innovation token. [0] [0]: https://mcfunley.com/choose-boring-technology

It seems like this article is basically just restating point by point a classic article / presentation of the same title, https://mcfunley.com/choose-boring-technology This article does link to the original, so it's not uncredited plagiarism. But it still feels a bit odd. The original has been discussed really extensively on HN in the past, and even quite recently: https://news.ycombinator.com/item?id=9291215 https://news.ycombinator.com/item?id=20323246 https://news.ycombinator.com/item?id=23444594

another excellent article on the same topic https://mcfunley.com/choose-boring-technology

Good eye and good question! When I first joined, the existing codebase was already built out in PHP on a LAMP stack. I was really opposed to it at first but I've learned to love it since. The safety, speed, and size of a compiled language on the web is something most modern frameworks can't compete with. I, personally, have built a ton of in-house APIs here aiming to "modernise" php and am really proud of the outcome. It's nowhere as safe, readable, or dynamic as something like a Rust or Swift but PHP is definitely a strong competitor for the modern web (IMO). This article https://mcfunley.com/choose-boring-technology also really helped me come around early on.

I think the usual term is "innovation tokens", from the "choose boring technology" post at https://mcfunley.com/choose-boring-technology. It's definitely very helpful in preventing projects from choosing all the shiny new tech at once while not preventing any all innovation at all. Some of the shiny tech is actually worthwhile, after all.

Dan McKinley's talks are not that recent, but are similar: https://mcfunley.com/ He is another former Etsy developer.

My goal for choosing .NET libraries is to minimize the total complexity of our software stack. [0] I won’t add a library to our stack if we have an existing solution. Most of our apps are written in C# and use Entity Framework with either ASP.NET MVC or Windows Forms. I would need an excellent reason to use something else. [0] https://mcfunley.com/choose-boring-technology

An older piece that I loved is Dan's point on just allowing a certain number of technology tokens in any project: https://mcfunley.com/choose-boring-technology I think one big part of the mistake is using Hacker News, Reddit, conferences as a sign of what companies are actually using. Instead, I liken it to a bazaar: https://www.nemil.com/on-software-engineering/beware-engineering-media… Oh, and remember marketing is not reality, even though marketers try awfully hard: https://www.nemil.com/mongo/3.html

"popular tech is safe because someone will have done what you want to do" is phrased negatively in this excellent opinion piece: with a new technology/tool, you don't know what can go wrong. With boring technology, there's enough community experience around it. https://mcfunley.com/choose-boring-technology It also seems like 'boring = popular & old', 'hype = popular & new'.

I've been working with Django for almost my whole career, since 1.1. It's a joy to use, and blows any other web framework I've used out of the water when it comes to actually just building stuff. Django is a fantastic boring[1] tool, and seeing boring updates like this is great. 1: http://mcfunley.com/choose-boring-technology

Yes. Rails has by now certainly crossed into boring software territory – arguably a [positive thing](http://mcfunley.com/choose-boring-technology) anyway – but it remains an excellent choice coming into 2018: - Out of the box, Rails has close to unbeatable developer ergonomics, tooling, stability, and ease of use - Lots of high quality, large companies use it (GitHub, Shopify, Airbnb, Square, Twitch) and have by now figured out how to scale it, often sharing and open sourcing their efforts, e.g. https://github.com/Shopify/identity_cache - If your product front end is simple, Turbolinks can be an excellent choice (find me a faster, more bug free product than Basecamp) - If you prefer to use a more modern JavaScript solution on the front end like Ember or React, Rails API is a perfect fit - The Ruby ecosystem and community are both very high quality

I love this advice. Here is a blog post that I keep coming back to regarding this. http://mcfunley.com/choose-boring-technology

Worth a thought -> http://mcfunley.com/whom-the-gods-would-destroy-they-first-give-real-t… why you don't see more of this type of stuff. Like other commenters pointed out, "live data" isn't a "charting specific" problem, it's a front-end / back-end problem and having a chart library that updates on new data. D3 and other javascript charting libraries have had the capability for a long long time. It's just that when you get down to it very few people really need "live data".

This reminds me of an Etsy engineering talk about A/B testing: http://mcfunley.com/design-for-continuous-experimentation Etsy employees were so sure that customers would love having blank/multi-windows, because if you shop on Etsy a lot, how else would you keep track of interesting things while moving down the list? According to slide 20, 70 percent more people in the testing group gave up and left the site after getting a new tab.

Pretty sure it was this one linked in the OP. See this footnote: https://mcfunley.com/choose-boring-technology#f4 > A good example of this from my experience is Etsy’s activity feeds. When we built this feature, we were working pretty hard to consolidate most of Etsy onto PHP, MySQL, Memcached, and Gearman (a PHP job server). It was much more complicated to implement the feature on that stack than it might have been with something like Redis (or maybe not). But it is absolutely possible to build activity feeds on that stack. > An amazing thing happened with that project: our attention turned elsewhere for several years. During that time, activity feeds scaled up 20x while nobody was watching it at all. We made no changes whatsoever specifically targeted at activity feeds, but everything worked out fine as usage exploded because we were using a shared platform. This is the long-term benefit of restraint in technology choices in a nutshell.

The essay Choose Boring Technology covers some of this ground. From that essay: "One of the most worthwhile exercises I recommend here is to consider how you would solve your immediate problem without adding anything new. First, posing this question should detect the situation where the “problem” is that someone really wants to use the technology. If that is the case, you should immediately abort." https://mcfunley.com/choose-boring-technology Another nice thing about the above essay is that it uses dark text on light background (as opposed to this blog post, which I had to print to PDF in order to read). I have to say, though, that I really miss the days when I was the excited young programmer dying to use the new language, the new framework, the new paradigm or even just some design pattern. Lots of fun! Luckily, during those years, I was always in a team with a more level-headed and experienced developer who would bring me (and the other team members like me) a little closer to earth. And the level-headed developer was learning from us while he/she was moderating our technical ambitions.

Per "Choose Boring Technology" [0]: > Let’s say every company gets about three innovation tokens. You can spend these however you want, but the supply is fixed for a long while... If you choose to write your website in NodeJS, you just spent one of your innovation tokens. If you choose to use MongoDB, you just spent one of your innovation tokens. If you choose to use service discovery tech that’s existed for a year or less, you just spent one of your innovation tokens. If you choose to write your own database, oh god, you’re in trouble. From my POV, the author spent their innovation tokens on a political commitment. I would not recommend this path to someone starting a company. It's hard enough already. Also, many American companies that might have been useful to the author were founded by Europeans, e.g. GitLab. There's plenty of European talent for making widely adopted infrastructure. If those companies aren't in Europe, it's worth asking why [1]. [0] https://mcfunley.com/choose-boring-technology [1] https://worksinprogress.co/issue/why-europe-doesnt-have-a-tesla/

Even with a clean slate, there's immense value in choosing something that you already know to be a tried-and-true approach - i.e. in choosing "boring" technology¹ instead of trying to be at the cutting edge. Now if exploring the cutting edge is a goal of yours in and of itself, then by all means blow some of those innovation tokens on the new Reactangular.ts hotness. For a lot of projects, though, the goal is to get something out the door as painlessly as possible; jQuery and plain JS have (for better or worse) been the tried-and-true "boring" approaches, and HTMX (from what I can tell) seeks to be the similarly "boring" choice. Obviously right now HTMX ain't the boring choice (because it's still pretty new), but a decade from now it could be. Having used it in a couple pet projects recently, it already does feel pretty boring (especially since it goes hand-in-hand with other boring strategies like "just use SQL" and "just use CGI scripts" / "just use classic MVC frameworks"). ---- ¹ https://mcfunley.com/choose-boring-technology

> It turned out that they [The Guardian] were burnt, and wrote about their painful migration to a RDBMS and to safety It's not really fair to judge technical decisions retroactively. PostgreSQL in 2012 wasn't the same as in 2018. PostgreSQL was uncommon back then, there was a limited talent pool, it was painful to operate/failover/scale/shard, and it wasn't yet available on RDS. JSONB support only arrived to Postgres in Dec/2014. The alternatives (e.g. MySQL) were also problematic, e.g. locking tables every time a new column was added was likely a deal-breaker. They only migrated to PostgreSQL because they didn't want the pain and downtime of self-hosting MongoDB, but there didn't seem to be any major architectural issues. In this case it seemed like specific issues with MongoDB in production rather than NoSQL in general. He briefly touches on the downsides during the talk, but the purpose of a talk is to excite and pique somebody's interest. https://youtu.be/qI_g07C_Q5I?t=3120 In the book he uses more nuanced language and warns that it's not something to be used on every occasion. * "It’s essential to test your expectations about programmer productivity and/or performance before committing to using a NoSQL technology." * "Most applications, particularly nonstrategic ones, should stick with relational technology—at least until the NoSQL ecosystem becomes more mature." * "But we also realize that there are many cases, indeed the majority of cases, where you’re…

It's partially covered in the first link on the page: https://mcfunley.com/choose-boring-technology. A specific quality described there would be languages that have fewer unknown unknowns, a lack of surprises. C, C++, Java (the three he picks) have relatively few surprises. Either by virtue of design (here I'd say both C and Java) or total industry experience with the language (C++, C, Java). Ubiquity might be another consideration. A lot of other languages could probably be added to the list on that criteria. Another would be how common it is, especially for a particular domain. In my field (embedded, safety critical, real-time) it would seem like Rust would be a great choice, but it's not common and there are both technical and logistical hurdles preventing its use (for fielding, at least, for proofs of concept it's viable and that could lead to its use in fielded systems later). I'm constrained to C, C++, and maybe Ada. Fortran has been phased out, but would've been one of the boring languages for this domain up to about 20 years ago (for a new project).

K8s absolutely has a steep learning curve, but it feels like we always focus on the most complex setups and use cases so that we can admire the shiniest new features. If you're going from "our app is running directly in tomcat in our on-prem data center" to "we want to move to a mirco-services architecture with a service mesh, canary deployments, multi-cluster observability, fault injection, automatic global failover, etc...", you're almost certainly going to have a bad time. I really like the concept of "innovation tokens" [0] here. Pick one or two big innovations at a time and don't add more until you're comfortable with what you have. Get your app running in docker first, and then get it running in a basic k8s setup first instead of leapfrogging to the more advanced stuff. Chances are if you didn't need a service mesh for your original non-k8s deployment, you probably don't need one for the v1.0 first pass of your k8s rollout. [0]https://mcfunley.com/choose-boring-technology

I really love how Dan McKinley frames this kind of thing in terms of each company having a budget of "innovation tokens". http://mcfunley.com/choose-boring-technology edit: now it's a club! http://boringtechnology.club/ > Let's say every company gets about three innovation tokens. You can spend these however you want, but the supply is fixed for a long while. > If you choose to write your website in NodeJS, you just spent one of your innovation tokens. If you choose to use MongoDB, you just spent one of your innovation tokens. If you choose to use service discovery tech that's existed for a year or less, you just spent one of your innovation tokens. If you choose to write your own database, oh god, you're in trouble. > Any of those choices might be sensible if you're a javascript consultancy, or a database company. But you're probably not. You're probably working for a company that is at least ostensibly rethinking global commerce or reinventing payments on the web or pursuing some other suitably epic mission. In that context, devoting any of your limited attention to innovating ssh is an excellent way to fail. > There is technology out there that is both boring and bad. You should not use any of that. But there are many choices of technology that are boring and good, or at least good enough. MySQL is boring. Postgres is boring. PHP is boring. Python is boring. Memcached is boring. Squid is boring. Cron is boring.

Sure. And since this is an obvious fact, I figured most people would read that in. But just to be clear, I mean "solved more effectively some other way". Blockchains in particular carry a business penalty for a few reasons. One is that they're novel. As Dan McKinley says, we should "choose boring technology" [1] unless we have a strong incentive not to. Blockchain expertise, to the extent that it exists, is bid up in the marketplace, giving another excellent reason to pick something else. A third is that the vigorous blockchain hype has created a fair bit of blockchain skepticism in reaction. I know people looking for work that won't even talk to blockchain companies. And then we have questions about security, efficiency, reliability, and all the other operational concerns that one mainly learns through hard lessons (hopefully other people's hard lessons written up for the rest of us to read). [1] http://mcfunley.com/choose-boring-technology