skysight-inc/HackerNews huggingface dataset:
With C++, the latest draft of the standard is made available for free [0]. My understanding is that the final draft and the official standard are more or less same w.r.t. their material content. I imagine the draft standard for OIDC is also available somewhere.

[0] https://en.cppreference.com/w/cpp/links#C.2B.2B_standard_doc...
Similar age. My answer to get motivation is this: Take on something much more difficult than you are currently calibrated to do.

AI is freaking awesome. Whatever project I choose to do now can be more complex or difficult than previously.
And laziness in a way is very natural and healthy. Resting, digesting, being present is boon to longevity, vitality, and creativity. Mindless production has been put on a pedestal too much in recent years.
I'm sorry but you just don't understand what the paper is saying.
I believe that's plausibly within the range is possible outcomes— which isn't true for any other project like Gimp, which has had its window of opportunity rise and then set forever.
The premise of this isn't really true is it, at least in the US? Don't most companies have your Equifax Work Number during the interview process?
Yes, absolutely. Nobody is entitled to service.
In a world where transportation is effectively instant you're correct. Here in reality, though, is another story. Living 2 hours away from a commercial center is practically useless unless you have one of the increasingly difficult to find fully remote jobs or enough money that you never have to work again.
Probably an LLM-assisted blog post.
Show HN: I made a curated list of Open Source Boilerplates for developers
A curated list of open source boilerplates and starter templates to kickstart your next project.
It’s not uncommon for the sums of the spreadsheet to get fed into other systems or even spreadsheets.

There being validation around that can significantly reduce errors, such as checking totals against system values etc.
Yeah there are some trainer chess boards that use hall sensors to track piece movements. But I think there is a possibility to actually encode pieces with different magnetic field strengths and flip them for each player. That way you can just do stateless reads and you'll always get the correct readout, plus you can recover from illegal states.

I did a project [0] a few years back that did this absolute encoding for senet, since there is only one type of figure and two players so just flipping the magnetic field worked really well once calibrated. I still need to make a proper writeup/video on that thing one day...

[0] https://imgur.com/a/a29CTXl
"Need" is doing a lot of work in that sentence.

This is from just a quick unrefined search:

https://techcrunch.com/2023/03/02/secret-service-ice-warrant...

https://arstechnica.com/tech-policy/2015/06/county-sheriffs-...
> Anyone have any tips that worked for getting over this hurdle?

This might give you something to work with: https://news.ycombinator.com/item?id=42102050. Maybe you're confusing natural and reasonable behaviour with self-sabotage? They look the same from some perspectives (such as perfectionism and people-pleasing).
How I fucked up working with a multi millionaire?
The ergonomics here for 99.999% of uses seem great to me. Whatever async function you have can run for as long as it needs. That's using the language, not adding more userland craft. It's a good move.
Javascript in browsers already has a full atomics API:

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Refe...

I'm not sure why Web Locks is useful TBH. I guess if you don't understand atomics it's a friendlier API?
Neat! I don't often see text-rendering algorithms I didn't try myself. I implemented several at my startup. This wouldn't have saved me because I needed resolution independence, and anti-aliasing. Also it might not generalize to all bezier curve font files. Converting curves to pixels can be hard, especially when glyphs cross over themselves. In general, it feels like standard text rendering is solved, and non-standard use-cases are brutal to attempt.

This actually seems conceptually similar to my favorite method by Will Dobbie (but much simpler). Both take raw font data and use it directly on a shader. The difference being, this method takes pixel data and stores it in arrays. Will takes svg path data and stores them as a "vector texture"

He made a cool demo, if anyone is curious: https://wdobbie.com/warandpeace/
we're not on reddit. I see nothing like what you're talking about here.

Like most legalese CYA, the rules sound fine as long as they don''t use it to copyright troll everything under the sun. So it's more on how/where Rust enforces this than on the rules themselves. Those who profit from drama will find drama no matter what, so their opinions aren't worth consideration.
I'd say it goes with the "write everything twice" heuristic! If you're in an environment where you can write things twice—you have trust and autonomy and aren't encumbered by process—then writing an initial version as fast as possible gets you started faster, lets you play with something concrete and leaves you more room for your second version.

