balefrost · HackerTrans

balefrost

no profile record

コメント

2 年前議論

MacOS also employs memory compression, so it's not necessarily swapping to disk.

3 年前議論

My experience is, for businesses who pay attention to open-source licenses, they will avoid GPL libraries like the plague (GPL applications are usually fine, though there's sometimes some skepticism).

But not all businesses pay close attention to open-source licenses.

I have to assume that scale has something to do with it. Huge companies usually take that pretty seriously. Tiny companies... eh, they might not even be aware.

4 年前議論

Nor any other non-FAANG company I've ever worked for. In my experience, 401k matches are immediate.

4 年前議論

If you just need "switch using keyboard", not necessarily "switch using shell", some KVM switches allow input switching using keypresses. For mine, it's <SROLLLOCK> <SCROLLOCK> <1-4> <ENTER>, though I think that can be customized.

4 年前議論

I dunno, even in C codebases, it's not uncommon to have data structures containing function pointers. Polymorphism isn't inherently bad and trying to achieve it using, say, enums and big switch statements isn't particularly maintainable.

4 年前議論

It depends on who is buying the Steam Deck. If it's people who don't already have a PC, then sure, Valve is broadening their market. But if it's people who already have a gaming PC, then it probably won't lead to a lot of additional software sales.

4 年前議論

The Atari 2600 had a digital joystick. The Atari 5200 was completely analog. If you tear the controller down, there's a complex mechanism that links the stick to two rotational potentiometers. It's similar in outcome to modern analog thumbsticks, but the mechanism is completely different (and is MUCH bigger).

The 5200 joystick didn't self-center, though. The only centering force was from the rubber boot. This ended up being advantageous in a game like missile command, but is widely seen as the Achilles heel of the controller.

4 年前議論

Yes, I should have been clearer. I meant that their Linux investment started out as a hedge, but over time they were able to pivot it to something else.

I'm not sure what the impetus was for the Steam Deck. I could see it as a hedge against anticipated future, dwindling laptop sales. I could also see it as an attempt to expand into the same space that the Switch occupies. After all, with the exodus of Sony from portable gaming, Nintendo's only competition is cell phones.

4 年前議論

I might have overstated that. Looking at eBay "sold" prices, they seem to go for anywhere from 30 USD (controller only, no accessories) to over 100 USD (used, but in box with accessories) or 200 USD (sealed in box). But even then, there's a lot of price variation - there are sealed controllers for as low as 130 USD.

4 年前議論

And Atari released theirs back in 1982.

4 年前議論

It's unclear whether Valve is playing the long game or simply hedging their bets. My recollection is that their investment in Linux was expressly stated to be a hedge against a future where Microsoft put Windows in a walled garden, like iOS.

On the other hand, I know that a bunch of people are unhappy that the Steam Controller has been discontinued. Secondhand prices are through the roof.

4 年前議論

I can't speak about Haskell, but Clojure's lazy sequences also generate a lot of intermediate allocs.

For example, here's Clojure's implementation of `map`[1]. It internally uses `cons` to build a cell[2] and `map` to recursively walk the collection (but all wrapped up in `lazy-seq` to delay evaluation).

Transducers[3] do help with this if you are applying a stack of collection transformations. But, and this is just my opinion as a very occasional Clojure user, transducers are harder for me to grok and so I generally avoid using them. If I was doing performance critical work, I might try to build up a better mental model.

My biggest complaint about the Java streams API is that it makes it hard to write your own stream transformation functions. Or rather, you can, but then calling them is awkward. You generally transform a Stream by calling instance methods - e.g. `myStream.map(::f)`. But since Java doesn't have extension functions, there's no way for you to make a custom function callable in the same way as the built-in functions. I ended up writing a small shim to build a stream pipeline without using member functions. You would use it something like this:

    newPipeline(stream)
        .then(map(::mapFn))
        .then(filter(::filterFn))
        .then(customTransform())
        .collect(Collectors.toList());

Contrast that to Clojure, where everything's a function:

    (into []
      (customTransform
        (filter filterFn
          (map mapFn collection))))

Or (using the threading macro, I think this is right)

    (->> collection
      (map mapFn)
      (filter filterFn)
      (customTransform)
      (into []))

Or (using transducers, I'm really not sure if this is right)

    (into []
      (comp
        (map mapFn)
        (filter filterFn)
        (customTransducer))
      collection)

[1] https://github.com/clojure/clojure/blob/2b3ba822815981e7f769...

[2] https://github.com/clojure/clojure/blob/2b3ba822815981e7f769...

[3] https://clojure.org/reference/transducers

4 年前議論

> God forbid you try to change the audio device from speakers to headphones in the middle of a call.

I've been using it for a couple of years, and I have never had this issue. I can switch between my built-in soundcard and my USB headset without any problems. On Windows FWIW.

4 年前議論

The EULA is giving you permission to e.g. copy and modify the font with certain restrictions (e.g. include the license text if you distribute it). In that regard, it's not terribly dissimilar in spirit from an open source software license.

4 年前議論

It's probably not as impressive as Miniaturwunderland, but if you're in the US, and specifically near northern New Jersey, there's a neat place called Northlandz [1]. It's much older than Miniaturwunderland and I'm sure it doesn't have the level of computer control. But it's huge. Even going as an adult, I was still surprised at how large the display room was. It's been maybe 6 years since I last visited.

There was another, much smaller one that was closer to home - Roadside America [2] - but it sadly closed permanently during the pandemic. I remember going there several times as a child and really enjoying every trip.

[1] https://northlandz.com/

[2] https://en.wikipedia.org/wiki/Roadside_America

4 年前議論

Are you not doing the same thing that the author is doing? The author has a bias against blockchain, sees blockchain proponents making a poor argument, and that reinforces their bias against blockchains.

You have a bias seemingly in favor of blockchains, you see a blockchain critic making a poor argument, and that reinforces your belief in blockchains.

I think the linked post makes good points (e.g. git and blockchains are related but not broadly comparable) wrapped up in a lot of unnecessary opinion.

Surely the rational approach is to just discount bad arguments, not to treat them as evidence to reinforce the opposite position.

4 年前議論

The Raspberry Pi foundation recently (about a 18 months ago) released their own dual-core ARM chip - the RP2040 - and a corresponding dev board - the Pi Pico. The Pico dev board runs about $4 plus shipping from authorized resellers.

Within the past few weeks, they introduced a wireless version - the Pi Pico W. It's about $6 from authorized resellers, though stock is hard to find at the moment.

https://www.raspberrypi.com/documentation/microcontrollers/

https://www.raspberrypi.com/news/raspberry-pi-pico-w-your-6-...

4 年前議論

In the worst case, you would get 2 leap seconds per year. So in the worst case, 1800 years.

However, in the past 50 years, we've only had 27. So at the current rate, probably more like 6667 years to be off by an hour.

Of course, if the earth's rotation changed speed by so much that 2 leap seconds per year wasn't enough, we'd find a way to cram more in. In fact, in that case, the case for leap seconds would probably get stronger.

4 年前議論

The RP2040 has a programmable IO subsystem. This lets you define a simple state machine that manages the IO pins and can transfer data to/from memory.

Here's what the project's README says:

So, how the heck the pico is able to achieve this? Well, the key are the PIO units, these units are a wonder, they are coprocessors explicitly dessigned to handle IO, it uses a very restricted and deterministic assembler (only nine instructions that each take a single cycle to execuet) but extremely efficient, so efficient that with only two instructions is possible to create a loop that captures GPIO data up to 30 bits and redirects the program flow based in the status of one of these GPIOs.

4 年前議論

North America got both variants. This iteration is the model 2, but the model 1 was also sold here.