madmax96

I think the real key is that Apple has recognized that App Store delays are a problem and has taken steps to quantifiably improve the situation. See https://appreviewtimes.com/. Anecdotally, the first version of one of my Apps was approved in < 8 hours. On another, more gray area app, it took ~1.5 weeks. Gone are the days of 4 week update delays. I’ve found that Apple’s release process has identified useful problems in my apps too.

+1 on Firebase. I recently helped a buddy build an app and decided to give it a try. Holy crap. All we had to was build the app! significantly faster than either of us estimated.

You can access it in Emacs itself with C-h t

There's also not really an evaluation section. So how can we conclude it is effective?

If there is often no scheduler, how does multithreading work? Also, how do things like valgrind or compiler sanitizers work for unikernels?

I think that this is a valuable lesson for CS students. I used to underestimate time for the same reasons these students did. The core technology (in this case, listening for the clipboard events) fits in the estimate. Making a product that can actually be useful will take much longer.

Estimating effort is important. Work is an investment, so the decision to invest changes with the amount of work.

I think this lesson can only be learned the hard way: create a new application and try to get users. You’ll learn where you spend time and get better at estimating. You’ll also appreciate why “simple” features appear slowly in software you use.

>but since most wealth is held by the rich, inflation affects them most

But not much of that wealth is liquid. Hyperinflation hurts savers.

Computer Architecture is exciting. Non Volatile memory, dark silicon, FPGAs, etc are gaining serious traction. Also integrated photonics.

> Everyone who holds cryptocurrency is holding Tether’s bag of poo

Everyone who holds Tether is holding Tether’s bag. If you don’t own tether, this doesn’t directly affect you. Most of the people I know don’t own (and have never owned) Tether.

I disagree. Many engineers want to refactor across a sequence of small PRs, for example. Small PRs are a good thing, because they’re easier to understand. But today, Git makes this painful. Also, understanding how the meaning of code changes over time can help reduce bugs.

The solution will have to be pluggable. But I think it is possible, and there are sane things to do (e.g. fall back to vanilla git) when there are missing plugs.

Not only that, but studying math takes discipline, commitment, and practice. You can’t passively learn math. To a certain extent, mathematical illiteracy is encouraged in society by the standard trope “I’m bad at math.” Almost everyone is bad at math. The difference is that some people understood math is the best way to precisely understand the world and worked to understand it.

I agree. With the 40 hours I’ve saved each month, I’ve wound up giving easily at least 10 more hours to my employer. I’ve used the remaining 30 to connect more with my spouse, work out, improve my home, read, and take mindfulness breaks.

My employer gets more labor. I feel more rested, so I engage more with my work. I’m interested in hearing perspectives where this is a bad thing.

Why not make it so that I can see flagged images in my library? It would give me a lot more confidence that my photos stay private.

That is the point of the free market. But deplatforming certain kinds of offensive content is regressive.

For instance, in the not-so-distant past many Americans found interracial marriage morally abhorrent. Wikipedia says only 5% of Americans thought interracial marriage should be legal in the 1950s. In today’s environment, that leads to deplatforming those who would’ve supported marriage equality. This is not something we would desire.

People are full of prejudices. I’m sure our grandchildren will look back in horror at ours. Let’s not deplatform them for that.

I did not have AppleCare. Sorry to hear about your iPad Pro keyboard issues.

Do you still use Apple laptops? If not what do you use?

Are Apple laptops higher quality, compared to competitors (despite design issues)? My current Macbook had the screen laminate peel off after a few years. To Apple's credit, they promptly repaired the machine at no cost. But I've had friends with similarly priced laptops (XPS, Razor, ...) who encountered similar build-quality issues, but did not receive the same level of support. Granted, all this evidence is anecdotal. I am curious to see across the board comparisons.

Plus, I'm in the market for a new laptop anyway, so this would be a valuable data point. :)

The line is blurred even in conventional kernels, e.g. ioctl.

>Wikipedia already lists 2 paxos variants that have byzantine security One of those mentioned is Fast byzantine consensus (FBC) [1]. FBC provides an optimal algorithm for a 2 phase commit system w/ byzantine agents. But FBC requires that each correct process sends a message to each other. This is O(n^2) and does not scale. Bitcoin (specifically, others differ) maintain some of the invariants with extremely high probability over time. High enough to be useful. In exchange, bitcoin's network scales much better. Really, it just needs O(n) messages to confirm a transaction.

