skysight-inc/HackerNews huggingface dataset:
From Apple Platform Security Guide [0] :

> The individual messages are encrypted much like messages in iMessage are. After the devices are paired, each device generates a symmetric 256-bit AES key that gets stored in the device’s keychain. This key can encrypt and authenticate the BLE advertisements that communicate the device’s current activity to other iCloud-paired devices using AES256 in GCM mode, with replay protection measures.

[1]: https://support.apple.com/en-gb/guide/security/secf78dbe639/...
Detached - I would have used that word - there is an Elon Reality Distortion Field just not in a good way.
How do you interpret their Additional Use Grant?

https://github.com/hashicorp/terraform/blob/main/LICENSE#L8-...
Am I correct that this only shows GUI apps that can be installed via Homebrew? I'm sure I have some command line utilities installed that aren't showing up in Applite.
> ... as it n becomes more and more obvious that the benefits of that software flow to giant integrated cloud platform providers rather than to the people who make the software.

The whole point of open source is that everybody has the opportunity to contribute to the benefit of everybody. You don't get to say "oh, but nazis / Amazon / rapists don't get to use this because I disagree with their morals".

The incentive to contribute comes from being part of a community that gets to experience better quality software. For many (me included), that's plenty. I really don't care what Amazon does - I'm neither a customer, nor an investor.
I don't know the details of BSL, but can HashiCorp now require compensation/$$$ from Spacelift, Scalr, Env0, etc? In that case, these products can be forced to offer similar pricing as Terraform Cloud.
> where you're implicitly depending on system include paths for versioning

The correct thing to do, imho, is check-in toolchains to version control.
> ... complete rewrite ... with Windows ...

Whaaa...?

Remind me the timeframe, this would have been very early 2000s, right?

Does anyone care to speculate on valid technical or business reasons for doing this? Could they perhaps have been battling flaky tcp/ip implementations or something?
You're not alone, I do that too sometimes! But I've also found that most people have a hard time doing or following along with something like that. Possibly because in the end it does require a whole lot of skill in using git, because you will usually want to rewrite history in some ways, and large numbers of developers are very uncomfortable with that.
Those arguments always remind me of this comic: https://www.cjr.org/wp-content/themes/cjr2017/images-body/NY...
How is it an act? Caring about the climate is clearly morally superior than not doing so.
most likely milanvarady used the defaults from xcode to build and distribute
From the user's point of view, yes, that is intended behavior. But the browser can't know that, all it sees is a dropped connection. For all it knows, there could be an actual issue with the network.

But unless you open the dev tools' network tab, you don't know about that request failing.
Why is that? Are these issues common?
I guess that largely depends on hiring practices. If you are hiring people who prioritize “incorrectly” then you’ll have people doing the wrong thing. I usually see this filtered out by having a list of issues in the “code test” and then seeing which ones they do first and asking why.
> “unfortunately”

There only exists few companies with the financial might and margins relative to Opex like Apple and Google, and even rare a company that is controlled by a major shareholder (Meditations on Moloch comes to mind).
I don’t see why or how Apple or Google would change their approach to business given the difficulty of doing so coordination wise and the opportunity cost of doing so. I can only see a company doing so if they had an assertive leader at the helm who is ready to pick up the low-hanging fruits of whatever upcoming technology is gonna make the shareholders the most money.
kiwi =/= chrome
One can also look into Buddhism and meditation.. a lot of stuff about what is really causing loneliness and depression
I am actually quite intrigued with NYTimes's Games play. I tend to play mostly their games whenever I'm on mobile. And surprisingly, their India games subscription pricing is also not very prohibitive.

I'd say they are executing well.
This would seem more useful on something like one of the calculator watches or I know I once had a watch with a TV remote built in, not sure offhand if that one was Casio, but that'd seem like something more useful to have in a watch.
Cool! Does that use the Gamepad API or WebHID? I'd like to get one working in the browser for one of my projects
> Don't their customers get value from having source code available, even if there are restrictions on how that source code can be used?

