skysight-inc/HackerNews huggingface dataset:
On the other hand, many companies view GPL software as some sort of kryptonite these days. So a good number of them -- at least the ones that are knowledgeable about software licensing -- won't even go near your software. Personally I'd consider this a good thing; opinions vary, of course.

Certainly there will be some companies that will just see open source code out there and use it, without considering the license at all (not even sure this is most often malice; I expect usually it's just a random developer who doesn't know any better).

But ultimately it's up to the copyright holder if they want to bring some sort of legal action or not. With MIT, you can't stop anyone from doing much of anything, for the most part. With the GPL, you at least give yourself the option, should you decide it's worth pursuing.
I've tried a couple of them. The problem is that they add so much friction to the basic functionality you want from a phone that they eventually become too frustrating to be worth it. Using a Light Phone gave me an enormous amount of respect for the work Apple has put into making their touch screen keyboard feel so responsive and type so "accurately" (by which I mean gracefully handle the inaccuracies that inevitably arise when typing on a touch screen). I just don't see a small startup ever being able to deliver a user experience that even comes close to what we've all gotten used to thanks to Apple, Samsung and Google. At the time that I bought a Light Phone I was desperate to be free of digital distractions but eventually I decided I would rather be distracted if it meant that I could effectively communicate with family and friends and maintain a social life without so much hassle.
3DS Emulator Citra is closing up shop and removing all their sites/code
I bet you thought you got him. My mans just learned that you can like a game without liking the company that makes the game
I mean, yes, if you have a small org with one CRUD app on a handful of VMs, but if you want nice things like "lower environments that mirror production environments", "autoscaling", etc then yeah you pretty quickly run into the kind of complexity that justifies Kubernetes, a cloud provider, a PaaS, etc. Essentially, the problems start coming when you have to manage more than a handful of hosts, and you pretty quickly find yourself reinventing Kubernetes, but you're cobbling it together from a bunch of different tools developed by different organizations with different philosophies using different configuration schemes and your team (including everyone you hope to hire) has to understand them all.
Right. Pin is the canonical way to have objects that can't be moved, and it was invented in order to support objects with self-references (namely, futures). However, Pin's design is pretty hacky, being implemented purely 'in userspace' without any language support.

There's widespread desire to add some form of language support for pinning someday, if only to make the ergonomics a bit nicer (e.g. not needing a method call to reborrow mutable pinned references). This would probably also be needed in order for the compiler to support self-referential structs. From I've seen there are two quite different proposals for how to add language support for pinning. One is to add sugar to `Pin` while keeping the design mostly the same. For example, `Pin<&mut T>` could turn into `&pin mut T` or something. The other is to essentially throw away `Pin` and replace it with a `Move` auto trait: instead of `Pin<&mut T>` you would just have `&mut T` where `T: !Move`.

A `Move` trait would be quite disruptive, but would also have many benefits and ultimately simplify the language. For example, with `Pin`, every type has two possible kinds of mutable references to it: `Pin<&mut T>` and `&mut T`. In the case of self-referential structs, how would a non-pinned reference to one work? And how would that interact with `Drop`, which always takes `&mut self`? You could answer these questions one way or another, just like they're answered for futures (although futures have it easier because they always start in a non-self-referential state). But it all becomes simpler if you take the `Move` approach, where `&mut T` is pinned if `T` is `!Move`, and there is no second reference type to worry about.
The app was awful anyway. I installed https://www.openvehicles.com/ and it's much better, with MQTT metrics and control as well.
Wow, that's unintuitive, but cool.

Doesn't help on the moon, though, where the surface is soft, and may contain boulders.
I've been where OP is. For me it's because, for whatever reason, I don't want to commit my shitty in progress work right now to go work on this interrupt. And if I stash it, I will likely forget I did that, and waste time looking for it again.

Worktrees are a different way of managing multiple branches in flight. They're not hard to use, and using them doesn't imply any incompetency with git. They are likely being used to cope with another kind of problem.
Presidio – Data Protection and De-Identification SDK
Hackers Behind the Change Healthcare Ransomware Received a $22M Payment
> The MacBook Air used to have a multiple USB-A ports plus video, now it 2 ports that have to handle everything.

I doubt this is much of a constraint in the real world. Most people plug power in, perhaps an external mouse, and that's it. (They should be plugging in external storage for backups, which might require an extra port, but I doubt most people do in practice).

> So now the dongle/no dongle question has to become considered as well.

I'm pretty much USB-C only at this point, but even before then I never understood the fixation on "dongles".
> by Terretta 6 hours ago: Now that you can dock an iPad with an external screen and keyboard and trackpad, try that for him, tell him it's the new Macpad Pro.