My best projects were like that. I'd figure out something quick—some combination of reducing scope and doing "things that don't scale"—then spend time refining the conceptual design and interfaces, and finally rewrite the initial piece based on that new design. This can absolutely work better than just trying to write something "good" the first time around, but it looks wasteful to somebody superficially tracking individual "tasks" you're working on.
The US taxpayer should not be paying for immigrants' healthcare expenses.
Truly a mechanical turk
Is 3D printing being held back by an invalid patent?
Parts made using the FFM (FDM) process are stronger in some directions than in others. This is due to imperfect adhesion between printed layers. This directional or anisotropic structural strength is a significant limiting factor for the structural integrity of 3d printed parts made with the common FFM process.

A method to drastically reduce this effect is described in an expired Stratasys patent, US1997/5653925A. As of this writing, I have not seen this feature implemented in any of the common open-source slicers. I would have expected this now-public-domain knowledge to have made its way into the slicers we use since the patent expired in 2017.

With some investigation, I believe this may be because of the 2023 patent US2023/11813789B2, to my knowledge only implemented as a proprietary in-house product of a 3d printing service house which appears to make the same claims illustrated in the 1997 Stratasys patent.

I am not expertly versed in patent law, but this patent would seem to have been granted in error. The fact that the 2023 patent actually references the Stratasys patent from 1997* makes the issuance of this patent even more baffling. At any rate, this seems like a low-hanging opportunity for a significant improvement in print strength that could benefit millions of users.

*The 2023 patent references the 1997 Stratasys patent as “teaching a process for adjusting the deposition rate .. to provide a predetermined porosity rate” but neglects to mention that the core claim of the patent was the staggered bead heights claimed.

In referencing the 1997 patent the 2023 work also gives a single-digit error in the patent number, as well as other “minor” errors in other patent numbers referenced in the patent. These misleading references could have impeded the examiner’s role in determining the validity of the patent.

https://patentimages.storage.googleapis.com/08/f6/2b/d3d9964...

https://patentimages.storage.googleapis.com/ea/e7/3c/2b836c9...

Looking up the 2023 patent filer leads to this:

https://www.addmangroup.com/
F# has been my favorite language since I first encountered it in uni.
F# was/is waaaay out ahead of C# with features like unions, null safety, pattern matching, records, more powerful type inference and generic constraints.

Over the years C# has been implementing these features too, which is good, but they have been implementing them in incompatible ways, which isn't very good. Since the investment in F# has been much smaller than in C#, it hasn't been innovating as fast as C# and has been left behind in some ways.

But it is still a great language and remains broadly compatible with the ecosystem and can deliver equal performance to C# with far less boiler plate
Install FreeBSD with One Command
My go-to ice cream book is Jeni Britton-Bauer's https://jenis.com/products/jenis-splendid-ice-creams-at-home (which won a James Beard award), and her base for all but a few custard recipes is milk, cream, sugar, starch, and cream cheese. I love eggs, but they are not a required element of top-shelf ice cream.
> I just question how useful it truly is as a heuristic

I think the author is presenting them as analytical tools that might or might not be useful depending on the situation.

Very often when faced with a difficult problem it's hard to know where to start attacking. Any idea, even if simplistic and wrong, can be useful to start gaining insight on what is going to work and why; even just refuting the original idea with a clear counterargument might suggest alternative avenues.

OT: this is IMO part of the reason why people like LLMs so much. Maybe the answer is trash, but articulating why it's trash gets you unstuck.
Gun to the head solutions: no tests, no quality, no future planning, hacks on top of hacks, tech debt.

As a manager, this "thought exercise" is dangerous. You think it is a fun and harmless exercise to your reports to really focus, your reports at best think you don't trust them, and at worst think you are threatening them with violence (hypothetical or otherwise) unless they tell you what they think you want them to say. Psychology safety will be at rock bottom pretty quickly.

