Yes, two bits (assuming you only need to encode those four bases; unfortunately, biological reality requires FASTQ to encode other nucleotide values). There's even a format from UCSC called "2bit" (https://genome.ucsc.edu/goldenPath/help/twoBit.html)
I'm writing a component library[1] on top of SwiftUI and while there are ton of unsolved problems in SwiftUI, the separation of concern allows for much more productive workflows than were ever commonplace in UIKit.
We're dropping into UIKit land quite frequently but for the user of the API, that remains implementation detail and while likely change as SwiftUI advances.
Ironically, a "Stock iOS" style app like Mail or Contacts is much harder to pull off with SwiftUI than an app like AirBnB that brings has its own design aesthetic and establishes its own conventions – cooperating closely with your designers and keeping them aware of what's easy/hard is a much better use of your time than trying to rewrite a pixel perfect `UISearchController` clone.
That said, navigation remains a complete mess and I hope that's a top priority for iOS 16.
I don't hear it myself but you might be interested to learn that the DotA song derives from 2000's Daddy DJ by the band of the same name https://www.youtube.com/watch?v=flL_2awF-QI
Without Taylor Swift (or any other big name major label artist), Spotify might not be a viable business though.
Taylor Swift may argue that she's entitled to a better deal since she drives traffic, similar to how Apple Stores can negotiate better rents in shopping malls.
Apologies, I have no idea how "perfect" perfect pitch is (is it sub-semitone accurate?) but could it be you were first exposed to these songs on PAL-region TV where they suffered from PAL speedup (or the inverse)?
No - I mean I’m listening to a song and I go to the piano to play along with it. The first note I play is sometimes a half step off.
This is not likely to happen with a recording of the instruments I’ve always played (piano and trumpet) but might happen if I’m listening to guitars or organ.
Note that this implementation of `isEven` throws on input that isn't a number or numbers that are not integers, NaN or larger than 2^53-1. I think it's fair to argue an implementation could just as well return false for 1.4, NaN or '2'. There is a cost to learning these minutiae of your dependencies, especially if there is no compiler support to assist you.
I've not programmed a lot of JS, so this might be obvious for someone who did, but:
Why does he first use Math.abs on the parameter and then type check the result of that? I'd think if you do an argument type check, you'd do it before using it. Just to make it not throw on null? I don't see the sense in that...
I'm not sure this is the reason for that specific implementation but `Math.abs` _will_ do a string-to-number conversion.
I.e., `Math.abs("-27")` yields `27`.
It might be the case that Math.abs does other *-to-number conversions also, so maybe this method is trying to take advantage of that. (Math.abs is usually implemented as a native function so without digging more deeply it's not obvious to me what the actual implementation does.)
UPDATE: Curiously, `Math.abs(null)` yields `0`, so a null argument passed to is-even would yield `true` I guess.
Also whatever the logic is for that conversion is it is not the same as the built-in `parseInt` or `parseFloat`. `parseInt("27 meters")` yields `27` but `Math.abs("27 meters")` yields `NaN`.
Personally in JavaScript I almost universally make use of home-grown `isInt` and `toInt` methods whose behavior is predicable for me -- eg. my toInt() will reject a string that's not _just_ an integer value (and return `null` rather than `NaN` in all cases because who wants to check `isNaN`?) -- but that's probably not a great practice either. But I've been programming long enough to realize that the principle of least surprise is probably the most important concern here for long-term efficiency. I suppose what is or is not surprising may be subjective though.
