skysight-inc/HackerNews huggingface dataset:
I see a different perspective. Unless all salaries are equal and capabilities and efforts of those receiving them are perceived to be equal, the only thing that salary disclosure really does is create morale issues within an organization. If you perceive that John Smith is weak and lazy, but know he makes 20k more than you, that creates discord within you. If you attempt to negotiate an increase based on that knowledge, you might find that your organization doesn’t have the same opinion of John Smith’s value to the organization than you do.
Don't optimise until it works.
Mississippi Fires Lawyer Trying to Recoup Misused Welfare Funds
Yes I meant colliding (sorry french here), Yes i'm lead developer of dappy project.
Interesting, I don't know any of your synonyms from my personal experience. The especially negatively connotated variant I know is 'McDoof' (basically 'McDumb' when translated to English).
Here's a couple of detailed and quite challenging videos [1,2] to help
you understand, in words far better than I can offer, why the present
governance structures of universities are widely regarded as
illegitimate by some of the greatest minds who work in them.

[1] https://www.youtube.com/watch?v=Z5EWYohECRQ

[2] https://www.youtube.com/watch?v=ANdhnoAadZk
It’s not though. At least according to every description of steelmanning I read you’re supposed to replace an argument you encounter with the best possible argument. But the best possible argument might be different enough that arguments which address it don’t address the original argument. Which is my whole problem with the practice. If you only make minor improvements to what I say that makes the arguments responding to my claims identical to the arguments responding to the new claim then I have no problems. But people in practice steelman arguments in ways that change the responses too them. At some point, if you aren’t actually addressing my claims we aren’t actually having a conversation.
Write simple, clear code. Make sure it's readable. If you come back to something a few days later and you think it's hard to understand, add a comment.

Be as consistent as possible with your styles and naming conventions. A large project is significantly easier to read when every class, method, ect, follows very similar style guidelines.

Make sure that you don't need to "think" when reading code. (IE, you shouldn't have to page up and down to remember what type a variable is.) Often this is solved by including type in a variable name, and using some kind of convention to determine scope. (For example, always use "this." so you can tell that a field is a field instead of a locally-scoped variable.)

Try to follow a consistent pattern for line breaks, especially for when a line gets over ~120 characters.

IDEs that let you view code side-by-side on a wide monitor are very useful.

Invest in a giant monitor. I use a 50" 4k TV that I picked up on sale.

Edit: Always be skeptical of frameworks and 3rd party libraries. Put a lot of time into evaluating them, and choose wisely. It's always significantly more work to remote / replace a bad 3rd party framework / library than the time you put into choosing it.

Sometimes "no framework" is easier than a framework. Only writing a few queries? Consider skipping a complicated ORM. A clear startup sequence that builds a shared data structure of long-lived objects might, in the long term, be easier to debug than a complicated dependency injection framework.

Sometimes "no framework" is easier to learn than a complicated framework. Newcomers to your team may appreciate that it's easier to read 1000 lines of simple code instead of needing to spend days understanding a 3rd party framework.

Edit2: Don't underestimate the power of unit tests and automated tests; especially for long-lived industrial-strength software. Take the time to learn how to write good unit tests that you can quickly run in both your development environment and in CI. (Continuous integration)
Isn't this right around the node that is under huge pressure right now, causing unprecedented shortages and backlogs for sectors such as automotive or medical devices? Might be nice to have more help there.
Related:
Titanium man: "Taking the core of one’s argument and rearticulating it at a higher level of nuance, sophistication, abstraction, and complexity. The argument is buttressed with more perspectives, contexts, and variables" https://greenteaji108.medium.com/from-the-steelman-to-the-ti...
The laptop market is driven by enterprise not individual consumers.

There's little business case for upgradeable laptops due to depreciation schedules and labor costs.

The history of upgradeable consumer and small business computers suggests that there's no actual demand.

Probably because people who want the latest, want the latest, not a half-measure.

There's good margins from FOMO.

Logistics swamp margins in fear of FOMO products.
> Write code that is obvious, clearly readable by future programmers maintaining the code