Nice job you have there, would be a reaaaaalll shame if anything hypothetical happened to it huh? Now estimate again, and this time don't make me angry <imitates pulling a trigger of an invisible gun at someone's head>.

Absolutely terrible behaviour.
> using trademark to enforce rules on unofficial events ... seems to me to be relatively recent.

It isn't. It's completely standard practice. Python uses it in the same way and you probably didn't even notice (and Go as you discovered).

It's not a new tactic. It's literally what trademark law is designed for.
A lot of the points are presented from the perspective of a ruby developer looking at python, not something that's relevant to a new learner. Some of the points aren't even relevant to pythonic programming, like getters and setters. I also noticed they didn't show how to declare a class, because it would be a lot simpler.
> all midi messages & all 16 midi channels are recorded

Looks like it does.
This is really neat.

It'd be so easy to do a version of the "infamous Dropbox comment" on this ("you can already build such a system yourself quite trivially by getting a MIDI cable, an audio interface, and a raspberry PI...") but of course what you have is exactly a sort of Dropbox Of MIDI here where it Just Works™ and backs up all your music automatically with no hassle.
Not that it's super important, but Web Locks API is getting some circulation after a question about how you keep multiple pages from trying to use a (single-use only) oauth refresh token at the same time. Which is a pretty good use case for this feature! https://bsky.app/profile/ambarvm.bsky.social/post/3lakznzipt...
20k isn’t noise to most people in a 200k salary range.
Thanks, we'd love to assist you in getting involved with contributing to our project! It's something we take pride in, making it more accessible than most other open source projects to begin contributing to. Come join our Discord (link is on the website home page) and introduce yourself like in your comment here. Cheers!
Um, have you ever looked at "stock photography sites"? Here's Getty, one of the largest:

NSFW - https://www.gettyimages.com.au/search/2/image?phrase=nude%20...
C# these days is GREAT, but F# still has features that C# doesn't like unions and much more powerful (and ergonomic) pattern matching.

And line for line, F# is more effective at getting things done (and i would argue with less bugs)
> to show other engineers that your idea of how much you should be payed could be completely wrong.

Defintiely could be. But not in this economy. I'll take what I can get.

But in general, it really is a matter of knowing your worth and what they could pay. IF you have a certain noteriety in a community of a domain and you get an offer, understand how much leverage you have vs. yet another front end web dev. Let alone 99% of students out of college.
F# is full supported on Windows, MacOS and Linux via CoreCLR and several more platforms via Mono, just like C# is
Ah, the United States of America, this is hardly possible in Europe, especially Germany.
I was trying to do something like this a while back, our approach was to have a different color underneath each piece, with an elaborate setup to get the colors reflected into a camera, but I could never get the color detection working reliably with the way we were doing it. It was a fun project though, there's got to be some easy way to detect moves and get a cheap-ish internet-enabled board.
How does a shared memory space work if you have different versions of scripts for the same domain?
> No one is going to say, “I love lots of footnotes in writing.”

I will. Sometimes the footnotes[0] are even the best part.

> Otherwise, it would save a lot of time to write in a more informal tone or to not have to use citations.

It may save authorial time, but it saves reader time even more by driving it to zero. As a reader (even as a reader primarily for entertainment), I'm aiming to spend my limited attention on things that someone else has thought about for a lot[1] longer than it'll take me to absorb, not just brain-dumps on a whim: ideas, not vibes.

[0] eg, those in https://www.youtube.com/watch?v=ObvxPSQNMGc

[1] see https://news.ycombinator.com/item?id=40147526
Tracing paper and a light table enabled us to iterate on Ames' Draw 50 series without the discouragement of drawing a misshapen form at the end of labored steps.

Cars, birds, and airplanes fill the transparent sheet, are taped up. I see the Concorde I quit after a first draft; decades later, reappears to me intact (with only some waver of line), colored in, next to passenger airliners and a dozen vehicles.

