Back to home page

Redis cross reference



0001 [Note: this is the Redis manifesto, for general information about
0002        installing and running Redis read the README file instead.]
0004 Redis Manifesto
0005 ===============
0007 1 - A DSL for Abstract Data Types. Redis is a DSL (Domain Specific Language)
0008     that manipulates abstract data types and implemented as a TCP daemon.
0009     Commands manipulate a key space where keys are binary-safe strings and
0010     values are different kinds of abstract data types. Every data type
0011     represents an abstract version of a fundamental data structure. For instance
0012     Redis Lists are an abstract representation of linked lists. In Redis, the
0013     essence of a data type isn't just the kind of operations that the data types
0014     support, but also the space and time complexity of the data type and the
0015     operations performed upon it.
0017 2 - Memory storage is #1. The Redis data set, composed of defined key-value
0018     pairs, is primarily stored in the computer's memory. The amount of memory in
0019     all kinds of computers, including entry-level servers, is increasing
0020     significantly each year. Memory is fast, and allows Redis to have very
0021     predictable performance. Datasets composed of 10k or 40 millions keys will
0022     perform similarly. Complex data types like Redis Sorted Sets are easy to
0023     implement and manipulate in memory with good performance, making Redis very
0024     simple. Redis will continue to explore alternative options (where data can
0025     be optionally stored on disk, say) but the main goal of the project remains
0026     the development of an in-memory database.
0028 3 - Fundamental data structures for a fundamental API. The Redis API is a direct
0029     consequence of fundamental data structures. APIs can often be arbitrary but
0030     not an API that resembles the nature of fundamental data structures. If we
0031     ever meet intelligent life forms from another part of the universe, they'll
0032     likely know, understand and recognize the same basic data structures we have
0033     in our computer science books. Redis will avoid intermediate layers in API,
0034     so that the complexity is obvious and more complex operations can be
0035     performed as the sum of the basic operations.
0037 4 - Code is like a poem; it's not just something we write to reach some
0038     practical result. Sometimes people that are far from the Redis philosophy
0039     suggest using other code written by other authors (frequently in other
0040     languages) in order to implement something Redis currently lacks. But to us
0041     this is like if Shakespeare decided to end Enrico IV using the Paradiso from
0042     the Divina Commedia. Is using any external code a bad idea? Not at all. Like
0043     in "One Thousand and One Nights" smaller self contained stories are embedded
0044     in a bigger story, we'll be happy to use beautiful self contained libraries
0045     when needed. At the same time, when writing the Redis story we're trying to
0046     write smaller stories that will fit in to other code.
0048 5 - We're against complexity. We believe designing systems is a fight against
0049     complexity. We'll accept to fight the complexity when it's worthwhile but
0050     we'll try hard to recognize when a small feature is not worth 1000s of lines
0051     of code. Most of the time the best way to fight complexity is by not
0052     creating it at all.
0054 6 - Two levels of API. The Redis API has two levels: 1) a subset of the API fits
0055     naturally into a distributed version of Redis and 2) a more complex API that
0056     supports multi-key operations. Both are useful if used judiciously but
0057     there's no way to make the more complex multi-keys API distributed in an
0058     opaque way without violating our other principles. We don't want to provide
0059     the illusion of something that will work magically when actually it can't in
0060     all cases. Instead we'll provide commands to quickly migrate keys from one
0061     instance to another to perform multi-key operations and expose the tradeoffs
0062     to the user.
0064 7 - We optimize for joy. We believe writing code is a lot of hard work, and the
0065     only way it can be worth is by enjoying it. When there is no longer joy in
0066     writing code, the best thing to do is stop. To prevent this, we'll avoid
0067     taking paths that will make Redis less of a joy to develop.