I agree, with the caveat that does not mean low-level/unabstracted/verbose code. Whilst each line of such code might be "obvious" on its own, the big-picture behaviour and inter-dependencies can be difficult to follow across multiple pages.

As an extreme example, machine code is completely "obvious" (e.g. "increment register RAX"), whilst being notoriously hard to follow (often requiring disassemblers, etc.)
But that would spoil the dad joke where everybody pretends they can't see it.
Here's a trick I wrote with `GNU grep`:

grep --group-separator= -A0 '.'

The above command is equivalent to the below `awk` command (including removal of empty lines at start/end of input):

awk -v RS= '{print s $0; s="\n"}'

Both the above solutions can be changed to a different group separator instead of single empty.

You can also just use `cat -s` if you don't need a custom group separator and don't care about start/end empty lines.

$ printf '\n\n\ndragon\n\n\n\n\nunicorn\n\n\n' | cat -s

dragon

unicorn

$ printf '\n\n\ndragon\n\n\n\n\nunicorn\n\n\n' | awk -v RS= '{print s $0; s="\n"}'
dragon

unicorn
$181M in Bitcoin buried in a dump. $11M to get them back
I like code-golf challenges. To write shorter code, you have to first find an algorithm that's short to write and also know all the ways you can re-write existing statements to make them shorter (which are often language-specific). This forces you to learn operator priorities (when you can avoid parentheses), what are default variable values, short-circuited statements, when you can re-use the same variable or ways to use built-in functions for things other than they were built for, etc.

Some code-golf tricks examples, for JavaScript: https://www.geeksforgeeks.org/code-golfing-in-javascript/

A few examples, if you skip the link:

// Check if variable is upper case
'g' < {} // Returns false, lower case
'G' < {} // Returns true, upper case

If you were to use a 'g' < 'a' you would need an extra character.

// Ceil
a = Math.ceil(a);
a = a%1 ? -~a : a;
It doesn't go nearly as far is it should, indeed, and at least in Texas, you can't claim the homestead exemption the first year you own a property. So I bought a house from someone who had been claiming the homestead exemption and also a senior discount. I immediately filed for the homestead exemption as well, but that doesn't take effect until the second year you own the house. So the property take history looks like: very low, very low, very high, somewhat low, somewhat low.

That rule about paying the full amount on year one is... odd.
That's an entirely valid point. We'll seriously consider taking it out. It provides an interesting case study and allows for some interesting conjecture, but it certainly isn't core to the arguments we hope to make and its lack of credibility probably does more harm than good to our overall arguments.
No idea, easy enough to test with a private link though if you really want to know.
Learn your development environment (IDE, or text editor). It may contain features that will make your life easier, both during development and during debugging.
How come STM32s are not available? I thought the chip supply issues were mostly related to smaller process nodes while these should be made on relatively older ones.
if it’s actually dogs, then they should get a job, pay taxes etc etc
There's a significant difference between "so you want people to sit at home all day and collect free money", and "so you want the people who sit at home all day to collect free money".

The former is a clear misrepresentation of the views of most UBI proponents. The latter is an accurate part of their views, albeit a loaded/(mis)leading statement.
Please explain how “our own governments” are in any way responsible for the actions and choices of one of the most brutal communist regimes in history. I’m presuming you’re Western. “Our own governments” have much to answer for, but North Korea isn’t one of those things.

The only alternative historical path would have completely erased South Korea, now a prosperous country that acts as a positive influence on the region and world. If any outside influence is responsible for North Korea, it is China, any other take beggar’s belief.
We're just gonna add a 6th standard to end all standards.
I’d definitely agree with that. I get more of an amateur interested in history (and from a quite strong English bias, at that) vibe than someone trying to present historical research, but it’s good to call that out.

There are actually several (maybe even most/all?) channels above that I would describe as “interesting voices” rather than “credible, non-biased experts” so take them with a grain of salt.
Somehow reminds me of monad...