My hope is seeing the final form encourages continued practice, and so far it's true. Lines can become confident later. Even architects use projectors, clippings, and other "shortcuts" to fill in the gaps.
Needs a year. He died in 1996.
MdBook – a command line tool to create books with Markdown
> The way I read it the intent is to ensure there is one sanctioned version of Rus

basically that

Through it's very annoying that it needs refinement _again_ and _again_ every f* time they update the trademark policy.

Like why

- is there no exception for research (i.e. science) use, as long as explicitly labeled at such

- public development forks which are used to prototype directions rust could go into, again if clearly labeled as such and not maintained as forks (through to be fair the line between a public experimental rust development fork and an early rust "full" fork are thin)

- wrt. software compatibility allowance why is it limited to the "packaging system of that platform" can't I fork to idk. create compatibility with a code analysis tool, changes I then later want to upstream but first need to test so need to distribute to various people?

and sure you will normally get written permission for all the cases above, just the chance that someone could abuse this preventing you from doing very reasonable thing is IMHO an issue. I really don't want to see a headline like "rust forbids <company> from creating a compatible code analysis tool because <some stupid issue>".
Yeah, existing proprietary (e.g. Apple/Google) push notifications are not E2EE, so apps that need to convey sensitive information (secure messaging apps, etc.) tend to take this approach already regardless of push provider.
It makes no sense that intelligence research is unintelligible to a wider audience. I almost gave up reading, but then thought, no I want to understand this. Good thoughts … we need a Carl Sagan to communicate it better!
In retrospect, what are the things you would reconsider in your office design?
We are currently in the process of designing our new office, we are software developers, the office is 160 sqmt.

Since many things are typically discovered only after living in the office for a couple of weeks, it would be great if you could share your own experience and considerations.

Also, things you would not do.
Show HN: Open-source tool to convert ComfyUI workflows into web apps and APIs
We built an open-source solution to transform ComfyUI workflows into production-ready web applications with minimal configuration.

The project consists of:
- ViewComfy (open source) - A tool for wrapping ComfyUI workflows in clean, user-friendly interfaces: https://github.com/ViewComfy/ViewComfy
- Cloud deployment layer - Includes an automatic dependency resolver that handles model management and node installation. Deploy either as interactive web apps (using ViewComfy) or REST APIs: https://playground.viewcomfy.com/deploy

Key features:
- Zero-config deployment of any ComfyUI workflow
- Automatic model/dependency management
- REST API generation
- UI builder components

You can get started by dropping a workflow here: https://playground.viewcomfy.com/deploy
It can be annoying when unexpected, though. I was writing out a substitution for a recipe and typed “1/4 oz =“ and it completed to “0.25 oz”. Useful.
Also check out https://github.com/D-Star-AI/dsRAG/ for a bit more involved chunking strategy.
This is the first thing that came to mind for me too. However, I am distinguishing this particular case (e.g. enforcing that you don't use trademarks in a way that would imply something is official) with the Rust/Go/Python trademark policies (e.g. enforcing a set of rules when using a trademark to refer to something in a clearly unofficial context.)
F# can also be compiled with NativeAOT. The main thing this target complains about is printfn and especially printfn "%A" which uses unbound reflection. So as long as you just Console.WriteLine instead it may not emit warnings:

dotnet publish -o {folder} -p:PublishAot=true

Note that -c Release is no longer required - it is now a default for 'publish'. Also, if you are doing a self-contained/non-AOT build, you may want to do it as follows to retain compact binary size:

dotnet publish -o {folder} -p:PublishSingleFile=true -p:PublishTrimmed=true

All the properties above can also be defined within respective .csproj/.fsproj files inside PropertyGroup blocks as e.g. <PublishAot>true</PublishAot> so you don't have to add them to a command every time.

F# also has excellent support for scripting with fsi and .fsx format: https://learn.microsoft.com/en-us/dotnet/fsharp/tools/fsharp...

Someone even made a tool for it which builds on top of bflat allowing to compile F# script files into native binaries directly without project setup: https://github.com/ieviev/fflat
This is UK
This is why we Europeans like working at American companies (in Europe)
Great job on this! With the ability for it to send midi over Bluetooth, it sounds like it could also act as a de facto replacement for my Yamaha Bluetooth USB adapter UD-BT01 (which has always been a bit fiddly), would that be a fair assumption?
Read-only use of an externally provided collection, presumably.
The sync uses native iCloud, so completely isolated and I have no way to look into any other account data, so this is completely handled by Apple :)
I‘m also planning to optimze the app for iPad and add a macOS version as well in the future
You basically just described Qubes OS, which I use as a daily driver.
This comment section has been extremely valuable. Htmx for the win?
That's great transparency. And I imagine you get what you pay for. That's honestly not a bad thing as long as it's a living wage. You don't always need an achitect, especially non-tech .

