I'm wondering why this is, it seems there is an assumption that you will always have an underlying observable which seems a to be an unnecessary and a limiting design. There are cases where you don't own the underlying state, in those cases
to properly bind to that state you either have to copy the state to an
observable or create a fake observable that you trigger on each write.

Also, if dependentObservables don't notifySubscribers on write, why do they even bother to do it on read? They get added to the observables list and subscribed to, but then they never trigger on updates. So what is the point of subscribing to them at all?

Is there some downside to calling notifySubscribers in the write that I am missing?

I think that for your scenario, dependentObservables may not be the right tool for the job. dependentObservables are set up to detect dependencies in the read function and re-evaluate/notify whenever any of those dependencies change. In a writeable dependentObservable, the write function is really just a place to intercept the write and allow you to set any observables necessary, such that your read function would return the proper value (write is typically the reverse of read in most cases, unless you are transforming the value).

For your case, I would personally use an observable to represent the value and then a manual subscription to that observable to update the original value (the one that you may not have control over).