skysight-inc/HackerNews huggingface dataset:
Again, my point is simply that if there were some more serious offenses as the person I responded to alluded they could easily respond to reporters saying this isn’t a simple administrative mistake.
I tought expect is a test framework
On iPhone, WiFi QR codes work just fine. You just open the camera app, and point the phone at the QR code. They're automatically detected and scanned, the same as any other normal QR code. (No, you can't open the camera app during initial setup... but, it's not for a lack of the standard or the feature.)
Interesting. I didn't know about that module. But just like I asserted earlier... I don't need to write in Erlang to use that module:

$ iex
Erlang/OTP 27 [erts-15.2] [source] [64-bit] [smp:20:20] [ds:20:20:10] [async-threads:1] [jit:ns]
Interactive Elixir (1.18.1) - press Ctrl+C to exit (type h() ENTER for help)
iex(1)> my_array = :array.new()
{:array, 0, 10, :undefined, 10}
iex(2)> my_array = :array.set(0, "test 1", my_array)
{:array, 1, 10, :undefined,
{"test 1", :undefined, :undefined, :undefined, :undefined, :undefined,
:undefined, :undefined, :undefined, :undefined}}
iex(3)> my_array = :array.set(1, "test 2", my_array)
{:array, 2, 10, :undefined,
{"test 1", "test 2", :undefined, :undefined, :undefined, :undefined,
:undefined, :undefined, :undefined, :undefined}}
iex(4)> my_array = :array.set(2, {:a_test, :test_tuple}, my_array)
{:array, 3, 10, :undefined,
{"test 1", "test 2", {:a_test, :test_tuple}, :undefined, :undefined,
:undefined, :undefined, :undefined, :undefined, :undefined}}
iex(5)> my_array = :array.set(3, %{test_field: "test map"}, my_array)
{:array, 4, 10, :undefined,
{"test 1", "test 2", {:a_test, :test_tuple}, %{test_field: "test map"},
:undefined, :undefined, :undefined, :undefined, :undefined, :undefined}}
iex(6)>

That is using the Erlang array module directly from the Elixir REPL, including such fancy features as rebinding on the single variable name `my_array`.

The Erlang docs say this about the underlying data type:
"A functional, extendible array. The representation is not documented and is subject to change without notice. Notice that arrays cannot be directly compared for equality."

Based on my REPL test, at least when the element count is small, it looks like they're using tuples; specifically a tuple nested inside another tuple where the outer tuple is defining the array metadata.

I think the reason I've not used the Erlang module is that the Elixir Enum module (https://hexdocs.pm/elixir/Enum.html) is sufficient for the cases where I'd want some sort of indexed data structure. Typically though if I'm indexed I'm really after some sort of associative array and maps are sufficient for that case.
Has it? Or do we instead have vast overfilled palaces of the sum of human knowledge, often stored in pointers and our limited working memory readily available for things recently accessed?

I'd argue that our ability to recall individual moments has gone down, but the sum of what we functionally know has gone up massively.
XKCD telescope sizes also could provide some guidance

https://xkcd.com/1294/
Oh my goodness, thank you! I've been looking for that for AGES!
The law is blatantly absent if the executive explicitly states it can detain and deport any person it deems a threat without due process and without duty to notify anyone, let alone a court or judge.

It's literally the executive tyranny of a king and absence of balance of power in full action which led to the founding of the United States of America.

Even if you're a criminal, last I checked the law, properly enforced, grants you the right to an attorney to prevent exactly this: unchecked executive power.
So, it is basically like it was written in C.
There was a few lines on this, but I wish it clearer that everything it said is also true classically about particles for which we are uncertain.

IMO so much writing about quantum mechanics gets harder to follow by trying to jump classic -> quantum, and certain -> probabilistic at the same time. If one does the latter switch first, it cuts out the noise of easier-to-understand things to get to the second.
Any advice for folks going through the same thing from someone who has lived it?
> truly revolutionary interfaces tend to require equally revolutionary hardware to match