ROTFL, someone made this and posted to HN four hours ago:

https://www.macstories.net/stories/macpad-how-i-created-the-...

https://news.ycombinator.com/item?id=39592288
> 4-bit quantized Mixtral Instruct running locally, gets it right

This has been one of my favorite things to play around with when it comes to real life applications. Sometimes a smaller "worse" model will vastly outperform a larger model. This seems to happen when the larger model overthinks the problem. Trying to do something simple like "extract all the names of people in this block of text" Llama 7B will have significantly fewer false positives than LLama 70B or GPT4.
My guess is they are leaning heavily on the fact that it’s “amphibious” and can count a large portion of the hull weight as a pontoon essentially.
My experience is that dead end suburb streets with no reason to drive on them are constantly used by hoons doing burnouts or modified motorbikes making loads of noise at 1AM
I'll answer for me and not try to answer for people in general. People's metabolisms are different, different food works for them.

Empirical answer: different sensation basically the minute it enters my body, from refined sugar. I don't enjoy that feeling it and I could feel it in a blind test. My body and brain do not feel good on such sugars, and avoiding them entirely is a good way to remove the craving for them.

Scientific answer: fruit sugars are slower to take up than refined sugars, when delivered in as juice or in fruit.
Fresh X-Rays Reveal a Universe as Clumpy as Cosmology Predicts
```
git clone https://github.com/irfanhakim-as/yuzu-mainline
git fetch origin 537296095ab24eddcb196b5ef98004f91de9c8c2
```

It seems that GitHub still serves the commit history through the existing forks of the repo. According to archive.org, this commit corresponds to the last release of yuzu-mainline before the repo takedown: http://web.archive.org/web/20240304185516/https://github.com...
Ente is now open source
Does the live demo page do anything? I just see a white page with the logo and "retool" floating button. On android chrome
> The opposite ("macs are overpriced") is something I've never been able to understand.

It's simple: People without much money have basic needs and want a ~$600 laptop but Apple doesn't sell one.

It doesn't matter if the $1000 Macbook has better battery life than a $1000 Dell because they don't have a $1000 budget.
Nintendo is the worst, and your entire gaming experience will be better on Yuzu or Ryujinx.

Is it a boycott if you are still playing the games?
https://www.brookings.edu/articles/unpacking-chinas-climate-...

To be taken with a huge grain of salt since it's a .cn site: https://govt.chinadaily.com.cn/s/202206/13/WS62a69ff5498ea27...

https://www.cfr.org/backgrounder/china-climate-change-polici...:
> In 2019, renewables accounted for nearly 15 percent of China’s energy mix, compared to 7 percent a decade earlier. China has used hydropower for years, and it is installing more solar panels and wind power generators as the world’s leading manufacturer of those technologies. It is also boosting its nuclear power capacity, with seventeen reactors under construction as of mid-2021.