btw defunctionalization usually means converting higher order functions into statically known function calls
Depends on your requirements. I have an M1 Air and I don't use it much compared to other notebooks. MacOS isn't flexible enough for all tasks and PCs just offer more here. Not a fan of the latest Dells either, but I understand preferring it.
That's only true because they used build-in int type. Why would I prefer to use:
var inst : MyClass;
over
MyClass inst;
looks like twitter bootstrap
I dunno. I've never tried the fake version. You could predict the same to be true about Impossible Burger but that has done well.
If you're having trouble naming something, don't just name it `x` or `a` if this is something you're going to have to maintain. Instead, it's a red flag that your abstractions are wrong. It's often worth taking some time to figure out if there's a better structure.
Ask HN: Generate sequence 10, 20, 50, 100, 200 ... 5,000,000,000,000,000,000,000
The R code that generates this sequence seems very beautiful.

How you would generate the sequence in your language of choice?

Full sequence:

10 20 50
100 200 500
1000 2000 5000
10000 20000 50000
100000 200000 500000
1000000 2000000 5000000
10000000 20000000 50000000
100000000 200000000 500000000
1000000000 2000000000 5000000000
10000000000 20000000000 50000000000
100000000000 200000000000 500000000000
1000000000000 2000000000000 5000000000000
10000000000000 20000000000000 50000000000000
100000000000000 200000000000000 500000000000000
1000000000000000 2000000000000000 5000000000000000
10000000000000000 20000000000000000 50000000000000000
100000000000000000 200000000000000000 500000000000000000
1000000000000000000 2000000000000000000 5000000000000000000
10000000000000000000 20000000000000000000 50000000000000000000
100000000000000000000 200000000000000000000 500000000000000000000
1000000000000000000000 2000000000000000000000 5000000000000000000000

R code:

options(scipen=99);(rep(c(1,2,5), 10) * (10 ^ (sort(rep(1:30, 3)))))[1:63]
Suppose I have a procedure that plays a piano:

const playTwinkleTwinkleLittleStar = (piano) => {
piano.play('c');
piano.play('c');
piano.play('g');
piano.play('g');
piano.play('a');
piano.play('a');
piano.play('g');
};

Now I want to have every note played twice. How can I do that?

Usual OOP solution is to have a wrapper on piano:

const playItTwicePiano = (piano) => {
return {
play: (note) => {
piano.play(note);
piano.play(note);
},
};
};

playTwinkleTwinkleLittleStar(playItTwicePiano(piano));

However, if we instead return a description of what to do, such manipulations compose far more easily:

const twinkleTwinkleLittleStar = () => {
return [ 'c', 'c', 'g', 'g', 'a', 'a', 'g' ];
};

const playItTwice = (sequence) => {
const xs = [];

for (const x of sequence) {
xs.push(x);
xs.push(x);
}

return xs;
};

And it's easier to test:

it('should start with c', () => {
const xs = twinkleTwinkleLittleStar();

assert(xs[0] === 'c');
});

Wherever you are building a complex mock for testing consider defunctionalization instead.
Those (most) companies do not filter out immature people who are incapable of hearing contrary opinions.

It's a very common problem, particularly in tech, which has a very young employee base.
Africa?
Depending on what code generation you are doing you have alternatives. Biggest one being Type Providers which are arguably better than anything I've seen from source generators so far (which I found incredibly buggy when I used them, and at one point I had to reinstall visual studio it bugged out my environment so much when messing with writing my own).

And see above for database, Type Providers are great at least for SQL server, I think the sql one also works for PostGres but I never used it so not certain.

GUI is a mess last I knew though I agree.
All you've proven is that controlling the default is a viable means of making a decision for someone.

I assure you, Opt-outs are much less likely to happen when combined with not explaining there is a choice to be made in the first place.
they put all the best to k9s: ncurses style of UI + vi style of key bindings
I have no dog in this fight, but I do want to point out that’s it’s not exactly true that Counter is implemented in pure Python:

* it’s a subclass of dict

