KajMagnus

How do you pass arguments to your Make targets? Let's say you'd like to set `DB_USER` to "my_name", then, do you:

    make psql user=my_name  # ?

To me, having to type `user=` is very annoying, I want to do just `make psql my_name`.

Agreed that Make is nice :- ) My Makefile is not as nice as Make though o.O

> I'm not excited about writing a bash script

Bash scripts almost could be illegal :- ) I'm thinking about writing scripts in Deno in the future, instead

> The worst thing I've experienced with Dvorak is typing "ls<enter>" repeatedly. It's really painful on the pinky. Putting L on the right pinky stretch was a really bad decision.

What about `alias s=ls`, a way to avoid the bad decision :- )

> Both y (yank) and p (put) are on the left hand ... right hand .. movement keys, which are more important when not using a mouse ...

Oh I didn't know. That sounds nice. Hmm makes me wonder if maybe I'd preferred Dvorak instead.

> I learned Dvorak back in college, and got fast by playing muds. Type fast, or you're dead

Hmm I wonder if type fast MUDs and spell correctly and the right grammar, or you're dead, could be a fun way to learn languages in high school :- )

Turns out there's: https://en.wikipedia.org/wiki/MUD#Educational_MUDs — but seems the last ones are from the 90's

I just had a quick look at Dvorak, and then picked Colemak instead because of more similar shortcuts. — It took weeks or months to get up to speed in Colemak. But it was a bit fun, fortunately. (How long did it take, with Dvorak?)

When the typing speed difference between Dvorak and Colemak is so small (it is?), I would say to myself that any of them is better than good enough and be happy :- )

There's also tools like tmux and fzf / skim, don't know if you're using them already; if not, I'd guess they'd save more time than learning Colemak.

> especially because vi keybindings are quite important

Oh I have nice Vi keybindings in Colemak — I use Vi always: VSCode, IntelliJ etc.

On the keyboard, I've mapped the N physical key to down, H to up, and left is Backspace (and Y which I never use), and right is Space and U. So I don't use the HJKL keys for navigation (well, H but it means Up for me).

This leaves the J K L keys available to do their usual things, in Vi — they map to N E I in Colemak (apparently you've noticed this :- )) which I use all the time.

> Is the big improvement that it leaves {} in their original place

I don't think so. I'd say, it's probably the shortcuts, and that many shortcuts continue working with the left hand only (e.g. using the mouse to select text, then the left hand to CTRL+C +V copy-paste).

Sounds like a good explanation.

Also, if I have two passwords AA and AB that are similar to each other, then, if I use only AA for a while, I easily forget AB, or start including parts of AA in AB. — Is there a word for this? For forgetting and messing/mixing up things, because they are too similar to each other

Hmm I have a bit forgotten how things were, before Colemak. I was typing mostly software things, when I decided to switch. I think I a bit felt like you do.

> But when I'm ready to code, my typing speed is the single biggest factor

Especially when writing docs / comments for that code, then it's mostly English words (rather than `(){};!+-,[]` things)

> Designing Safe Software Systems Part 2 https://www.digitalmars.com/articles/b40.html

> Dual Path

Hmm there's something similar in the SRS book by Google, they call it "failure domains" (I haven't read all of it though).

> Monitors: If the output is outside some preset bounds, the system is shut down

Maybe in software, becoming read-only can be a similar good idea, when something looks weird

> Deadman: A deadman is a hardware timer switch added to a computer system that shuts it down if it isn’t regularly reset.

This is something I'm planning to add to the software I'm developing :- )

It's forum / blog-comments software, and, in case the admins have been away for too long (maybe vacation for some weeks), the forum would become read-only, maybe even retroactively hide some risky comments & discussions, until they're back — so there's always humans around that can remove toxic troll comments and such things.

> Safe Systems from Unreliable Parts https://www.digitalmars.com/articles/b39.html

> Improving the quality of that component by a factor of 10 will get us there, but at a cost explosion of 10 times the price. But suppose we add in a backup component B, that also has a 10% failure rate. The odds of A and B both simultaneously failing are 10% of 10%, or 1%. This is achieved by a mere doubling of the cost instead of an order of magnitude increase

