fluencelabs/redis
1
0
Fork 0
mirror of https://github.com/fluencelabs/redis synced 2025-04-25 10:32:14 +00:00
Code Issues Projects Releases Wiki Activity

MANIFESTO v2.

Browse Source
This commit is contained in:
antirez 2019-03-18 15:38:43 +01:00
parent 14b17c3615
commit a5af648fdd
1 changed files with 41 additions and 6 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

47
MANIFESTO
View File

@ -34,7 +34,21 @@ Redis Manifesto
so that the complexity is obvious and more complex operations can be so that the complexity is obvious and more complex operations can be
performed as the sum of the basic operations. performed as the sum of the basic operations.
4 - Code is like a poem; it's not just something we write to reach some 4 - We believe in code efficiency. Computers get faster and faster, yet we
believe that abusing computing capabilities is not wise: the amount of
operations you can do for a given amount of energy remains anyway a
significant parameter: it allows to do more with less computers and, at
the same time, having a smaller environmental impact. Similarly Redis is
able to "scale down" to smaller devices. It is perfectly usable in a
Raspberry Pi and other small ARM based computers. Faster code having
just the layers of abstractions that are really needed will also result,
often, in more predictable performances. We think likewise about memory
usage, one of the fundamental goals of the Redis project is to
incrementally build more and more memory efficient data structures, so that
problems that were not approachable in RAM in the past will be perfectly
fine to handle in the future.
5 - Code is like a poem; it's not just something we write to reach some
practical result. Sometimes people that are far from the Redis philosophy practical result. Sometimes people that are far from the Redis philosophy
suggest using other code written by other authors (frequently in other suggest using other code written by other authors (frequently in other
languages) in order to implement something Redis currently lacks. But to us languages) in order to implement something Redis currently lacks. But to us
@ -45,23 +59,44 @@ Redis Manifesto
when needed. At the same time, when writing the Redis story we're trying to when needed. At the same time, when writing the Redis story we're trying to
write smaller stories that will fit in to other code. write smaller stories that will fit in to other code.
5 - We're against complexity. We believe designing systems is a fight against 6 - We're against complexity. We believe designing systems is a fight against
complexity. We'll accept to fight the complexity when it's worthwhile but complexity. We'll accept to fight the complexity when it's worthwhile but
we'll try hard to recognize when a small feature is not worth 1000s of lines we'll try hard to recognize when a small feature is not worth 1000s of lines
of code. Most of the time the best way to fight complexity is by not of code. Most of the time the best way to fight complexity is by not
creating it at all. creating it at all.
6 - Two levels of API. The Redis API has two levels: 1) a subset of the API fits 7 - Threading is not a silver bullet. Instead of making Redis threaded we
believe on the idea of an efficient (mostly) single threaded Redis core.
Multiple of such cores, that may run in the same computer or may run
in multiple computers, are abstracted away as a single big system by
higher order protocols and features: Redis Cluster and the upcoming
Redis Proxy are our main goals. A shared nothing approach is not just
much simpler (see the previous point in this document), is also optimal
in NUMA systems. In the specific case of Redis it allows for each instance
to have a more limited amount of data, making the Redis persist-by-fork
approach more sounding. In the future we may explore parallelism only for
I/O, which is the low hanging fruit: minimal complexity could provide an
improved single process experience.
8 - Two levels of API. The Redis API has two levels: 1) a subset of the API fits
naturally into a distributed version of Redis and 2) a more complex API that naturally into a distributed version of Redis and 2) a more complex API that
supports multi-key operations. Both are useful if used judiciously but supports multi-key operations. Both are useful if used judiciously but
there's no way to make the more complex multi-keys API distributed in an there's no way to make the more complex multi-keys API distributed in an
opaque way without violating our other principles. We don't want to provide opaque way without violating our other principles. We don't want to provide
the illusion of something that will work magically when actually it can't in the illusion of something that will work magically when actually it can't in
all cases. Instead we'll provide commands to quickly migrate keys from one all cases. Instead we'll provide commands to quickly migrate keys from one
instance to another to perform multi-key operations and expose the tradeoffs instance to another to perform multi-key operations and expose the
to the user. trade-offs to the user.
7 - We optimize for joy. We believe writing code is a lot of hard work, and the 9 - We optimize for joy. We believe writing code is a lot of hard work, and the
only way it can be worth is by enjoying it. When there is no longer joy in only way it can be worth is by enjoying it. When there is no longer joy in
writing code, the best thing to do is stop. To prevent this, we'll avoid writing code, the best thing to do is stop. To prevent this, we'll avoid
taking paths that will make Redis less of a joy to develop. taking paths that will make Redis less of a joy to develop.
10 - All the above points are put together in what we call opportunistic
programming: trying to get the most for the user with minimal increases
in complexity (hanging fruits). Solve 95% of the problem with 5% of the
code when it is acceptable. Avoid a fixed schedule but follow the flow of
user requests, inspiration, Redis internal readiness for certain features
(sometimes many past changes reach a critical point making a previously
complex feature very easy to obtain).