Of course, PoS like Ethereum's takes much inspiration from byzantine paxos. But I wouldn't call this a solve problem, and crypto has innovated in this space. We can just debate whether or not the innovation has been worthwhile ;).

[1] https://www.cs.utexas.edu/~lorenzo/papers/fab.pdf

>I have yet to see any of this be an actual problem in real-world projects

Just on Monday, I was bitten by a bug caused by operator overloading. I'm building a static analysis tool in C++. There's a method `getType()` that returns the qualified type of an expression. I had a call to `getType()` nested in some other calls, e.g. `expr->asAssignmentExpr()->getRHS()->getType()->getSomeQualifiedTypeProperty()`.

The creators of the `QualifiedType` type that's returned by `getType()` had overridden the class member access operator to return an UnqualifiedType. This problem took me an embarrassingly long amount of time to diagnose. The compiler error messages told me that `UnqualifiedType` doesn't have a property `getSomeQualifiedTypeProperty`, but I couldn't see why I was getting an unqualified type from a method that is supposed to return a qualified type. I searched the documentation online, searched the header files, tried reinstalling the library, nothing made sense.

Then, I learned this operator had been overloaded. So, I just needed to write `expr->asAssignmentExpr()->getRHS()->getType().getSomeQualifiedTypeProperty()`.

Ouch.

The mining reward is not intrinsic to BTC. It can be adjusted as needed (provided 51% of compute agree.)

I’m a relative newcomer to Haskell. I still haven’t used it for anything serious, but I’d like to.

I had experienced all of these problems. Initially, I was attracted to Haskell for the promise of “if it compiles then it’s probably correct.” I quickly discovered that isn’t true, for the reasons discussed in the article.

But I also had issues with Cabal. I couldn’t get Snap to install. I tried installing it in a container, still didn’t work. I finally figured out something that would let me build with Snap, but for some reason LSP in Emacs couldn’t find the snap libraries, so it couldn’t provide me correct feedback. And then the build times. Wow. I gave up on writing that program in Haskell and wrote it in Go instead.

I think Haskell has a lot to offer. I’d be open to trying it again. Hopefully these shortcomings improve.

It doesn't eliminate that. But it gathers evidence. Where did they acquire the 10,000 bananas? Multiple parties must collude -- and then that collusion is on record.

I'm interested in if that data is useful to anyone?

Also, why not trust a central entity with that data?

in what ways have crypto currencies been colossal failures?

Proof of stake doesn't prevent 51% attacks. It eliminates the incentive. If an attacker controls 51% of coins, why would they attack the network? That would be attacking their own wealth.

It's an interesting take. e.g. provide specs/types across module boundaries only. Gradual typing is certainly becoming popular. Meanwhile, statically typed languages are adopting type inference. Some people only write the types for the exports in their modules. The two worlds are coming closer. More statically typed languages are adding dynamic type information (like Go). More dynamically typed languages are supporting static type markup (like Python).

There is no limit on the number of problems easier to solve using dynamically typed languages. For an individual hacker, dynamically typed languages make a lot of sense. I don't forget what types my functions accept as I am writing a program. All static typing can accomplish is slow me down when I'm trying to bang out something. This is why Python (for instance) is loved by data scientists, researchers, and startups. And they're right to love it! Purely anecdotal, but I can accomplish more faster (from a clean slate) with a dynamic language like Python than I can with Haskell, Go, or Rust. The difference is small, but non-negligible.

But static typing has a few key benefits:

* No searching through comments for type constraints.

* Better autocompletion.

* Better compilation.

* Better serialization/deserialization.

I do think static typing pays for itself in the long term. Sometimes, we shouldn't care about that. Engineering means managing tradeoffs: short-term velocity vs long-term performance and maintainability?

Microsoft acquired GitHub for $7.5 billion. How much is GitLab worth?

How much money has Microsoft made selling Windows vs Linus off Linux?

How much money does Apple make off iThings?

I'm not sure I follow. To me, recent polarization is a product of echoChamber * confirmationBias. e.g. (1) I subscribe to a trustworthy information outlet on $PLATFORM that reflects my beliefs. (2) I am recommended related untrusted content to increase my engagement with $PLATFORM. (3) I do not verify the related content because it reflects what I already believe. Rinse, cycle, repeat. Forcing voters to "shut up" means only allowing information to be shared by trustworthy sources. Over time I suspect that decreases polarization, at the expense of free speech.

How has Google monetized Chrome?

>A profiler can tell you when you should drop asynchronously

Is there any profiler that does this today?

What are the drawbacks with asynchronous drops?