I think it's interesting that this at the same time, doubles the attack surface, for hackers? Although the failure risk gets down to 1%, now the hackers can try to break in into both A and B? Hmm. I wonder if there're any ways to avoid this tradeoff, ... Maybe there aren't, in the same way as it's going to be 2 x expensive, too

> was stymied by this for a full day

Oh it took a while until I noticed the extra ';' :- ) It'd likely have slipped past code review o.O

> impossible to assemble parts any way but the correct way

Hmm make me think about database constraints & foreign keys :- )

> As time went on, this warning became commonplace in other compilers

Nice that different languages can help each other become better :- )

> D is better because so many unnecessary things in C and C++ are minefields

I remember long ago when coding C++, we had to add a bunch of macros in each C++ class, to remove dangerous-by-default C++ auto generated things (like the copy constructor that copied pointers). I guess you know a lot about such things. D and Rust seems nice :- )

> For those who are afraid that it will somehow affect QWERTY typing speed, such fears are totally unfounded

What! :- ) Well founded fears, I'd say: I've been typing in Colemak for 10+ years and if I switch to QWERTY I'm significantly slower than before I started using Colemak. — But I'm still glad I made the switch.

> the typing speed is not the productivity bottleneck

Yes agreed. I'd only recommend a software person to switch, if they think the learning process seems fun. But maybe if one writes novels, it's nice to type faster? Or someone who writes a lot here at HN :- )

> hotkeys are generally a MESS

Colemak: Hotkeys = fine :- )

> many things I learned designing gearboxes to the D programming language

I'm curious about what are some of those things :- )

(embedded software for gearboxes? Or physical design things that were translatable to software?)

> doesn’t have to be the best, and probably isn’t

Precisely. And, building the truly best solution, is often a mistake, in that it can take pointlessly long.

Good enough is good enough, and others might find things to improve, and be correct that it'd been better in their way — the important thing is instead to realize that actually making any improvement one might have found, can be far down on the priority list. Maybe there'll always be other more important things to do, so it'll never happen.

> > "at least possible that it's over all the best solution"

can be rewritten as:

> > "at least possible that it's a good enough solution"

And maybe it can make sense to make improvement suggestions, and then, when the others say "yea but there's too much else to do", then, ok, maybe forget about it and be happy anyway.

Or if someone who had been designing airplanes for 40 years, shifted to writing software?

Becoming aware that people "by default" think like you describe — plus reflecting about if it's appropriate, and maybe doing something about it — is a bit the point with the article?

Look at the last paragraph:

> policymakers and organizational leaders could explicitly solicit [...] proposals that reduce rather than add

And why there are dedicated tools for finding unused CSS that can safely (hopefully) be removed without breaking anything

https://www.google.com/search?q=find+unused+css

Often (but not always), finding a good enough addition is "almost instant", O(1) — for example, in software, how to implement a new feature, can come to you directly, when you read the new feature description.

But to find something to delete — then one needs to know about all existing source code — that takes O(N) to read and think about. (Unless keeps it all in memory)

Meaning, in practice, it's often O(1 * N), versus O(N * N). But yes you're right about the cases when it's a complex thing that can be done in many ways.

Check out the Business Source License: https://mariadb.com/bsl-faq-adopting/,

and maybe: https://www.cockroachlabs.com/blog/oss-relicensing-cockroach... "Why We're Relicensing CockroachDB [under the Business Source License]"

Also, the Fair Source license: https://fair.io

I think you're right. And that it'd take rather much time & inconvenience, for the customers, to in effect "micro manage" payments for individual features, and agree internally about if to spend money on this feature or that feature

At the same time, maybe for some rare & "really big" features, it could be worth the extra administrative work, to pay for that particular feature

> I think for most people it will still introduce stress [... ] run after things that you shouldn't.

I think so too. There's personality trait that I wonder if it is related to this: Agreeable vs Assertive, in the Big 5 personality traits,

