Better Programming

Scott was instrumental in turning around Docker (which was "broken" [0]), after a $23m Series B raise from Arjun Sethi at Tribe Capital: https://medium.com/better-programming/the-greatest-startup-turnaround-… / https://archive.vn/loTwW [0] Some interesting remarks on it by Bryan Cantrill: https://news.ycombinator.com/item?id=28460504

Publications and spread. I have a larger following on Medium than I have in dev.to or hashnode. So I post there and usually provide a canonical link to the actual article in a more "decent" location. The value is the publication such as https://medium.com/javarevisited/ which I usually use or https://medium.com/better-programming which is a bit more painful (for the submitter). But the benefit is that both have orders of magnitude more followers than I do. When an article goes up in a publication I get huge viewer numbers. Monetization isn't available in my country so I never enabled it as an option. I'm not sure if I would turn it on to begin with as all my new content on medium isn't exclusive to the platform.

Link to bypass the paywall if you aren't a Medium subscriber: https://medium.com/better-programming/why-flutter-isnt-the-next-big-th…

Bypass the paywall with this link: https://medium.com/better-programming/a-python-substitute-i-tried-out-…

+1 that Why matters most. My teammate recently wrote a blog post on how we document Why in git commits and PR descriptions. https://medium.com/better-programming/daily-habits-to-turn-your-git-hi… Would also recommend checking out a related talk by a tech lead at StitchFix: https://confreaks.tv/videos/rubyconf2018-documentation-tradeoffs-and-w…

“It, like the semicolon, always has been and will be.” Not the best of examples. It hasn’t always been. Early fortran and lisp didn’t have it. Reading https://medium.com/better-programming/a-brief-history-of-the-8efda9dde… it seems Algol and PL/I set the trend to make it popular. Looking at newer languages, I also get the impression it’s on the way out. Rust has them, but python, scala, go and swift try to avoid them (https://python-reference.readthedocs.io/en/latest/docs/operators/semic… “Avoid having multiple statements on a single line. Though the language definition allows one to use a semi-colon to delineate statements, doing so without reason makes one’s code harder to read”, https://golang.org/doc/effective_go.html#semicolons: “Like C, Go's formal grammar uses semicolons to terminate statements, but unlike in C, those semicolons do not appear in the source. Instead the lexer uses a simple rule to insert semicolons automatically as it scans, so the input text is mostly free of them.”, https://docs.swift.org/swift-book/LanguageGuide/TheBasics.html#ID316: “Unlike many other languages, Swift doesn’t require you to write a semicolon (;) after each statement in your code, although you can do so if you wish. However, semicolons are required if you want to write multiple separate statements on a single line”)

honestly it feels like a colossal amount of software development process is designed to prevent exactly this. put it on the backlog. we'll come back to it. i very much appreciate some of the sensibilities of trying to bring bring your team with you, but also i feel like 95% of the world outright fears & is desperate to wrench control (and a sense of purpose) from those who can & those who aspire. ultimately we are very very alone in many cases in what we make of our positions, and excellence & a mentality of chasing the unlimited & great is often quickly sacrificed to support a more manageable corporate existence. apologies. i am fairly blunt in first writings, it takes me time to refine, synthesize, be nice. this is many many sided; engineers so far to little to create inroads & expose their wonders, which is just one of innumerable problems in this tension. there's, in this case, some good recent writing on the topic on HN, huzzah. "We throw away our power as engineers working for other people."[1][2] the tension is real. [1] https://news.ycombinator.com/item?id=24773266 [2] https://medium.com/better-programming/we-throw-away-our-power-as-engin…

