According to this infographic (linked below), it seems like Apple Music does give more average revenue per play than Spotify, $0.0060 for vs $0.0044. But in general, Apple Music isn’t _that_ much better than the rest where paying artists goes. It lags far below tidal, for example, which doles out $0.0125 per play on average.

https://informationisbeautiful.net/visualizations/spotify-ap...

However, it's worth noting that Tidal has been accused of inflating its streaming numbers: https://www.musicbusinessworldwide.com/did-tidal-falsify-str...

Tidal's model is supposedly more literally like the proverbial "pie", where the most popular artists get the biggest cut. So if it's true that they inflate numbers for Jay Z and Beyonce, then other artists are being deprived of revenue.

Holy cow. So you have to play a song 227 times for the artist to make a dollar off the song? Any idea what it's like for just buying the song on Amazon?

Long time reader, first post.

It’s actually more plays than that because Spotify also takes 30% of each stream payout, so it’s odd they would also complain about a 30% mechanical.

The premium accounts payout more per stream than freemium accounts.

This is also assuming the artist owns the master recording outright, wrote the entire song, and administers their own publishing and mechanical royalties. The latter being almost impossible.

More than likely if signed to a label, they will get 10% of sales, the label will get the rest. This is based on traditional album deals where you get 1 point per song. If they are also published, the publisher takes half of their performance royalties, a mere 6-7 percent of stream payout. Also the PRO(ASCAP, BMI, etc) recieves half of the mechanicals, another measly 6-7 percent. To be clear if you don’t speak music payment terms. The people that own the publishing AKA the people that actually write the song, and administer that published writing only get 12-16% per stream payout(not fair). When labels receive around 48%-58% per stream payout, this is for a specialized business loan that pays for the recording + marketing and distribution(way too much). Not to mention this loan has to be totally recouped before the artist sees any of that 10 percent, if they ever do.

To sell anything on Amazon, you are charged $40/month for a professional account, or they have an under 40 item plan with a listing fee of $.99 per item. An additional 15% is taken by them on music sales. So if you have less than 40 songs you pay $.99 a month to list them each.

Damn, this sounds so brutal. Thank you for explaining.

Artists or record labels get about 30 cents of a $0.99 song purchase I believe.

Wow interesting... thank you!

The sieve is made out of Graphene-oxide, not pure Graphene, so should be easier to produce.

Isn’t that what the tesla semi electric truck and airbus e-fan x electric plane projects aim to help mitigate though: the reliance on gas for shipping/transportation?

Just because some use cases are not practical for renewables now doesn’t mean they won’t be in the near future.

This is a theory, but I feel that time of posting and accumulation of advantage (initial momentum makes it more noticeable, generating even more momentum) has more to do with a post getting more or less traction than a sort of collective memory decay, at least for this particular example.

Tl;dr: event-stream repo was injected with an attack that crawls your dependencies trying to find “copay-dash”. It then attacks it to steal all your bitcoin. The attacker was given maintenance rights to the repo by simply emailing the owner, who gave the rights freely. The owner and npm didn’t do a background check. Because of the MIT license, the owner has no liability/responsibility for his actions.

"Because of the MIT license" is a little misleading. Any FLOSS license out there would disclaim the same sort of warranties.

Well, more state in code usually makes it more difficult to do things like run the code concurrently. You have to worry about managing data races when there is a lot of shared state, whereas in stateless code no complex managing is needed

Although this is true of stateful code, I think an even more fundamental, but related, reason to reduce state is this: code that is stateless always behaves the same way so it can be characterized and reused more easily than code that changes behavior depending on the state. This is the reason it is good for concurrent programming, but it also means it has a more concrete/consistent nature.

Yep! Looks like the silent hardware upgrade happened in v5.0.0 of the OS.

Here's a youtube video published March 13th talking about it: https://youtu.be/ZzsbDGDwg1U?t=5m17s

And here's a related reddit discussion on the nintendo switch subreddit: https://www.reddit.com/r/NintendoSwitch/comments/8588c1/50_w....

That article studied IQ gains in students aged 17 or younger. I’m a bit skeptical the same findings generalize to adults and older, but I’d shown otherwise with other studies/sources

Maybe! Or maybe just wait - one thing we know is that technology will continue to improve, and there may be a headphone in the future that appeals to you even more by the time your PM3 gives out.

... Or maybe it's worth buying a reserve just as an investment. Some people regarded the PM-3 as one of the best value closed-back headphones on the market now[1][2]; there's a chance it may increase in price?

PM-3 Reviews:

[1] http://www.trustedreviews.com/reviews/oppo-pm-3

[2] https://www.techradar.com/reviews/audio-visual/hi-fi-and-aud...

Just to expand a little on the "you can take any loop and transform it into a tail recursion" (because I think it's cool), here's an example:

Python iterative solution

  1.  def fib(n):
  2.      i, curr, next = 0, 0, 1
  3.      while i < n:
  4.          i += 1
  5.          curr, next = next, curr + next
  6.      return curr

Python tail-recursive solution*

  1.  def fib(n):
  2.      def fib_tail(i, curr, next):                  #1
  3.          if i >= n:                                #2
  4.              return curr                           #3
  5.          return fib_tail(i+1, next, curr+next)     #4
  6.      return fib_tail(0, 0, 1)  

Some explanation of the 1-1 conversion process:

#1. We need a helper function, `fib_tail` to keep track of the variables we update in the while loop. (lines 4-5 in iterative)

#2-3. Return `curr` when the opposite of the while condition is met. (lines 3,6 in iterative)

#4. Recursively call `fib_tail`, using same update logic as while loop body when passing arguments. (line 5 in iterative)

#5. Call helper function with initial values for the additional variables (line 1 in iterative)

* We're going to pretend that Python supports tail recursion. It doesn't, but I figure more people are familiar with python; think of it more as pseudocode for instruction. You could easily implement the above in something like Scheme