(Actually I wrote a sibling reply (sibling to yours) and mentioned this, here: https://news.ycombinator.com/item?id=26433328 hmm maybe it'd been better if I had replied to you instead :- ) didn't see your reply until now though.)

> I'm not convinced the closed/open source nature of his code is responsible for that

Could that depend on the personality traits of the solo founder? What if it's in some people's nature, to feel bad about rejecting make-sense feature request and bug fixes, in order to instead focus on money making things? (Even if logically it'd be the long term good thing to do.) Whilst someone else might have felt just fine, doing that?

If you know about the Big 5 personality traits, maybe this is related to where you are, in the Agreeable vs Assertive dimension.

For someone who is more Agreeable, then, keeping the SaaS closed source, might be the way to go — so there simply won't be any unsupported platform installation problems to ignore but feel bad about.

Sounds like crowdfunding of new features / bugs, repeatedly, in the same software project — instead of crowdfunding a new project just once?

I wonder if there's any SaaS that specializes in this. Like, Kickstarter but for new features, preferably on the company's own sub domain? So as not to distract people with unrelated projects, when they visit the "features crowdfunding" page. And the audience would come from the company's website (but not from the "Kickstarter for features" company's website).

Or I wonder if Gumroad would think this sounded interesting.

> with some expiration so customers don't end up paying for a bug that isn't fixed until years later

Good point

> wrong person [...] a bad decision that takes hundreds of man years to undo

Makes me wonder if there's a real life story behind that

> small startups [...] can’t afford to make stupid mistakes

Yes, well, I'd say all companies do stupid mistakes?

And the small ones need to be good at noticing when they do it, and revert, undo :- )

> items shifting ... before I click ... results in the wrong choice

Or a window from a different app pops up (the app took a while to start), steals the Enter key press, interprets Enter as "Yes do [something]", and then does it (but I didn't want that!).

Why can't OS windows be click & mouse disabled for 2 seconds, after they open

Intereting talk :- ) "Steve Jobs: Content vs Process", https://www.youtube.com/watch?v=l4dCJJFuMsE 3 minutes.

I'd guess that it'd work better with a better-than-good-enough Benevolent Dictator who gets to improve the user interface however s/he wants,

than to go looking for the "magic" UX improvement process

So, a company can do dumb things, repeatedly, also if all people working there are bright

For large organizations, in a way, the whole can be less than the sum of its parts?

I wonder if there's a way to bring that approach, into the world of 1) software build servers, 2) third party dependencies, and 3) code review.

1) Build servers: Maybe by keeping it possible to build one's software on a laptop — then, when it's time to release something, one can build the software at the build server plus some people's laptops and compare hashes.

2) ???

3) Different people who don't talk with each other, do security code review, independently of each other? Hmm does that make sense

> Someone (I think uncle bob) said that good code is self-documenting, which is bs in 95% of the cases

Agreed. For example, comments about Why-do-this, and Why-Not-do-that can be necessary, even if the code shows what happens.

Imagine you're in a taxi, and it suddenly takes the wrong turn, now instead heading towards Surprise-City. Then — you know what is happening. You're going to Surprise-City.

But would't you also want to know Why?

So then it's nice if the taxi driver explains Why: "I buy milk to kitten."

I think the 'Linux kernel coding style' explains comments pretty well:

https://www.kernel.org/doc/html/v4.10/process/coding-style.h...

> basically zero presence in the parts of the web I'm around

What parts of the web are that, if I may ask?

I think Discourse is popular in software and tech related organizations — I see it a lot on such websites.

Talkyard Blog Comments, https://talkyard.io/blog-comments

(I'm developing it. Open source: https://github.com/debiki/talkyard. Not yet so well documented — soon time to add more docs, ... as per this nice discussion: https://news.ycombinator.com/item?id=26002656 )

In general, scammers want to know that something is popular, before they decide to clone it?

I wonder if they had bought website visit statistics via e.g. Alexa? And in the app store, they'll see how many downloads? ratings? already existing apps have, and can decide, based on that?

Meaning, "who was first" can work fine, most of the time?

> "theirs could be available in another store, and you copied theirs from there"

And one would need to check different app stores, e.g. who was first in any of Google Play and Apple's App Store?

> compares trust across companies

Did you mean different companies trusting each other, and thus being "hyper productive" if getting things done together? In a way that lasts also after the individuals (executives, managers, people at the companies) who initially created that high trust, have left?

It sounded more as if you had in mind to compare the "trust level" inside different companies, with each other? Maybe plotted against profitability?

In any case, sounds like interesting topics to me.

> Across countries

Did you mean how much people in different countries, trust others in the same country as themselves?

Or if nearby countries can "lift each other up" by people and politicians there, trusting the people & politicians in the other nearby countries

OSAS? Open Source As Service?