The prime examples given were about mixing and matching capabilities that most hardware already has. Most computers and tablets already have a microphone and some kind of tactile input (touch or keyboard).

So, I wouldn’t say that you’re wrong in tying UI innovations to hardware, but it feels like perhaps you didn’t read the whole article. We can innovate by remixing existing functionality without having to wait on entirely new paradigms being adopted and universally available.
I'm starting to buy it.

> You can safely backup SQLite databases while they're being written to

Is this true with WAL enabled?
If I’m not mistaken iOS can scan the text directly from the text field though (not a very well known feature).
I've had a stock A600 for over a decade, it was okay. Sure I had to run a ReloKick for some games but the OS was vastly superior to the awful blue-orange flat shading ugly 1.3 topaz font hell of A500. Sure A500+ existed but over here (central europe) it was very rare and it was missing the IDE port anyway.
Ironically for me the greatest issue was lack of the numpad, which caused issues with some software, and forced a very lasting aversion to numpad usage on me.

From today's perspective, A600 is... annoying, which I've found out a few years ago. The architecture choices are hard to work with: the PCMCIA slot limits the amount of memory you can work with (well, unless you don't want to use it but it's almost indispensable, esp. for data transfer), the internal bus only accepts "slow" RAM - the desired Fast RAM (CPU exclusive) can only be added by expansions put directly over the CPU itself. Sure, there are Vampires and PiStorms but the compatibility of both can be a bit spotty, and if you're dumping that much on the system you must love it specifically, lest you'd just go with an A1200 which is superior in every respect.

On that note, currently the easiest no-brainer Amiga to actually have fun with without eating your budget too much is an A1200. Slap an 8MB fast ram expansion, an IDE CF controller, and 3.2.2 OS/ROM it's ready to go. WHDLoad installs exist for every important game and many obscure ones too, data transfer can go either via PCMCIA>CF card, or a Parallel Port contraption that reads microSD cards. And if you want more power (though I can't imagine why, unless you want to run Doom on it), TerribleFire cards aren't too pricey. 128MB RAM + 030/060 CPU is a substantial boost (note: games, especially early 3D, will break with that much power).