For the most part, no, the main direct customer benefit comes from the absence of lock-in with regard to maintenance and services thar results from the absence of usage restrictions.

There's some potential indirect ecosystem benefit for customers from the somewhat lower friction for partners in some source-available-but-use-restricted situations, but otherwise for most customers its the same as any other proprietary license.
My app doesn't offer comment editing, but I asked as a kneejerk before searching (doh).

It was for the toolchain: https://news.ycombinator.com/item?id=12519729
To add to what others have pointed out, if you have a good following on any social platform and can push your product there, putting it behind something like Gumroad is also an option.
Disney is on the profit-price spiral greed bandwagon still thinking they own Osceola County and people are stupid and will pay anything. Newsflash: Most people are losing real wealth and nominal income as America increasingly becomes a perversely unequal country.
- They lost focus with just about every other project other than Firefox & Thunderbird which were the actual products I donated money for

- They are (recently) very top heavy for a non-profit foundation and are spending non-negligible amounts of money on C-level and execs

- Ideologically I disagree with them taking money with strings attached from Alphabet

- (Personally) their recent trends of UX with 'dummyfication' and mimicking chrome is a terrible loss
Just as an added data point, some languages (e.g. Hungarian) do use double negative “natively”, and I have definitely caught myself having to fight some native expression seeping into my English, including ‘irregardless’. For example a Hungarian would say “I have never done nothing bad” over “anything bad”, but it is used not in a logical sense, but more as an emphasis, perhaps?

(!)Regardless, what I’m trying to say is that due to the unique position of English as the de facto world language, it has to “suffer” some non-idiomatic uses seeping in from non-natives. Actually, I would go even further and say that most smaller languages will slowly stop evolving and only English will have that property going forward (most new inventions no longer gets a native name in most languages, the English one is used).
I can't imagine dropping Android for any other device, but ESP32 Linux looks like it has real potential.

I'd love to see it integrated with Arduino, so we could finally have easy to make, loadable, sharable apps on small devices.
Unfortunately this practice has been happening with a lot of websites, and many companies are not complaining with the cookie law

https://www.cnil.fr/en/refusing-cookies-should-be-easy-accep...
The rule is simple: If you want to relicense a project, then you need approval from all the individual copyright holders. It does not matter if you are relicensing between permissive OSS licenses such as, for example, from Apache 2.0 to MIT. They are different licenses, so you need permission for the change.

That's why OSS is commonly called a "Community". The software's copyright belongs to the hands of all the community of developers who have written and contributed code.

What a CLA usually does is grant perpetual permission to do anything with the code, including to relicense without asking. Practically speaking, CLAs grant full control to a single hand. Thus, OSS projects with such CLAs are not part of any so-called "Open Source Community" in any meaningful way.

EDIT: Changed "CLAs grant full ownership" -> "CLAs grant full control", to avoid misunderstandings.
What is even worse about these doctors, is that sometimes they may be doctors, but not medical doctors.
I watched a video on YT once and the doctor's explanation for why his advice would work seemed a bit weird to me. Checking his credentials it turns out he's not a medical doctor and known for alternate science and questionable view points.
All the YT comments were really positive of course, giving any reader zero value or a chance for a different view.
Taking that away was just the last straw. Trust has been broken, and I don't like being bullshitted and abused, and then brow beaten and guilt tripped for not liking it. I use tools that respect me and do what I need them to do, I refuse to be herded into a set of acceptable behaviors and thoughts like a cow, and by a corporation no less. The people making decisions at Mozilla should be ashamed of themselves.
The "using electricity is bad" meme must be one of the stupidest ones in the last few years
It really depends on what you are shipping:

1. does what you are shipping have lots of international regulations and compliance requirements per country it will be available in with new countries being rolled out on a planned basis -> your manager will determine what you should work on

2. Are there things being released on a set date due to some sort of legal requirement, business deal? -> your manager will determine what you should work on