Whereas in the US, in 10 months the climate policy could be "It's a hoax, folks. Just a big hoax. The biggest hoax ever.".
Day 5/10: in Japanese, why is fu in the ha row?
I'm not an expert or anything, but I've never seen an implementation of event handling that was anything other than STCFBOHEH. (hadn't heard the term)

My understanding of "async" as a language feature is basically support for an `await` keyword. Having a message loop and event dispatcher seems like a less useful definition, but good to know, I guess.
Not you too.
Building a chess playing agent using DSPy
Nintendo Switch emulator Yuzu is dead [pdf]
You're avoiding my question. You claimed, "a large percentage of Apple customers are buying iPhones because of those restrictions and not in spite of them", and I requested empirical evidence to support this claim. You've still not provided such evidence. You keep changing the subject to legislation or monopoly or whatever, but I simply want proof that a large percentage of iPhone customers buy iPhones specifically because iPhone prevents them from installing whatever 3rd software they want.

In my view, iPhone is a very complex device with a lot of features, consumers have many different reasons for buying them, and vendor lockdown of 3rd party apps is probably not at the top of most people's lists. I've actually never heard anyone cite that as the main reason. Here's a related question: how many iPhone owners have you heard say that they'll switch to Android if Apple allowed sideloading? How many European iPhone owners are saying it now, with the DMA changes forthcoming?
nftables is very flexible and flowtables won't work (transparently) in all configurations.

For example sending packets from a single connection over multiple links round-robin. The cache will remember only one link and route all packets over that link.

And packets in offloaded connections will bypass nftables rate/bandwidth limits and counters.
Unlike in Haskell `{}` are not optional in Gleam, so that would be written like so:

use a <- one({
use b <- two
// etc
})
You'll like the way Apple does their screens even more then. They're 3-5k screens but they essentially scale up their UI 3X so it still looks like a 1080p except 3x sharper.

They are what Apple calls "Retina" displays.
There's a volume zones of people who want "a laptop and nothing more", will pay for better materials and Apple has perfected that segment with a few caveats [0].

To your point, then comes the lower end ("just give me something cheap"), the corporate middle ("the same laptop as at work"), and the super high end (gaming, CAD, anything needing special software or a discrete GPU), with the outliers (linux etc)

IMHO windows laptop nowadays are for people who either don't really care, or have already a very specific target or limitation.

For instance Lenovo or Asus definitely care about pushing laptops' limits and design. A lot. IMHO more than Apple.

[0] resistance to abuse isn't there. A macbook's screen will be dead pretty quick if not handled with appropriate care. A Lenovo Flex for instance will take it a lot longer.
How is this an either-or situation if you could just provide an additional internationalization for 'preferred language english' + 'IP outside of US'?

'less than an inch (11.5mm)' would still be a better specification if you want to have a version where you rather err towards US customers.

I'm not offended by seeing inches, just irritated that you wouldn't cater to the rest of the world.
It seems you overlooked adding a license so that people can know under what circumstances they can use your project's code
mixtral:8x7b-instruct-v0.1-q4_K_M got this correct 5 out of 5 times. Running it locally with ollama on a RTX 3090.
Ok thank you. I see the linked project somewhere closer to shareware. I don’t expect that to be open source (my own expectation).

But seems over time we’ve moved away from shareware and maybe open source to open source shareware. I’m trying to grasp how the expectations of people have changed over time. Not looking to start a flame war.
Thank you for providing the sober explanation of what really happened here, I knew there had to be more to it, but didn’t care enough to dig in.
But it's orders of magnitude too slow and memory-inefficient for performance-sensitive graph computations—if you have even moderately sized graphs and graph algorithms are a bottleneck, you'll need to use something else, and probably something domain-specific.

This seems a little pessimistic to me. There are plenty of application domains that can be conveniently represented using graphs where you might have thousands of nodes and edges — which is what I’d characterise as “moderately sized” — and your needs might only extend to relatively simple and efficient graph algorithms. FGL is excellent in this kind of scenario.

If you do need the kind of algorithms that explode in complexity then even a representation a couple of orders of magnitude more efficient won’t help you much either. Big-O is the thing that is going to spoil your day in this story, not the constant factor. Some problems simply don’t have convenient fast solutions and ideally with those you find a way to change the representation so the original problem doesn’t arise in the first place.

It’s true that there’s also a zone where you have significantly larger graphs but still only need computationally tractable algorithms, and in that case the overheads of a library like FGL become a factor in what is viable. I also don’t disagree with you (and Hillel in the original piece) that it would be difficult to define comprehensive graph functionality to include in a standard library when there are so many different trade-offs involved.

A good — and not entirely unconnected — analogy might be calculating with matrices. It’s convenient to have support for simple but widely useful cases like 3x3 and 4x4 built into your language or standard library. However, once you’re solving systems with hundreds or thousands of rows, you probably want more specialised tools like BLAS/LAPACK, and the structure of your matrix and how you can decompose it start to matter a lot more.
Legally, I meant. Yuzu definitely isn't dead. I wonder where it will be hosted, though.
I get it! My MacBook Air M1 is honestly perfect. I'm considering a Studio upgrade only because I find myself working on ridiculously large (24K x 30K) 16 bits-per-channel image files lately.
You can run modern macOS on the thinkpad x1 tablet gen3. Might be more practical than what OP has.
There's no theory.

Just in real life usage, it is extremely uncommon to stochastically query the model and use the most common answer. Using it with temperature 0 is the "best" answer as it uses the most likely tokens in each completion.
Not hard at all, development will definitely be continued to some degree but likely not by the original developers, since most of them didn't do a great job of obscuring their identities and won't want to take the risk.
I clearly understood this while playing Lunar Flight
https://store.steampowered.com/app/208600/Lunar_Flight/
Well, there's different ways to make things up. We decided against using a pure generative model to avoid making up phoneme or words. Instead, we predict the expected acoustic features (using a regression loss), which means that model is able to continue a vowel. If unsure it'll just pick the "middle point", which won't be something recognizable as a new word. That's in line with how traditional PLCs work. It just sounds better. The only generative part is the vocoder that reconstructs the waveform, but it's constrained to match the predicted spectrum so it can't hallucinate either.
Very sad outcome, but not that surprising given Nintendo's track record of suing fan projects into oblivion.

The same had happened with the Skyline emulator some time back.
I don't care about any of this, I think how the system works is bad. It produces outcomes that are bad (in this case, absurd inequality), and I don't think that was inevitable. Moreover I don't think we (as a species, at least) are doomed and could learn something better, somehow.
This blog post could have been written by me. This is exactly how I feel, on all accounts.

Hope this doesn't mean we are in a cult ;)
Yes I think that'd be ok. You'd basically just be taking advantage of the thermal gradient between the radiating body and the object being heated. It'd be analogous to adding more insulation as it heats up and removing insulation as it cools down.

You'd be slowing the flow of heat into your reservoir just as much as you'd be slowing down the loss of that heat later though.

You might still get some benefit in preventing freezing at the expense of needed a larger area to get the same amount of heat flow in to your water system though.
Obviously. And my opinion is lawns are expensive designer patches of dirt. Like a Rolls Royce or a Bentley. Really nice, and there's a whole industry surrounding them, and a whole lot of culture surrounding having one but ultimately problematic for society if everyone has to have one of their own. Which comes to the part where there are facts. A house with a lawn takes up more space than the exact same home without a lawn. Adding the lawn increases the footprint of a house which increases size and drops population density, which makes services more expensive because things are simply further apart. No one has to agree with my opinion that lawns are a luxury good, but it is very expensive for everyone to think they want one.
An interesting trip down memory lane for those of us who learned to fly later. But he went and ended it with a bunch of "old man yells at cloud" nonsense. Yes, airmanship needs to be cultivated in an era of glass cockpits, but that doesn't mean the glass isn't head-and-shoulders above the steam gauges. The only reason the steam gauges existed were because they were the best we could do at the time. Hopefully the next step is incorporating augmented reality.
I've tested with the Mixtral on LMSYS direct chat, gen params may vary a bit of course. In my experience running it locally it's been a lot more finicky to get it to work consistently compared to non-MoE models so I don't really keep it around anymore.

3.5-turbo's coding abilities are not that great, specialist 7B models like codeninja and deepseek coder match and sometimes outperform it.
Which .NET Foundation was supposed to solve, yet we observe more and more FOSS projects not happy with it, and moving away from it.

Avalonia being the most recent example.
For the keyboard + trackpad maybe, although you would be likely damaging the screen in the long run. I also have a lenovo yoga and it spends very little time flipped. It is just too heavy to be used as a tablet regardless of the UI (gnome3 works quite well for that.
Being able to explore code from another revision in your regular editor side by side with your other branch (two editor instances) is a big plus of worktrees. Maybe it wouldn't work if you use some heavyweight editor like Visual Studio or Eclipse or if your project is massive and IDE intelligence features take up a lot of RAM, but for lightweight editors, small-medium projects it works great.

I personally use it all the time on longer lived projects. Stashing/unstashing is fine, but I like really like the flexibility of just being able to switch over to another branch to fix something, review a PR, or anything else with zero mental overhead of keeping track of stashed work.
"Because they don't teach Lunar Lander in schools anymore."
What do you mean by mainline consumer machine? MacBook market share is less than 20%
Well, stashing is ok for short term context switch, but it's not that organized or neat.

You're supposed to be working in a feature branch when your were given the bug to fix. Would you not have commited (or, worse, pushed) anything to it already? Most times you already have, so it's not like stashing your latest changes and getting to the latest state of the feature branch is neutral.

Plus, what big benefit would stashing have, since you'll still need to create a separate bugfix branch to create the bugfix PR off anyway? If you get to context switch while you were working on my-feature-branch, you still need to create my-bugfix-branch and push the fix from that, no?

Besides nobody guarantees you ahead of time that the bug will just be solved fast and they get to return to working on the feature pronto. So a bugfix branch makes more sense than a stash, which is more of a short term thing.

Just making a bugfix branch is neater.
How about we just don't compare lines of code at all, as if it's a useful metric of anything?
But will probably outlive your MBP keyboard.
GPL v2.0 is pretty vague on that:

If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works.

I use the pipe/exec loophole to include a GPL program in a proprietary one. I personally decided that the proprietary code can be considered an independent and separate work because it's still does something useful without the GPL component. Also, you could swap the GPL component for a 3rd party proprietary one, which actually exists and uses the same interface for communicating via files. So to me, it's just a generic interface and I'm distributing the GPL program together as "aggregation" of separate works. For the sake of human relations, I also got approval from the GPL program's author to do this but he admitted he wasn't sure, and neither am I.