Just watch for leaky capacitors (thankfully there's a whole industry for fixing this), and for the love of god don't use the stock A1200 PSU, it'll kill your system (thanks Commodore).
Books made orators dumb. I'm not sure this argument has ever had any credence, not now and not when Socrates came up with his version for his time.

Any technology that renders a mental skill obsolete will undergo this treatment. We should be smart enough to recognize the rhetoric it is rather than pretend it's a valid argument for Luddism.
See also https://html5boilerplate.com/
Yeah I'm having a hard time telling as well, but I think it is AI. Following threads has a surprising amount of consistency and coherency that we don't commonly see in AI art. I would expect AI art to be VERY bad at felt imagery. The image here[0] looks too consistent though there are definitely parts that are edited. And here[1] the blurring is very consistent (other than the stitching you cans see when scrolling). Although this one[2] really makes it look like the text on the computer screen is AI generated. A lot looks good but the coat on the main character flattens out. But here is a really good one where you can see the AI errors pop up if you look at the bow[3] (the blurring is also inconsistent here)

There are definitely issues that pop up but I find it weird people are calling this "slop". "Slop" is that bullshit people are posting where they take the first output and don't pay attention to details. Clearly this person played around with the parameters a lot. The problem with AI Art is taking the art out of the art (and the data theft). But if you're using AI, iterating, focusing on details, then I'm not sure how it is different than any other medium where you do the same things. Art takes time and makes you feel. Considering how it added to the message here and how clear it is that this person put time into the details, I find it hard to call it "slop" just because AI was used.

[0] https://wattenberger.com/thoughts/our-interfaces-have-lost-t...

[1] https://wattenberger.com/thoughts/our-interfaces-have-lost-t...

[2] https://wattenberger.com/thoughts/our-interfaces-have-lost-t...

[3] https://wattenberger.com/thoughts/our-interfaces-have-lost-t...
GitHub Action tj-actions/changed-files supply chain attack
There's a difference in quality, though. IntelliSense was never meant to be more than autocomplete or suggestions (function names, variables names, etc.), i.e. the typing out and memorizing API calls and function signatures part. LLMs in the context of programming are tools that aim to replace the thinking part. Big difference.

I don't need to remember all functions and their signatures for APIs I rarely use - it's fine if a tool like IntelliSense (or an ol' LSP really) acts like a handy cheat sheet for these. Having a machine auto-implement entire programs or significant parts of them, is on another level entirely.
Also true. Tap on any text field. In the menu where the "paste" option lives, there is also a Scan Text option. I've used that for a number of things over the years.
While there are examples of wealthy people getting into drugs or something that destroys them, you don't need money to destroy yourself with drugs there are plenty of dirt poor Appalachians doing that every day. I don't see any evidence of a causal relationship, and this is one of the well known narratives to get poor people to accept being poor.

"Rich people are rich because they are so frugal and save every penny"

"Being rich doesn't make you happy! Rich people are miserable!"

"Rich people work 120 hour weeks and way harder than most people, are you sure you even want to work that hard and sacrifice your family and happy simple life??"

"Being rich is less important than being honorable, moral, and religious, in fact being rich makes it harder to be those things so you are better than them actually!"

If any of this true people who get rich wouldn't fight so hard to keep it. The reality is that human society is just incredibly cruel and unfair.
And every time the commentariat dismisses it with the trope that it’s the same as the other times.

It’s not the same as the other times. The naysayers might be the same elitists as the last time. But that’s irrelevant because the moment is different.

It’s not even an abstraction. An abstraction of what? It’s English/Farsi/etc. text input which gets translated into something that no one can vouch for. What does that abstract?

You say that they can learn about the lower layers. But what’s the skill transfer from the prompt engineering to the programming?

People who program in memory-managed languages are programming. There’s no paradigm shift when they start doing manual memory management. It’s more things to manage. That’s it.

People who write spreadsheet logic are programming.

But what are prompt engineers doing? ... I guess they are hoping for the best. Optimism is what they have in common with programming.
I was reflecting on something similar to this this while photographing the recent lunar eclipse with a Fujifilm X-T5, a highly tactile camera that is just an absolute joy to operate.

I was on my roof in the dark at 1:30 in the morning in the cold and wind. I'm tired, can't really see much, but still need to actively work with the camera's controls. Thankfully, the X-T5 is covered in physical dials, switches and buttons. Without looking at the camera's screen, I can quickly change shooting modes and the majority of the settings I care about and be confident that I changed the right things.

The same cannot be said about a large number of modern cameras, which opt instead for a more digital approach.

In terms of modern "computing" devices, my cameras are an absolute joy to use compared to most of my other hardware.

So much so that I've recently been finding myself looking to recreate this tactile experience on my general purpose computers. I've been looking at weird bespoke dials, switches and various input hardware to make processing the photos (among other tasks) feel more tactile.
I think we should ban third-party advertising altogether. Or rather, ban any kind of remuneration in exchange.
A lot of server code and specialized software won’t work.

Competition is always good
Have you tried TriliumNext? It doesn't have collaboration for editing but sharing is built in,

It lets you structure your notes in a way that's reminiscent of object oriented programming (you've got templates to define types, inheritance of attributes to instantiate and specialize them, etc). I have hierarchies of hundreds/thousands of notes that for all intent and purposes are as good as Notion's Databases
And yet, it's the best we currently have. I donate to them. We can come with demands of how it should be managed, but it should not prevent us from helping them.
Yeah … but

That has some amount to do with the level abstraction but almost everything to do with inexperience. The lower level you get, the harder the impact of inexperience.

New web developers are still sorting themselves out and they are at a stage where they’ll suck no matter what the level of abstraction.
Very lucky for WPS to ever work for you. I stopped even trying a long time ago.
I got my nice Herman Miller chair that I'm sitting on now, which was wheeled out into the parking lot by the facilities guy saying "take it all..."
Intel is run by fools. I don't see them coming back. They just don't have the willingness to compete and offer products with USPs. Intel today is just MBAs and the cheapest outsourced labor the MBAs can find.
When you think that your primary relationship with a machine is "telling it what you want" you've already taken the first step to an inevitable hell.
This. I was surprised to see the outrage over USAID, which up until now I had considered an arm of the CIA. Of course you are downvoted, because right now the progressive thing is to support these institutions and not question them. But this attitude used to be the domain of the left and so was seen differently. Now that the right is saying it, we have to downvote you.

Edit:

Some pre-2025 links:

https://foreignpolicy.com/2014/04/03/cuban-twitter-and-other...

https://search.library.wisc.edu/digital/AA2RFE4CPSKBZ78P

https://mronline.org/2008/09/23/usaid-key-weapon-in-dirty-wa... (from a socialist magazine, so take w/ a grain of salt)

https://www.motherjones.com/politics/2004/11/coup-connection...

Please do not be blinded by your well deserved distaste for trump. People calling for the ending of USAID are not all MAGA.
There is a niceness to more kinesthetic input devices, to dials, knobs, and pens. I'm always experimenting with trying more. The unfortunate thing is they tend to be niche and unsupported. Try finding a nice dial to control things like zoom or volume, it's harder than it should be and costs over $100 or is not a great experience.
cm8bw71d7000opl0kvjzjif9j, around three hours ago (17:30 UTC).

I see about the follow up comms, makes sense. Would still prefer if leaving the email was optional for the request leaver. I realise this complicates things :)
Until their innocent kid with tattoos gets kidnapped to El Salvador or Guantanamo.
Its my understanding WebView uses GTK. for ios/kde I don't use WebView
Gen Z startup lives together, plays together, and hustles together
This has me wondering about converting law into source code, running it through something like Coq or Agda and finding logical contradictions that need resolution.