* its update method (used by the code in the post) dispatches to a C implementation on its fast path
Could this be used to, say, reverse-engineer the Chitubox-proprietary file format that a lot of 4K+ MSLA printers use?
Merely supporting it or in leadership role? Either way...
Yea, I appreciate his really clever naming of that.
This was a major point of contention during the chip shortages. Automotive and medical devices are stuck on very old nodes, like 180nm. This MediaTek partnership is using way, way too new of a node than they would like, while being too old for smartphones. 22nm would be lightyears ahead of where they are.

Chip makers view the situation as being simple: Car makers and Medical need to upgrade their tech to newer nodes, as they aren't interested in building new 180nm-era factories. Car makers and Medical chip makers blame, well, the chip makers and say that redesigning those chips would be very expensive as well as to re-certify, but so far the chip makers don't care.

And so rumor has it, though rumor only for now, that car makers are finally updating because there is no other choice. To what though? Probably the next-oldest and cheapest node, 40nm or older, not 22nm.
A post I made elsewhere, which seems pertinent here:

Politics and Hermit Crabs

Hermit Crabs wear a shell for protection. If they get separated from their shell, they get frantic and often die if they can't find a replacement. They don't like it when people mess with their shell.

Imagine coming up with a brilliant, powerful political argument. You can smash the shell right off your opponent. Will they thank you for it? There is a real human psychological need behind people's beliefs. There is lived experience behind these beliefs.

It can feel like a real attack when that lived experience is invalidated. People retract into their shell, or attack right back. If their shell is actually busted, they probably won't stick around and find out what else you plan on doing to them; they'll run off and they may find an even worse shell.

So what then? Just accept that they will wear a terrible shell forever?
I think that you have to accept their current situation. You don't have to accept it forever, but you have to see them where they are now. You can't change their shell, and you shouldn't expect them to change to a shell that matches yours any time soon, but if you don't drive them away, then maybe they can accept that your shell is valid, and find value in your point of view.

And to be clear, you don't have to do this for everyone, and you sure don't have to do it on social media. You may not be able to accept anyone's terrible shell right now. That's fine. But remember that we all picked up our shells from our environment; we carry our history around with us.
What makes you think that "there is no trade-off analysis" ?

I find the assertions of "overruns" to be mere hand-waving. Likewise the repeated invocation of "activists".
https://www.nowleap.com/the-patented-mediator-release-test/

Importantly, should be ordered by a nutritionist and requires a blood draw. It’s got some challenges but overall helped me when paired with a restricted diet. Easy to relapse though, 2-3 months versus a lifetime of eating behaviors.
What is a “fact” other than a piece of information demonstrated through repeated direct observation? Acting as if “North Korea is bad” is “just like your opinion man” is one of the most bad faith statements I’ve ever seen on the Internet. It’s utterly ridiculous and you know that too.
I do believe cooking food neutralizes most of those toxins.

Anyway, I do believe (citation needed) that food sensitivity is also correlated to gut biome, and that some sensitivities can be overcome with dietary and/or gut biome changes.
The term "hypersonic missile" these days is short-hand for terminally-guided endoatmospheric missiles that can operate at hypersonic velocities. This is an extremely difficult engineering problem and there is no evidence that anyone has an operational weapon in this class.

Nothing in the Ukraine fits this description. Those are ordinary ballistic missiles, which naturally have hypersonic ballistic re-entry. There is nothing interesting about that, we've had it for 70+ years now.
The Magic Keyboard on the 2019+ models is really nice, going back to my unibody MBP made it feel like wet cardboard.
Haskell monadic IO is basically this pattern, yes.

Term from this blog post: https://www.gresearch.co.uk/blog/article/defunctionalisation...
> Scientists have ruled out any connection with coronavirus or Covid vaccines.

Well, that's a relief.
"Two minutes paper"
There's a difference between (1) a statistical survey, (2) "the news found it somewhere and needed clickbait to stay in business", and (3) regular people are reporting seeing it. Of course, properly collected statistics is best, but short of that, I'd be more inclined to believe it's widespread if ordinary people are reporting it's around them. It's the news' job to go around and look for a story, so they're likely to find it somewhere. Neither is proper proof, only statistical survey would be, but a combination of 2 and 3 is close enough for me and you've already said it was on the news, thus my question.
abc * xyz;