But we should always keep in mind that these crazy salaries aren't all a result of impact software can make, but also as a bid to prevent other companies from hiring those architects. Paying someone an extra 200k/yr to potentially keep a new competitor from making 10m/year is an obvious bargain sale if you can afford it.

At least, that was the gameplan back in the '10's. I think we're past that point and those levels of salariesare only reserved for director+ level people in 2024/5.
The biggest difference happened between 2020 and 2024. I encourage you to give it a try - F# support with Ionide in VS Code is excellent.

There is no other platform like .NET in capability to cover both high and low level scenarios.
Starch and cream cheese?!
Whoa. Talk about secret ingredients.
> navigator.locks.request("my_resource", async (lock) => {

This would be so much more readable with `using`

{
using lock = navigator.lock('my_resource');
await do_something();
await do_something_else();
}

(https://github.com/tc39/proposal-explicit-resource-managemen...)
Notice I’m not suggesting that people go for “hard” negotiation. You don’t loose anything by not revealing comp early. Worst case you will get offer that’s too low. But best case you get offered above what you expected.
Reminds me of a DEW. =/
Related:

GitHub Gist: "Document Conversion":

https://gist.github.com/datacustodian/4483fff487a0ef70c7b760...

https://en.wikipedia.org/wiki/List_of_document_markup_langua...

https://pandoc.org/

https://news.ycombinator.com/item?id=39164002

https://asciidoc.org/
I generally agree with the thesis here.

Adjacent points: I also think that selecting mature projects for your dependencies matters significantly. My old couchdb or early node work is generally defunct. On the other hand, I have some dotnet projects that are still functional with zero updates from a decade or more ago.

Additionally, it's reasonable to keep a copy of your dependencies somewhere in case the vendor dies, the licensing changes, or something else catastrophic happens. Even if you just image dev's machines when they offboard. There have been a few times this has prevented permanent project death or rewrite emergencies for me.
Does it? In any more specific way than that where Plucky runs to, his wrestling adversaries are waiting for him? They don't seem surprised to see him in the ring. :)
I agree with this, but when working with a team I always feel motivated to see the progression made. Rarely do solo developers work well with others and rarely do collaborative developers work well by themselves. It really depends on the dynamic of the environment and the goal of the team.
I remember this being discussed: https://news.ycombinator.com/item?id=41914724
Now the question is where to find American companies willing to do B2B/freelance contract without location-adjusted bs.
Automatic Differentiation in Ruby (2016)
Sometimes I feel like someone already wrote what I am writing and it doesn't feel good to just work on something I know could be critiqued hard because an alternative exists.
Sadly modern idiomatic C# is a bit of a nightmare these days. It's a heavily abstracted/"indirected" style, where you are basically forced to use a debugger to determine where a method call actually goes. The goal seems to be to make things as emergent as possible, with reflection and IL emit determining code flow as much as possible.

I think that F# goes a long way to prevent this, by nature of being functional.
Really cool!

Side note: there are some typos in the last header :P
> From the point of view of academia

... but they did not specify their pov?