Not sure that would be feasible (e.g. if those languages would even be capable of doing such a thing), or how much computing power you'd need to churn through however many thousands of pages of something like the US Code and process that all.
The article reads like a description of personal computing in the late 90s to early 2000s. It also reads very similarly to Apple’s early marketing around multitouch displays.
Makes sense. As often happens, it is the most vulnerable ones who are being taken advantage of.
This sounds embittered. But if it isn't that, what problem with rust do you see?
Have you ever tried to be nice to people instead of threatening them to get what you want ?
That's the idea
Unlikely to have a WPS button in a hotel room.
The President has threatened to deport many people because of their political views, and he has already arrested at least two that I know of, plus one more who left the country before she could be deported. So it's not a "theoretical slippery slope" argument.
if you hold-press on any system notification in a reasonably modern non-nerfed android, it'll give you a gear that'll let you turn on/off individual notification categories. You can access this from the very top of the "App info" system page you get by hold-pressing the icon. For Play you want to disable "Payments, Deals,
and Recommendations" category.

Most apps on my phone are on a "one strike" policy, and some don't use notification categories (like the Amazon shopping app) and thus don't get to make any noise and I rely on my mail receiver to email me when they accept a package instead of the Amazon push notifications
In video games that have procedural generation, there's often a seed function that predicts a continuous geometry.

But in order to track state changes from free agents, when you get close to that geometry the engine converts it to discrete units.

This duality of continuous foundation becoming discrete units around the point of observation/interaction is not the result of dueling models, but a unified system.

I sometimes wonder if we'd struggle with interpreting QM the same way if there wasn't a paradigm blindness with the interpretations all predating the advances in models in information systems.
When a higher level of abstraction allows programmers to focus on the detail relevant to them they stop needing to know the low level stuff. Some programmers tend not to be a fan of these kinds of changes as we well know.

