David R. MacIver

For me, it depends on the type of problem I'm trying to solve. Specifically, I ask is it hard work or a difficult problem? (see also [1], [2], and HN commentary at [3] from a short time ago).

Hard work is something that a big corp can solve by throwing bodies at the problem. A proprietary data format or protocol but with an available, thorough specification (eg. a giant PDF from an international standard, an industrial protocol, and associated XML schema with a bunch of separate devices to talk to by just reading through thousands of pages of PDFs...). Another example of hard work is handling a high volume of support requests, just communicating to individual users might involve more hours in a single day than are available to a single user, and it might require supporting 3 shifts or 7 days a week, which a solo dev just can't do. These are tasks that a solo dev is likely to burn out on and which I would not entrust them with.

On the other hand, a difficult problem is something that can be solved by a single contributor, but which often cannot be solved by throwing bodies at it. The output may be something as tiny as a few hundred lines of code that realize a single critical insight. That insight might synthesize a lot of complicated and inaccessible concepts available only to someone who is an expert in multiple fields and who has experience gained over many consecutive years of work in a single field. A company that can put 20 people with 1 year experience and 4 year…

https://en.wikipedia.org/wiki/Delphi_method > https://news.ycombinator.com/item?id=26368011

https://blog.pragmaticengineer.com/yes-you-should-estimate/ > https://news.ycombinator.com/item?id=27006853

https://josephmate.github.io/PowersOf2/ Complexity Estimator

https://earthly.dev/blog/thought-leaders/ > https://news.ycombinator.com/item?id=27467999

https://jacobian.org/2021/may/20/estimation/ > https://news.ycombinator.com/item?id=27687265

https://tomrussell.co.uk/writing/2021/07/19/estimating-large-scale-software-projects.html > https://news.ycombinator.com/item?id=27906886

https://www.scalablepath.com/blog/software-project-estimation/

https://estinator.dk/ > https://news.ycombinator.com/item?id=28104934

https://news.ycombinator.com/item?id=28662856 How do you do estimates in 2021?

https://web.archive.org/web/20170603123809/http://www.tuicool.com:80/articles/7niyym Always Multiply Your Estimates by π > https://news.ycombinator.com/item?id=28667174

https://lucasfcosta.com/2021/09/20/monte-carlo-forecasts.html > https://news.ycombinator.com/item?id=28769331

https://tinkeredthinking.com/index.php?id=833 > https://news.ycombinator.com/item?id=28955154

https://blog.abhi.se/on-impact-effort-prioritization > https://news.ycombinator.com/item?id=28979210

https://www.shubhro.com/2022/01/30/hacks-engineering-estimates/

https://www.paepper.com/blog/posts/monte-carlo-for-better-time-estimates-of-your-work/

https://drmaciver.substack.com/p/task-estimation-101 >…

This article feels like a follow up on "On Ruby"[1] and related to "It’s OK for your open source library to be a bit shitty"[2]. The common theme I find in all three is the quality and health of a dependency. I agree with OP that stars and latest commit are not clear indicators of quality.

I think more useful indicators are tests, documentations and pull requests.

* Tests. These are things you can actually run to see if the library actually works. In most cases, you can read them and understand how it is supposed to be used. On some platforms even if the tests passed in the past, they may not pass now, for example using different version of the language or platform. The coverage of the tests would be nice, but it is hard to measure at first sight, therefore using the ratio of tests LOC to library LOC might be an indicator.

* Documentation. The documentation itself does not change how the library behaves but it is a clear indicator whether the author expected someone else to be able to use it or not, and shows a sort of responsibility. Most of weekend hacks would not have one.

* Pull Requests. If there are old and open pull requests, that seem useful, it is a bad sign for the maintainer of the project.

[1] http://hawkins.io/2015/03/on-ruby/

[2] http://www.drmaciver.com/2015/04/its-ok-for-your-open-source-library-to-be-a-bit-shitty/

This reminds me somewhat of a system by David MacIver: https://drmaciver.substack.com/p/using-a-list-to-manage-executive

He builds his list from scratch every morning. The list is flat, so as you go about your day and subtasks occur to you, they are added to the list without explicit links to the main task.

I thought it might be risky to start with a blank list, because something important might be forgotten. But it turns out that a blank list is a great filter for what is truly important and motivating. If it is important, you will remember it at some point during the day.

This system is also excellent for shorter periods of time. If I come home and want to get started on dinner, want to tidy up a bit and have a few other demands on my attention, I put my laptop in a central location, open up Notepad, and just start typing in everything I see around me that I need to do. Usually I start with maybe 5 items, but as I start doing things I quickly add tasks to the list, and it might grow to 15 or 20 items. But then at some point the list starts to shrink again as these small, granular tasks are completed. It is strangely satisfying to see the list initially grow and then shrink to nothing. It also leaves me with a feeling of having thoroughly attended to everything that was bothering me when I first walked in the door.

This confirms my own experience. I discovered that programs written in (or use) dynamic languages like Lisp are surprisingly reliable (Emacs in particular).

Type safety won't protect us from broken software. Quote: "The most common bugs caught by static typing are also the least critical sort of bug."

Source: http://www.drmaciver.com/2016/10/static-typing-will-not-save-us-from-broken-software/

Static typing helps a lot to catch basic type errors but it is surely not the "Messiah" of code safety. In big systems the good old way of testing still seems to be the best practical way.

Haskell's claim "If it runs then it's likely correct" is a deception because no compiler can catch logical errors. This was also Ada's problem in the Ariane disaster, although Ada has probably the strongest type system beside Haskell. You need special verification tools like FramaC, and even those tools don't catch all errors. Haskell's safety is even more questionable in face of the underlying libraries which are written in C. Finally, the still unresolved Cabal hell speaks for itself. Stack works only because it is an isolated repository where the maintainers have to take a lot of attention to make sure that new code doesn't break other code.

People say this, but it seems like a false dichotomy. I use Emacs exactly because I choose productivity!

Emacs might take more time to configure, but that's time measured in hours or, at most, days—a tiny blip compared to the total amount of time you spend programming in the environment! On the other hand, you get a system that you can quickly adapt to your specific needs in a way that other editors do not really support. It's the perfect environment for "situated software"[1], and environment that can grow[2] with your needs and workflow.

Emacs's learning curve and configuration is an O(1) cost for an O(n) benefit. As long as you're planning to use it a lot—and we're programmers, we're going to use it a lot—even a small increase in the benefit is worth a substantially larger up-front cost.

[1]: https://www.drmaciver.com/2018/11/situated-software/

[2]: "Grow" in a similar sense to Guy Steele's "Growing a Language" talk: https://www.youtube.com/watch?v=_ahvzDzKdB0