Elements of Clojure

@elementsofclj

A book about the philosophy of software, through the lens of Clojure

Vrijeme pridruživanja: srpanj 2018.

Tweetovi

Blokirali ste korisnika/cu @elementsofclj

Jeste li sigurni da želite vidjeti te tweetove? Time nećete deblokirati korisnika/cu @elementsofclj

  1. Prikvačeni tweet

    A print edition of the book is now available for purchase. It will show up on Amazon et al in a month or so, but in the meantime you can purchase it directly from Lulu:

    Poništi
  2. proslijedio/la je Tweet
    31. pro 2019.

    Beginning to read . ❤️ the typesetting and small format.

    Poništi
  3. We’ve reached the end of the book once more. The quotes will begin again in January, but in the meantime: if you like the quotes, read the book! If you’ve read the book, please rate or review it on Amazon, Goodreads, or anywhere else books are judged. It really does help.

    Poništi
  4. This book cannot tell you if your software is useful. There are no formulas to reduce our software down to an objective measure of worth. It can, however, help you judge for yourself.

    Poništi
  5. A task ends when the consequences of an effect are uncertain. We can display text on a screen, but we can't dictate how the user will respond; we can write a value to the database, but we can't dictate if it will ever be read.

    Poništi
  6. proslijedio/la je Tweet
    27. pro 2019.

    This is a very deep truism of almost all "functional-ish" languages. Functions accrete via various composition mechanisms. They cannot be edited, and furthermore, they are opaque.

    Poništi
  7. A function cannot be reduced or reshaped; it can only accrete.

    Poništi
  8. A process is a mostly opaque thing. We cannot directly alter it or see inside it. All we can do is share data and wait for it to do the same. This means that, unlike most things in Clojure, processes are not values.

    Poništi
  9. There are only three things we can do with data. We can *accrete* data by adding it to an existing collection, *reduce* data by discarding information from an existing collection, or *reshape* data by placing it in a different kind of collection.

    Poništi
  10. Most input data is not inherently limited in its origin, shape, and size. Most new input data does not have its effects carefully monitored by a trained engineer. In most cases, we must make our processes intrinsically robust.

    Poništi
  11. In some cases this is unavoidable. Limits are tied to the specifics of our application and do not generalize. Since the components of our file system sit beneath many such applications, they cannot define their own timeouts.

    Poništi
  12. Queues by themselves do not provide isolation. Queues couple the execution of processes and, by default, allow one process to block the other indefinitely. If neither places limits on how long it will wait to push or pull data, they cannot be understood separately.

    Poništi
  13. These strategies, describing what our process will do when its environment provides too much or too little, are called an *execution model*. A process with a well-defined execution model can be safely considered in isolation.

    Poništi
  14. A Ring webserver is a *framework*; it invokes our code rather than being invoked by it. This frees us from having to consider the complexity of effects when writing our code, but it also makes it more difficult to understand what our software is doing in production.

    Poništi
  15. proslijedio/la je Tweet

    In more stringent domains we must fight to keep the system as simple as possible, so that it can fit in our head. Any system that exceeds our understanding will inevitably grow a bit slow and flaky, no matter what the design specification says.

    Poništi
  16. In more stringent domains we must fight to keep the system as simple as possible, so that it can fit in our head. Any system that exceeds our understanding will inevitably grow a bit slow and flaky, no matter what the design specification says.

    Poništi
  17. A complementary strategy is to define timeouts, which prevent a process from ever waiting too long. If a timeout elapses, we don't try to understand why; we just try to recover.

    Poništi
  18. If we never wait longer than we're willing to, there's no need to consider the system as a whole. The simplest way to achieve this is to have low expectations.

    Poništi
  19. Mutability may be necessary at the edges of our processes, but it should be avoided elsewhere. If we pass a mutable data structure into a function, we cannot prevent that function from sharing it with another process, creating a new edge in our system.

    Poništi
  20. Communication between processes is only possible via shared references, and any change to such a reference is called an *effect*.

    Poništi
  21. A process can only access data that is globally visible or passed in as a parameter. Once initialized, its universe is bounded and fixed, consisting of both immutable values and mutable references.

    Poništi

Čini se da učitavanje traje već neko vrijeme.

Twitter je možda preopterećen ili ima kratkotrajnih poteškoća u radu. Pokušajte ponovno ili potražite dodatne informacije u odjeljku Status Twittera.

    Možda bi vam se svidjelo i ovo:

    ·