But do LLMs provide a higher level of abstraction? Is this really one of those transition points in computing history?

If they do, it's a different kind to compilers, third-party APIs or any other form of higher level abstraction we've seen so far. It allows programmers to focus on a different level of detail to some extent but they still need to be able to assemble the "right enough" pieces into a meaningful whole.

Personally, I don't see this as a higher level of abstraction. I can't offload the cognitive load of understanding, just the work of constructing and typing out the solution. I can't fully trust the output and I can't really assemble the input without some knowledge of what I'm putting together.

LLMs might speed up development and lower the bar for developing complex applications but I don't think they raise the problem-solving task to one focused solely on the problem domain. That would be the point where you no longer need to know about the lower layers.
Last year I learned a new language and framework for the first time in a while. Until I became used to the new way of thinking, the discomfort I felt at each hurdle was both mental and physical! I imagine this is what many senior engineers feel when they first begin using an AI programming assistant, or an even more hands-off AI tool.

Oddly enough, using an AI assistant, despite it guessing incorrectly as often as it did, helped me learn and write code faster!
There is an option to not link to it for instances like OS writing and embedded. Writing everything in pure Rust without libc is entirely possible, even if an effort in losing sanity when you're reimplementing every syscall you need from scratch.

But even then, your code is calling out to kernel functions which are probably written in C or assembly, and therefore "dangerous."

Rust code safety is overhyped frequently, but reducing an attack surface is still an improvement over not doing so.
Everyone in my (US) family slams doors to close them, it drives me nuts. The whole building shakes. I blame the spherical door knobs, their design and appearance invites just pushing/pulling the door without gently grabbing and turning the handle.
>You aren't going to find departures just by banging around in your garage

This kind of rhetoric saddens me. Someone says "design an experiment" and you jump to the least charitable conclusion. That people do this is perhaps understandable, but to do it and not get pushback leads to it happening more and more, to the detriment of civil conversation.

No, the experiment I had in mind would take place near the Schwarzchild radius of a black hole. This would require an enormous effort, and (civilizational) luck to defy the expectations set by the Drake equation/Fermi paradox. It's something to look forward to, even if not in our lifetimes!
> They are terrible in that removing obsolete columns requires a drop and recreation, which can become a nightmare when you build views on views.

This is a problem with the `alter` abilities, but in fact the lack of using `views` is a problem.

`views` is how you abstract the database. Also, combined with `instead of` triggers become amazing to simplify the other triggers.

Nothing more awesome than flatten your db so external code barely ever do joins themselves.

My trick to solve the problem of migrations is that I put all the `views, functions, etc` in their own section of a `sql` file:

-- DEPS --

-- VIEWS

-- FUNCTIONS

-- TRIGGERS

And then I have a special `DROP ALL VIEWS, CREATE ALL VIEWS` comment in my migrations that do that. It remove the problem greatly!
This is the reason I don’t use auto completing IDEs. Pretty much vanilla emacs. I do often use syntax highlighting for the language, but that’s the limit of the crutches I want to use.
Military grade sonic weapon is used against protesters in Serbia
There are no arrow on the numeric island an Apple keyboard, nor is there a numlock key. There is a 'clear' key on the numeric island in the location where a PC would have a numlock key (it has the function of the 'AC' key on a calculator and functions as such in the calculator app).
The idea is that you can trivially search the code base for "unsafe" and closely examine all unsafe code, and unless you are doing really low-level stuff there should not be much of it. Higher level code bases should ideally have none.

It tends to be found in drivers, kernels, vector code, and low-level implementations of data structures and allocators and similar things. Not typical application code.

As a general rule it should be avoided unless there's a good reason to do it. But it's there for a reason. It's almost impossible to create a systems language that imposes any kind of rules (like ownership etc.) that covers all possible cases and all possible optimization patterns on all hardware.