This advice is confusing. CPU is a "compressible" resource -- pods don't get killed for (trying to) exceed it. Pods don't get evicted from nodes based on CPU starvation, so autoscaling your node count won't help if you end up with a set of pods on a node that need more CPU than the node can provide. They'll just starve each other. If your service allows horizontal scalability, you can use autoscaling of pods with Horizontal Pod Autoscaler (ideally also with a cluster autoscaler) to increase pod count for a given service when some percentage of the requested CPU is exceeded, whether or not you set a CPU limit. Setting the cpu_request appropriately for your pods is critical to ensure that node CPU is not oversubscribed by the Kubernetes pod scheduler. Pods where mem & CPU requests = limits are given the highest class of service ("guaranteed"). For your most critical and latency sensitive services, this is the best approach when also coupled with HPA. Assuming a 4.19 kernel or later, I suppose. https://medium.com/better-programming/the-kubernetes-quality-of-servic…

Related: https://medium.com/better-programming/here-are-the-three-virtues-of-go… Also, here's my interpretation / rephrasing / translation of the 3 virtues: Laziness (Larry Wall): "The quality that makes you go to great effort to reduce overall energy expenditure. It makes you write labor-saving programs that other people will find useful and document what you wrote so you don't have to answer so many questions about it." My Translation: Efficiency. Choose the most efficient solution to a problem, and if there isn't one, then invent it. Automate any manual repetitive process that can be automated, even if* extraordinary large amounts of time and manual repetitive effort are required to automate it in the first place! (Related: The 5th Labor Of Hercules, The Augean Stables)* Impatience (Larry Wall): "The anger you feel when the computer is being lazy. This makes you write programs that don't just react to your needs, but actually anticipate them. Or at least pretend to." My Translation: The Most Efficient Use Of Resources Possible (AKA "The Knowlege Of A Better Way Of Doing Things"), the anger you feel when a better path / solution is known -- but for whatever reason (management, etc.) that path / solution, is not or cannot be taken. This makes you take the initiative, and ask for forgiveness later (if you screw up), rather than permission earlier (that is, never start on the solution if the answer from higher-ups early on is…

Flowise was cool. I used to to help build an enterprise employee search tool with it a few years back. https://medium.com/better-programming/employee-search-with-openai-flow… The fact is, there's not as much need for drag-n-drop low code tools anymore. At least I don't have much need.

I believe strongly in this counterargument: https://medium.com/better-programming/software-component-names-should-… Small summary: external identifiers are hard to change, so projects will evolve such that they are not accurately descriptive after time. (Less discussed there, but: In a complex or decentralized ecosystem, it's also the case that you come across many "X Manager"/"X Service"/"X State Manager"/"X Workflow Service" simultaneously, and then have to rely on a lot of thick context to know what the distinctions are)

Not necessarily "better" but cursor-based pagination, for example, has a different set of trade-offs. It can be more performant, but tends to be trickier to implement. This article looks like a decent overview: https://medium.com/better-programming/understanding-the-offset-and-cur…

Segmenting different data sources is the main approach pursued by OpenAI afaik (ChatML for example). That has not worked so far, as you can see in this prompt golfing game: https://ggpt.43z.one/ The goal is to find the shortest prompt that subverts the "system" instructions (which GPT was trained to obey). Inputs can not "fake" being from the system and yet it only takes 1-5 characters for all the puzzles so far. I've also elaborated on why this problem is harder than one may think in a blogpost: https://medium.com/better-programming/the-dark-side-of-llms-we-need-to… It's easy to come up with solutions that seem promising, but so far no one has produced a solution that holds up to adversarial pressure. And indirect prompt injection on integrated LLMs increases the stakes significantly.

I'm glad to see the organic combination of Python and Rust. My personal interesting experience is to rewrite a Python project using Rust [1], which has increased the speed by 40 times. Then the original Python project and the rewritten Rust code are organically combined through PyO3, which is very good. We have not only achieved performance, but also achieved ease of use and scalability. Just like PyLint and Ruff. [1] We Rewrote Our Project With Rust… and It’s Almost 40X Faster. https://medium.com/better-programming/40x-faster-we-rewrote-our-projec…

Nominal types are on Typescript's roadmap: https://github.com/Microsoft/TypeScript/wiki/Roadmap Side note: An Introduction to Nominal TypeScript: What are nominal types and why should I use them? : https://medium.com/better-programming/nominal-typescript-eee36e9432d2