Depending on what abc is (variable or type name) it can be either a multiplication or pointer variable declaration. With the new syntax ambiguity is reduced.

This might not be a huge issue for people reading code (because in context it should be pretty obvious), but for compiler it means that type information is required to parse code and compiler stages get mixed together.
It appears that children not getting sick in the first few years of their lives paired with some mutations that aren't uncommon can cause the immune system to stay too weak. This is one of the leading theories why so many children get Leukemia. This is a pretty serious scientific study on the phenomenon:

https://www.nature.com/articles/s41568-018-0015-6
NFC transactions are powered by the EMV chip, and include all the same signing ond one-time-key exchange as a chip-insertion but without the potential for skimming the mag strip
I follow a few general learning videos, some of them cover seemingly random, but interesting, topics. But I have my favorites, and here they are.

- Technology Connections - Somebody already mentioned his channel, but it's worth it to find out how the stuff we take for granted works.
- Today I Found Out - One of Simon Whistlers channels, he covers a wide range of topics, diving in to where you are just almost over your head.
- Answers With Joe - Joe Scott covers many topics with a bend towards science appreciation. I would use his videos in late high school lessons if I were a teacher.
- Knowing Better - History. Mostly American History, but it's a really deep dive. I like his delivery and his unapologetic way of discussing the really bad parts of history that people tend to sweep under the rug.
- Half as Interesting - It's from Wendover, but short and funny.
- Kyle Hill - The Internet's knockoff Thor, he explores deep science and physics in an approachable manner, especially when he is in "The Facility".
I'm probably just biased, but to me the problem with modern C++ is its complexity. The mental model of the language, its syntax, and the amount of history / number of interfaces a programmer needs to be familiar with to be productive are all too large. Rust isn't any more complex, but it's not radically simpler either. Carbon doesn't look like it solves this problem. It would seem that creating a language that is expressive, performant, and small while still general purpose is quite a challenge.
I did for a while. Mostly fun one-offs for popups and events rather than practical applications. Once I got a taste for it I tried seeking a career in it but there's just very few places doing it and I wasn't able to get my foot in the door. The market exists but it's small.

I can also tell you it's really not rocket science. We built UIs the same way we build anything else. A lot were just web pages with a machine locked in Chrome kiosk mode. Some were Electron or Unity if we needed razzle dazzle. You can get all kinds of off-the-shelf devices control lighting or read input from all kinds of sensors that just go in a USB port. You can rig stuff with microcontrollers but for a commerical project, you can buy bulk devices purpose-built for whatever task.
Embodied thinking: The antidote to being in the zone
> How finishing what you start makes teams more productive and predictable

What's even better? Starting the right things that deserve to be started in the first place.

Efficient !== Effective
Yeah, well, we got married fairly recently, so we're actually saving a decent amount of money compared to before we met. Plus we both like pretty small places. Enough room for the cat and for love.
I was not replying to the document, but to catchclose8919's comment where he advocated "handing extra child care support to educated people in helthy societies and contraception to the others."
That hasn't been my experience, personally. In fact, sometimes I wish decltype was easier to use, to declare type dependencies.
Most kids nowadays (hopefully) get the chickenpox vaccine and never have to suffer from it or shingles as adults.
Yeah, the problem is amount. Owning more than you can use should be highly discouraged. Imagine if you declared ownership of a chunk of the sky or the ocean.
Get someone else to do it or do it yourself, pick as appropriate.
I think it's more likely that Unity will end up in a situation similar to Apple during the period where they messed up the Mac Pro and Macbook Pro - not losing huge sales, but the creative trendsetters that used to be their biggest evangelists will start looking for alternatives.
Once you are doing a job that you see as being in any way productive and adding to the world (vs parasitical) and of course can live on it, then that is already the end goal. The only other goal is just family and get as many years of that state of being as possible.