David R. MacIver

The author posted a follow-up piece: https://www.drmaciver.com/2015/04/surprise-feminism/

did you just describe the OP as a non-engineer? https://www.drmaciver.com/

To those who are attacking this article. I think, Steve unfortunately has chosen a somewhat bad example to illustrate a very good point. I have seen countless examples of complex payment logic shoved down into User model (or CreditCard model), because developer did not had the foresight to see that Payment logic does not belong in User or in CreditCard model. About functional or using higher order functions - yeah go for it. The great thing about Ruby I think is - you can still use best of OO patterns with minimum amount of heavy lifting and sprinkle blocks and lambdas - resulting in pretty neat design overall. Also, functional code != good code sometimes (http://www.drmaciver.com/2008/08/functional-code-not-equal-good-code/)

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.

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

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-b… 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.

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-t…

I also like David MacIver’s more general notion of “situated software” https://www.drmaciver.com/2018/11/situated-software/ though its meaning is not as immediately obvious as “symbiosisware”.

DRMaciver wrote a novella about it. Programmer at large, it's called. Largely about cultural variation in gender and sex norms. https://www.drmaciver.com/category/programmer-at-large/ (down) https://archiveofourown.org/works/9233966/chapters/20941043

Someone may enjoy this article on advice in "Overthinking Everything" blog as well: https://drmaciver.substack.com/p/how-to-give-good-advice

Yes. I know it's existing as coverage when you run unit-tests. I'm well aware of the performance impact on production, I guess it's the major challenge here. Since I'm mainly developing in python - here's a good article about that, he gave some directions to make it faster: https://www.drmaciver.com/2017/09/python-coverage-could-be-fast/

I came across this interesting post touching on Haskell just recently: https://www.drmaciver.com/2015/04/on-haskell-ruby-and-cards-against-hu…

Have you seen the talk I did about using it with Django? http://www.drmaciver.com/2015/06/hypothesis-for-django/ We're all still figuring out the details, but this sort of testing definitely works for testing your applications as well as your algorithms. ETA: Oh, and thanks for the kind words. :-)

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-sof… > 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/a… 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-estimat… https://drmaciver.substack.com/p/task-estimation-101 >…