27 Matching Annotations
  1. Last 7 days
    1. Most users crave pleasant UX

      I don't even think that's it. Plenty of people are willing to do with poor UX. (Look at GitHub.) The overriding factor is actually a consistently familiar interface. (Look at GitHub.)

      Related: https://www-archive.mozilla.org/unity-of-interface.html

  2. Jun 2021
    1. The first argument to shared_context (the shared group name) is superfluous. It feels a bit like "what's this argument for again?" (Note that you could still use it with include_context to include the group manually, but it's a bit odd to mix-and-match the approaches).
    1. Once a variable is specified with the use method, access it with EnvSetting.my_var Or you can still use the Hash syntax if you prefer it: EnvSetting["MY_VAR"]
  3. Mar 2021
  4. Feb 2021
    1. provide interfaces so you don’t have to think about them

      Question to myself: Is not having to think about it actually a good goal to have? Is it at odds with making intentional/well-considered decisions?  Obviously there are still many of interesting decisions to make even when using a framework that provides conventions and standardization and makes some decisions for you...

    1. Using a terminus to indicate a certain outcome - in turn - allows for much stronger interfaces across nested activities and less guessing! For example, in the new endpoint gem, the not_found terminus is then wired to a special “404 track” that handles the case of “model not found”. The beautiful thing here is: there is no guessing by inspecting ctx[:model] or the like - the not_found end has only one meaning!
    1. In object-oriented programming, information hiding (by way of nesting of types) reduces software development risk by shifting the code's dependency on an uncertain implementation (design decision) onto a well-defined interface. Clients of the interface perform operations purely through it so if the implementation changes, the clients do not have to change.
    1. Programming to an interface means that when you are presented with some programming interface (be it a class library, a set of functions, a network protocol or anything else) that you keep to using only things guaranteed by the interface. You may have knowledge about the underlying implementation (you may have written it), but you should not ever use that knowledge.
    2. The problem with this is that it creates a strong coupling between your code and the implementation, exactly what the interface was supposed to prevent.
  5. Oct 2020
    1. Interface specifications can be reused through inheritance but implementation need not be.
    2. The existing interface is closed to modifications and new implementations must, at a minimum, implement that interface.
    3. This assumes that the module has been given a well-defined, stable description (the interface in the sense of information hiding).
  6. Sep 2020
  7. Jul 2019
    1. Undo/Redo Have you noticed that Undo support on almost all web applications is either nonexistent or terrible? It's hard to implement, but Core Data solves the problem elegantly. An Undo button encourages users to experiment with the application and not be afraid of making mistakes.

      huh, nice

  8. Feb 2019
    1. And the screens are almost horizontal

      It took quite a long time to get to more tactile interfaces, yet still, predominantly (as I am using a laptop right now) interfacing more of a vertical interface.

  9. Sep 2015