3. Is it basically the same product in all markets / countries other than internationalized text with not pending contracts or business deals requiring specific functionalities impacting the company? You should be able to determine what you should be working on.
Simply put, there's no coming back from a successful suicide, and generally people who attempt suicide are not in a normal/healthy state of mind.

There are many liberal societies that allow euthanasia though - even for mental health conditions - it's just there tends to be a process of checks and balances to go through to ensure the patient's decision is made of sound mind and without coercion.
Artificial General Intelligence – A gentle introduction
You didn't respond to this

> Let's assume that in 10 years, LLMs are at the point where you cannot distinguish between a well written book by an author and one generated by entirely by an AI. Suppose we have two authors, one that is long dead and whos works are public domain and a young one that is just starting. An LLM trained on the author whos work is in the public domain can generate books that is just like the original works. But what if the young author writes in a similar way, is that now legal or illegal to generate the same content? It's impossible to know if the young authors work have been used for training.

which is central to my reasoning. You could go the same way as software patents, but that is not preferable in any way.

---

>> I am certain that trying to ban LLMs, or dictating what and how is not the answer.

> I wouldn't ban LLMs because of copyright issues, though I would let authors choose whether their IP can be used for training or not.

> Why not? Just say that using for training is considered derivative work, and that's it. Now copyright owners just have to update their license to allow for training if they want to, and that's solved. Of course, Big Tech makes less money from that scenario.

Big Tech can train on everything that is "legal" and malicious actors can finetune with a specific authors works and then generate books. You will not be able to detect that and the malicious actor can claim to have written it themself. Then we're back to the starting point.
R12 contains the address of your score. In this case, that is address 0 - the start of the data segment.

The score register is yellow, and the corresponding memory region it points to (the actual bytes of your score) are also yellow.
Not so: open source licenses tend not to have any clauses requiring reciprocation, free software licenses do. Think MIT or BSD vs GPL.
I wonder what became of that. Of course, fast forward to now and they could migrate to ZX Nexts. :-)
Yes, you're right. That's what I meant, but I should've highlighted the incompatibility aspect.
Dark Reader and Relay are both on Android. I'm not sold on LocalCDN being necessary or even helpful these days (but there was a time when it was. A bit like antiviruses other than Windows defender these days, or those registry cleaner tools).

The others are missing for sure, though.
When did we stop building software for the "Power User" persona? I don't disagree that there are some (many?) people who start screaming and running in circles when they see an error code, but not every user is like that. You don't have to be a dev to care any the distinction between a system doing its job and silently failing. Why not have some indication that there's smoke coming out from the engine?
I wasn't going to post that... but I certainly was thinking of it! (Sadly, that particular video misses Davos later correcting Jon in turn.)

Weird Al, too: https://www.youtube.com/watch?v=RGWiTvYZR_w
TXR Lisp:

(defun y (f)
[(op @1 @1)
(op f (op [@@1 @@1]))])

It looks like the Haskell one is calling itself by name: (y f) appears in the right hand side. That's against the spirit of the exercise. The Y combinator is a way of boostrapping the ability to have functions be able to call themselves in a language which doesn't have named functions as a primitive.

See here: https://mvanier.livejournal.com/2897.html starting at "Deriving the Y combinator" where it presents a lazy version of Y in Scheme, similar to the Haskell one and argues that it's not valid.

Regarding the Scheme version, there is a shorter form:

(define (Y f)
((lambda (x) (x x))
(lambda (x) (f (lambda (y) ((x x) y))))))

This is analogous to the TXR Lisp one above which rewrites the lambda terms using op syntax.

Except, the TXR Lisp one doesn't assume that the function takes one argument: the (op [@@1 @@1]) syntax describes a function that takes any number of arguments, and passes them to the funtion produced by [@@1 @@1], so it's like this version:

(define (Y f)
((lambda (x) (x x))
(lambda (x) (f (lambda y (apply (x x) y))))))

Note that (lambda (y) ...) is now (lambda y ...). This denotes the capture of zero or more arguments into the list y, which can then be applied.

You can see the equivalence:

