jmah

Just search for "iPod nano watch".

https://www.macworld.com/article/667363/ipod-nano-6g-with-st...

This was originally a comment on https://www.ashleygjovik.com/3250scott.html via https://news.ycombinator.com/item?id=40773136

Though it doesn't invalidate the gist of your saying, malloc is a user-space function not a syscall. (Its implementation will occasionally do a syscall, such as to sbrk or vmmap.)

Lockdown Mode was added in iOS 16. The article only mentions iOS 15.7, saying there is no information whether iOS 16 is vulnerable (with or without Lockdown Mode), unfortunately.

It's curious they say iOS 16 was released "last month" when it was released last year.

Images are broken; 403 from googleusercontent.com

No, because when companies receive an unsigned resume (after modification), it will look like every other unsigned resume they receive

You can access it through DuckDuckGo.

Maybe an encompassing description of "cite" is "to publicly recognize"

$2500 of stock over three years? Seems like why even bother for that small amount, the overhead of the book-keeping (on both your and their side) would be a pain at that point.

For the record, that's a different Dyson. Not to say it won’t trigger the thought though!

Is that a third party kernel extension? Sounds like a buggy one if so, and if it’s this <https://www.oneperiodic.com/products/handsoff/> then it might be lessening security instead of increasing it.

DuckDuckGo is fantastic on mobile (iPhone). It feels way faster than Google for me — part of that is not getting the "Can I use your location?" pop-ups which then trigger a re-search.

Plus there's no AMP junk in the results! And links are real links — when you copy them you get the URL, not some huge tracking string.

Occasionally I've felt like I'm not getting good results so have gone to Google to repeat the search. There hasn't yet been a case where that's helped, so I've stopped doing it.

That could be what's happening but enum case names can't be determined from the disassembly.

Parent is saying that the content of email is almost always transmitted in the clear. While the connection from client to server is (hopefully) secure, the server can see the plaintext of all messages passing through it — which it helpfully uses to provide some server-side facilities like search and filtering — but if someone hacks the server they get all the mail.

Contrast with more recent messaging protocols (e.g. iMessage, WhatsApp) where the server doesn't have access to the message, they're decrypted on the client (while potentially also authenticating the sender).

"rebase" (like many terms in git) has multiple implications. It sounds like you're advocating for squashing your commits / cleaning up your history, which I don't think anyone argues against. The linked post argues against re-parenting those changes.

The point is, what's the threshold for "enough support"? Already for Bitcoin Cash, different exchanges have come to different conclusions on whether it's sufficiently supported to list on their exchange.

Usually this is accomplished by blocking the keyboard shortcut; pasting via right-click menu typically works.

There are some OS-level features to support running arbitrary code in additional sandboxed processes.

The bottom references it being created using http://shorthand.com

Open the Image Capture application, and you can change the setting at the bottom-left of the window. It seems to get increasingly hidden with each OS release.

There's more stuff here: https://mapzen.com/tangram https://github.com/tangrams/

I assume that's the point of adding bash regression tests into the mix, if the tests cover "needed functionality".

Not that I can see here: http://www.hasbro.com/common/instruct/battleship.pdf

There a little here: http://en.wikipedia.org/wiki/Communication_with_submarines

and interesting detail here: http://en.wikipedia.org/wiki/Project_Sanguine

This code works:

    let d = [1: 1, 2: 2, 3: 3]
    let intToInt = d.map { $0 + 1 }
    var IntToString = d.map { String($0) }

I successfully got the Functor example to work like this:

    protocol Functor {
        typealias T
        typealias FunctorResult
        func map<P>(mappingFunction: T -> P) -> FunctorResult
    }
    
    extension Dictionary : Functor {
        func map<P>(mappingFunction: ValueType -> P) -> Dictionary<KeyType, P> {
            var newDict:Dictionary<KeyType, P> = [:]
            for (key, value) in self {
                newDict[key] = mappingFunction(value)
            }
            return newDict
        }
    }

My first reaction was to try the double-slit experiment, but unfortunately there was no interference pattern. Beautiful none the less. (Ok, a little less.)

Also Cocoa's NSString:

  [@"baffle" uppercaseString]; // @"BAFFLE"

Perhaps I want the original because other people value it more, such that its value is more likely to increase over the replica.

http://en.wikipedia.org/wiki/Positional_good (credit to dbond)

Bluetooth LE uses a client/server (called "central" / "peripheral") model; think of "server" like "web server", typically the client is your smartphone.

I could believe that a single peripheral can't simultaneously connect to multiple centrals (I'm just getting started with BTLE), but the typical pattern is for e.g. the heart rate sensor and smartwatch to both be peripherals of a smartphone.

The first article you reference says: So for folks that may use one device for cycling and another for running, this could cause issues if both devices tried to connect to the heart rate strap at the same time.

As long as you're not cycling and running at the same time, this isn't an issue.