It’s basically a matter of expressing your dependencies in terms of interfaces instead of concrete classes (or worse, static methods). So if one of your classes needs to perform authentication, it should be provided an IAuthenticator (or whatever). This means that: You can write your code before implementing the real dependency You can test via … Read more
There are probably several reasons. Here are some: Huge backwards compatibility problems How would you write the definition of ICollection<T>? This looks natural: interface ICollection<T> : IReadOnlyCollection<T> { int Count { get; } } But it has a problem, because IReadOnlyCollection<T> also declares a Count property (the compiler will issue a warning here). Apart from … Read more
In an optimistic update the UI behaves as though a change was successfully completed before receiving confirmation from the server that it actually was – it is being optimistic that it will eventually get the confirmation rather than an error. This allows for a more responsive user experience.
what exactly does his pattern introduce? OLOO embraces the prototype chain as-is, without needing to layer on other (IMO confusing) semantics to get the linkage. So, these two snippets have the EXACT same outcome, but get there differently. Constructor Form: function Foo() {} Foo.prototype.y = 11; function Bar() {} Bar.prototype = Object.create(Foo.prototype); Bar.prototype.z = 31; … Read more
In short they come from to different conceptualizations that, in some languages where double dispatch is not natively supported, lead to the visitor pattern as a way to concatenate two (or more) single dispatch in order to have a multi-dispatch surrogate. In long The idea of multiple dispatch is – essentially – allow a call … Read more
A simple example is java.io.OutputStream. The template method is public void write(byte b[], int off, int len). It calls the abstract method public abstract void write(int b), which must be implemented by a subclass of OutputStream. In this case the invariant portion of the template is the basic error handling that is common to every … Read more
The Activity and the View are created at essentially the same time. The Surface is created later, and that’s what the SufaceHolder callbacks are for. You can’t render on the Surface before it exists or after it’s destroyed, so there’s no point in starting your rendering thread before then or leaving it running after. The … Read more
While you can reuse WithCancellation for both cancellations and timeouts I think it’s an overkill for what you need. A simpler and clearer solution for an async operation timeout would be to await both the actual operation and a timeout task using Task.WhenAny. If the timeout task completes first, you got yourself a timeout. Otherwise, … Read more
You missed the “double” part of the double dispatch. The point of this pattern is to make sure that the right method of the processor is called – the method that accepts the right type. Since the processor is initially not aware of the type of the object that’s passed to it, you need the … Read more
The best approach is to use a set: if cond in {‘1′,’2′,’3′,’4’}: as membership testing in a set is O(1) (constant cost). The other two approaches are equal in complexity; merely a difference in constant costs. Both the in test on a list and the or chain short-circuit; terminate as soon as a match is … Read more