3> (expand '(op [@@1 @@1]))
(lambda (. #:arg-rest-0023)
[sys:apply [@@1 @@1]
#:arg-rest-0023])

In this dialect (lambda arg ...) can be written (lambda (. arg) ...) for clarity. When the printer sees (lambda atom ...) it prints it as (lambda (. atom) ...) and we see that above. Just like (lambda (a . rest) ...) means there is one required parameter a followed by zero or more others that are shored up into a list called rest, (lambda (. rest) ...) just means zero required arguments followed by zero or more trailing arguments that become the list called rest. It's a special syntax probably found in TXR Lisp only: (. y) means y, anywhere it appears.

The double @@ in @@1 means "do not refer to @1, the implicit parameter 1 of this op function: refer to parameter @1 of the next enclosing op function":

(op f (op [@@1 @@1])
^ --- ---
`-------'---'

The (op f ...) writes a function, and @@1 inside the nested op refers to that function's first argument. Whenever you mention positional arguments in op, it no longer passes the variadic arguments implicitly. The generated function is still variadic, but throws away the trailing arguments. If you want them, you have to mention @rest:

These defaults all work together to make a short Y combinator which lets the recursive function have multiple arguments.

1> (expand '(op f @1))
(lambda (#:arg-1-0016 . #:arg-rest-0015)
[f #:arg-1-0016])
2> (expand '(op f @1 @2 @3))
(lambda (#:arg-1-0019
#:arg-2-0020
#:arg-3-0021 . #:arg-rest-0018)
[f #:arg-1-0019
#:arg-2-0020
#:arg-3-0021])
3> (expand '(op f @1 @2 @3 @rest))
(lambda (#:arg-1-0024
#:arg-2-0025
#:arg-3-0026 . #:arg-rest-0023)
[f #:arg-1-0024
#:arg-2-0025
#:arg-3-0026
#:arg-rest-0023])
> I see this weird back-lash in modern development against having common, standard platforms. I suspect it comes from the Python and JavaScript world, where having "no batteries included" is seen as a good thing, instead of a guaranteed mess of dozens of half-complete incompatible frameworks.

Kind of odd to have Python included there as Python's motto for years was (is?) literally "Batteries Included".

https://en.wikipedia.org/wiki/Batteries_Included
Pretty much everyone underestimates the complexity of workflow scheduling.

This means like 99% of tools have had various random limitations and quirks that make them not applicable to a lot of use cases.

This is something that people using these tools mostly never realize (and so complain about the "reinvention").

The folks I know who tried to implement a pipeline tool are often a bit more aware of the challenges and how hard it is to make something that is really general.

I say this as someone who evaluated a dozen tools, and finally extended an existing tool to fix some limitations (Luigi, with our SciLuigi extension), and finally developing our own tool (SciPipe).

It has gotten better, and a tool like Nextflow is pretty generic these days, although they also might have limitations. For example, before DSL2 we needed re-usable modules, which is why we developed SciPipe, which otherwise has a very similar scheduling mechanism to Nextflow (Dataflow/Flow-based).

Still today, I'm having mixed feelings about using extremely complex tools that are dependent on a single organisation to keep updating. Not being able to easily debug execution and a few other things, which is why we wanted a simple library that we could understand ourselves and run through a debugger. (And it didn't hurt that we could get complete audit logs per output file, which can be very useful both for provenance and debugging, and is not found in almost any other tool.)

Just to give some examples of why someone might still entertain thoughts about developing separate tools.

All in all, the widely used ones like Nextflow (and Snakemake) are great tools. They just aren't optimal for every usecase and situation.
For best performance on x86 CPU and Nvidia GPU, ts_server is interesting ( https://bellard.org/ts_server ).
Wow, that's really cool. If these commits were marked one could quickly drop them during rebate at the end of the review before merging. Or just remove them when the fix is applied.

Thanks for sharing!
Uses the Gamepad API. I found it very easy to work with, in large part thanks to the corresponding MDN docs.

The only weird part about the Gamepad API is that you have to poll it rather than handling events the way you normally would for other, similar stuff in JavaScript. In practice, this means that you have to do your own debouncing for handling things like key combos, but that doesn't really affect individual button presses too much.
Then don't complain about people not contributing to your projects. You reserve the right to reject my PR, and I reserve the right not to contribute any more.
How do you know the man’s power is not cleanly generated?
If I'm reading this correctly, a Linux kernel parameter `gather_data_sampling=off` will be implemented to disable the mitigation: https://www.intel.com/content/www/us/en/developer/articles/t...
Yes, me too. I'm no longer in that geographic area (or area of the industry, for that matter), so I don't know.

However, I am anxiously awaiting my Spectrum Next...it seems to be inching towards a delivery date.
Opening the dev tools and looking at the network tab is easy enough for power users.
Coding on iPad using VSCode, Caddy, and code-server
Integration of Manticore with Logstash/Filebeat
Why? IMO we should all avoid waste, whether that's plastic or energy.
I very recently had to push back on a bug that wasn’t a bug in my part of the stack. If they wanted it “fixed” in my part, it would be a feature. (Enum values from an API being localized — these were hardcoded on the backend). IMHO, these should be localized in the client, which has the current locale (I do not have the current locale and no strings are translated from this API by this API).

That was pretty fun, but I don’t think generalizing “denying a bug” as saying we are being “lazy” is a correct assumption.
Thanks for explaining. I can't help but ask why you believe these things have happened? What went wrong and what is the alternative to Firefox?

I am approximately as cynical as they come, and I'm not sure how Firefox could even exist if Google weren't keeping Mozilla alive (on life support), so I am intrigued by your criticism. I'd like to understand your viewpoint and what ideology is behind it, if any. In your view, what should be done?
I’ve recently listened to a talk from Jane Street about their review system: they use this method exactly with a helper tool that keeps track of what you’ve already reviewed in the PR, minus any changes that were committed after review. PR author also “reviews” the branch, so the code review comments and changes would show up on self-re-review (because they were not reviewed).

https://youtu.be/MUqvXHEjmus
Transcript: https://www.janestreet.com/tech-talks/janestreet-code-review...
I quite enjoyed this article, but I reckon they're talking about ADHD rather than "bipolar" mind. Seen under that lens, I resonate with his caricature.

Focus is a precious, rare resource outside my control. Mainstream languages, made for collaboration in big teams rather than maximum personal freedom, soon impose restrictions that kill hyperfocus. The "unused variable is an error" is the most egregious of them that I hate with a passion. The separation between compilation and running is another that seemingly inescapable today. With languages like Lisp, I can code at the speed of thought from prototype to production.

These days tech is advanced by FAANGs, so no one cares about removing the safeties from our languages; this is the reason the focus-challenged among us still go back to Lisp and other lost languages (Forth, Smalltalk, Self) that have disappeared from the mainstream.

Rust, C++, Go, Python, etc. are good, but they're not made for us.
I also used to do this in a couple of small startups. I loved having the review history just stored in git, and how commits that fix a problem also delete the comment about it, so when reviewing fixes I make sure every newly deleted comment is taken care of, then git grep "CR:" and if it comes back empty we're good to go.

However, I got a feeling it wouldn't scale well to large teams. Specifically because you have to manually keep very strict about not mixing reviewed and unreviewed code, and if you do it's hard to disentangle them and decide what's in scope for a review.
I just checked and this book is 100$ AU. Why so expensive?
I've heard this often.

Why don't they scale?
I used them for some years for a team of ten or so people who all first had to learn to understand how they worked so might that be the problem?
Why are people so hostile towards BSL? Paying/asking money for great products is fine and if the product's source code is in git, the better.

Not everything has to be _free_. The major benefit of OSS for many is that you can read the source code. The major benefit of paid SaaS is that things just work and you pay for that. BSL can be the perfect combination of these.
Oh, you can surely install a minimal development environment system-wide.

Once.

Containers just enable you to do it more than once. And they leave you a plaintext napkin with the list of stuff you installed.