As far as I know, a (C-like) language must either have: - A statement separator (semicolons) - Significant whitespace Otherwise parsing the language is very likely ambiguous, e.g JavaScript [1] [2]. [1] https://flaviocopes.com/javascript-automatic-semicolon-insertion/ [2] https://medium.com/better-programming/you-might-need-those-semicolons-…

I forgot to put the non-paywall link! It's here - https://medium.com/better-programming/3-uncommon-bash-tricks-that-you-…

Hey, author here. Thanks for posting my article! Here's a friend link so you you can bypass the paywall. You might want to update the url of this post to point to this instead: https://medium.com/better-programming/from-15-000-database-connections…

Friends link: https://medium.com/better-programming/numpy-illustrated-the-visual-gui…

A really nice and thorough comparison of modern programming languages: https://medium.com/better-programming/modern-languages-suck-ad21cbc8a5…

I went back and forth on whether it was a good idea. In the end I wrote one and it was well received by my team. Indeed, most of the team wrote one and we collated them in our documentation space. This was pretty helpful in the first few months of lockdown, when people's work preferences and constraints were quite varied. I also decided to write up a short piece on the pros and cons + some advice if you are considering writing a User Guide (or README or Personal User Manual) - https://medium.com/better-programming/personal-user-manuals-the-good-t… [Edit: Grammar]

I use this strategy borrowed from Stephen Fry (Podia's founder) https://medium.com/better-programming/podias-founder-on-the-importance…

Could definitely be workflow related. Here's one that shows the upgrade button/overlay for me. https://medium.com/better-programming/getting-started-with-creative-co…

I think this article does a good job of comparing the two if you're familiar with TypeORM: https://medium.com/better-programming/prisma-vs-typeorm-60d02f9dac64 which compares the two. Most of exevp's comment about the Prisma schema are a non-issue given an understanding of the value it provides. But I can understand the reluctance to learn yet another DSL. But in my experience, if you've worked with relational databases, it's a breath of fresh air to be able to define your database schema with it.

> However, it [Typescript] does not actually ensure that the data you are manipulating corresponds to the type that you have declared to represent it. For example, the data might contain additional fields or even incorrect values for declared types. This made me curious, as it sounds like something that can be added as a transpiler option under tsconfig.json. But it turns out Typescript doesn't already have a support for "nominal" type, but there are some tricks one can leverage to achieve similar thing: https://medium.com/better-programming/nominal-typescript-eee36e9432d2

No, nominal types are extremely useful to ensure the correctness of your software. You can define a function to receive a FirstName and LastName instead of passing strings so you cannot accidentally mix up the parameters for example. There are several techniques to approximate nominal typing in typescript (https://medium.com/better-programming/nominal-typescript-eee36e9432d2 for example) and there is an open issue https://github.com/Microsoft/Typescript/issues/202 but it’s still not being considered for implementation as far as I remember.

Some pointers https://redux.js.org/recipes/implementing-undo-history https://github.com/anthonygore/vuex-undo-redo https://medium.com/better-programming/utilizing-the-command-pattern-to…

Sort of. I don't think you can write off the virtual Dom. But this is basically my area of research. I'm saying that a specific approach to reactive programming is more performant. I have an article for that too: https://medium.com/better-programming/the-fastest-way-to-render-the-do…

I see a lot of people talking about SQL or Airtable. But there's a third middle ground here - Graphql based headless CMS. For example Graphcms, Prismic, etc. You get the standardization of Graphql (which means no lock-in) and pretty much as powerful as SQL really. You also get the admin/dashboardy/WYSIWYG aspects of a CMS - https://prismic.io/feature/custom-type-builder Very easy integration - https://medium.com/better-programming/graphql-combine-and-swiftui-fe9c… (of course this works just as well on Android, React Native/Web,etc)

Node takes advantage of multiple cores. The code is all async by default and that is easy to load onto green threads. This used to be implemented with callback hell, now it's Promises which is actually really cosy (and what Rust is adopting). Random article I found on it: https://medium.com/better-programming/is-node-js-really-single-threade…