Revise project description

blog/authors.yml

@@ -5,7 +5,7 @@ sergefdrv:
   url: https://github.com/sergefdrv
   image_url: https://github.com/sergefdrv.png
   socials:
-    x: sergefdrv
-    linkedin: sergefdrv
     github: sergefdrv
     bluesky: sergefdrv.bsky.social
+    x: sergefdrv
+    linkedin: sergefdrv

docusaurus.config.js

@@ -26,14 +26,14 @@ const siteLicense = {
 /** @type {import('@docusaurus/types').Config} */
 const config = {
   title: 'Replica_IO',
-  tagline: 'Compose practical distributed replication mechanisms',
+  tagline: 'Express the essence of distributed replication and coordination',
   favicon: 'img/favicon.ico',
 
   url: 'https://replica-io.dev',
   baseUrl: '/',
 
   customFields: {
-    description: 'An open-source framework for building practical distributed replication mechanisms.',
+    description: 'An open-source project rethinking distributed replication and coordination — from first principles to a practical framework.',
     gitHubUrl: gitHubUrl,
     siteLicense: siteLicense,
     recentBlogPostsOnHomePage: 5,
@@ -80,7 +80,7 @@ const config = {
       './plugins/blog-plugin',
       {
         blogTitle: 'Replica_IO Blog',
-        blogDescription: 'Blog of the Replica_IO project - an open-source framework for building practical distributed replication mechanisms.',
+        blogDescription: 'Blog of the Replica_IO project — rethinking distributed replication and coordination from first principles to a practical framework.',
         showReadingTime: true,
         showLastUpdateTime: true,
         showLastUpdateAuthor: true,
@@ -135,7 +135,7 @@ const config = {
       metadata: [
         {
           name: 'keywords',
-          content: 'decentralization, decentralized-computing, distributed-systems, fault-tolerance, replication',
+          content: 'research, programming-model, concurrency, distributed-computing, decentralized-computing, fault-tolerance, replication, coordination, consensus, rust',
         },
       ],
       colorMode: {

src/pages/about.md

@@ -4,115 +4,132 @@ title: About
 
 # About Replica_IO
 
-Replica_IO is an open-source framework for composing practical
-distributed replication mechanisms.
+Being an independent, open-ended effort, Replica_IO is all about
+rethinking distributed and concurrent computational processes from
+first principles — discovering a most natural way to express them,
+which is perhaps the most practical path to excellent software. As
+ideas mature, they are to take shape in a minimalistic, Rust-based
+open-source framework for designing and implementing core replication
+and coordination mechanisms of decentralized, distributed systems,
+such as BFT consensus.
+
+## 🌟 Motivation
+
+The world is concurrent in nature: unless there is a causal
+dependency, things don't have to happen in a specific order. So is
+most of the modern software, which is becoming increasingly
+interconnected — it has to remain responsive while dealing with many
+interaction contexts concurrently, especially in decentralized,
+distributed systems. But concurrency is genuinely hard, perhaps not
+yet well enough understood. On the other hand, we reason and
+communicate sequentially, step by step; and early computer programs
+simply did the same. The sequential model feels so intuitive it even
+seems natural, if only it were.
+
+Concurrency may seem like a mess and the temptation to impose more
+order than is really there is hard to resist. This instinct runs deep,
+pervading how we tend to express concurrent systems in specs and code,
+even how we reason about them. But artificial ordering may ironically
+create its own mess: unnecessary constraints, hidden dependencies, and
+brittleness that weren't there to begin with. So perhaps concurrency
+itself isn't the real enemy. Could it be that we rather lack a natural
+enough way to reason about and express it?
+
+What if rethinking concurrency from first principles could reveal one?
+Not only incremental progress, but a genuinely different way of seeing
+concurrent systems. One that would call for a new framework: a set of
+well-crafted, practical tools. The insights might also open new
+perspectives on distributed coordination in general, maybe even beyond
+computing itself.
+
+## 🧭 Approach
+
+How the goal is pursued matters — shaped by values and principles.
+And this requires making deliberate choices — some of them difficult.
+The following perhaps best reflects the character of this project.
+
+**Fundamental exploration.** Driven by a desire to understand deeply,
+going to the essence of things. This means challenging what's taken
+for granted, following consequential thinking wherever it leads, and
+exploring by trying, knowing that some paths will lead nowhere.
+Uncertainty is embraced as part of the process, as breakthroughs often
+come from where they are least expected. The aim is not incremental
+improvement, but a genuinely different way of seeing.
+
+**Autonomy and conviction.** The project is mission-driven and
+unbiased, guided by what genuinely makes most sense. However, it may
+be principled and opinionated about what matters — not every decision
+needs an objective reason. Some things are simply felt before they can
+be fully articulated, which calls for trusting intuition, even if it
+seems irrational at first, when forcing rational justification ahead
+of time would only get in the way. This demands courage, especially
+when the ideas may seem strange, controversial, or sometimes even
+outright wrong to others. Conviction means pursuing what's worth doing
+even if it's hard and takes time — persisting and succeeding, not
+"failing fast".
+
+**Minimalism and flexibility.** Every assumption is questioned; every
+apparent constraint is challenged. Nothing gets in without a strong
+reason, and what doesn't earn its place is readily removed. The result
+should capture the essence — generic and composable so that good use
+cases naturally emerge.
+
+**Thoroughness and aesthetics.** Every relevant detail matters;
+consistency holds everything together. "Just works" is not enough
+— it should feel right. Elegance is valued not just as decoration but
+as a genuine design criterion (which perhaps matters even for AI). The
+right thing, once found, becomes self-evident.
+
+**Radical transparency.** Open and honest by default: commitments are
+made carefully, and bitter truths admitted rather than hidden behind
+comfortable lies. Communication is clear, with little noise.
+Contributions are welcome, though not everything may fit in.
 
 ## 🌱 Status
 
 This project is in its early stages. It's being developed entirely in
-the open from day one. So more stuff will follow. Stay tuned! 📡
-
-## 🌟 Purpose
-
-The purpose of this project is to advance computing by making highly
-reliable distributed systems more practical to implement.
-
-More and more we depend on increasingly complex computing systems.
-Therefore, we ought to make such critical systems highly reliable.
-Distributed systems are potentially much more reliable than
-centralized ones. However, anyone who tried implementing
-fault-tolerant distributed systems knows how hard it is in practice.
-
-Practical solutions should be both efficient and easy to use.
-Unfortunately, distributed systems tend to be less efficient, and they
-are notoriously complex. Often we can tolerate moderate decrease in
-efficiency, but reliability is crucial for critical systems we largely
-depend upon.
-
-Nevertheless, complex problems can have neat solutions that are not
-only efficient, but also easy to properly apply in practice.
-Discovering and developing those solutions obviously requires
-significant effort. This project is making such effort.
-
-## 🎯 Goal
-
-The goal of this project is to develop a well-supported and widely
-used state-of-the-art framework for building distributed replication
-mechanisms, thus greatly facilitating practical implementation of
-highly reliable distributed systems.
-
-Specifically, the framework should provide a carefully designed
-collection of primitives, components, tools, and guidelines for
-developing core mechanisms of fault-tolerant distributed systems, such
-as state machine replication or distributed coordination services.
-Sensibly chosen principles guide the process of designing and
-implementing generic components, such as consensus or various kinds of
-broadcast. These components get constructed out of the corresponding
-protocol logic, more simple components, and fundamental primitives,
-such as asynchronous communication or timer abstractions. Unified
-means of combination ensure great composability of the elements. Fine
-modularity together with built-in capabilities for tracing and
-controlling execution enable effective debugging, validation, and
-analysis. Powerful and convenient tools allow effectively utilizing
-those features. Clear guidelines help using the framework properly by
-explaining its features on simple, easy-to-follow examples.
-
-This framework is conceived as generic and independent from any
-specific target system or use case, embracing different flavors of
-fault-tolerance, consistency, and synchrony models, e.g. strong, weak,
-or eventual consistency under CFT, BFT, or hybrid models with strong,
-partial, or no synchrony assumption. It is particularly concerned not
-only with immediate safety guarantees, but also with ensuring rigorous
-liveness guarantees and memory bounds, as well as further features
-highly desired in practice, such as bootstrapping procedures, online
-reconfiguration, failure detection, recovery of faulty nodes, and
-the ability to recover from a massive system crash (durability).
-
-Last, but not least, it should be highly ergonomic so that developers
-enjoy playing with it while effectively solving their problems.
-
-## 🤓 Approach
-
-The approach of this project is best characterized as follows:
-
-  * _open:_ publicly available, transparent, and collaborative;
-  * _understandable:_ intuitive, well documented, and easy to use;
-  * _flexible:_ generic, modular, and easy to integrate;
-  * _holistic:_ taking into account all relevant aspects;
-  * _innovative:_ discovering and using state-of-the-art techniques;
-  * _quality-oriented:_ carefully designed, implemented, and verified;
-  * _iterative:_ starting small — growing strong, delivering value
-    regularly and persistently.
+the open from day one. Stay tuned! 📡
 
 ## 🏁 Roadmap
 
-- [ ] [M0.1: Initial Ideas](https://github.com/replica-io/replica-io/milestone/1) — exploring the state of the art and coming up with clever ideas
-- [ ] [M0.2: Core Concepts](https://github.com/replica-io/replica-io/milestone/2) — developing the rough ideas into clearly formulated concepts
-- [ ] [M0.3: PoC Implementation](https://github.com/replica-io/replica-io/milestone/3) — verifying the feasibility of the concepts in code
-- [ ] [M1: Prototype](https://github.com/replica-io/replica-io/milestone/4) — demonstrating how the final framework will look like
-- [ ] [M2: MVP](https://github.com/replica-io/replica-io/milestone/5) — unlocking some actual use cases
-- [ ] [M3: Ready for Integration](https://github.com/replica-io/replica-io/milestone/6) — releasing a version ready for integration into production
-
-## 🙏 Contributing
-
-The project's goal is quite ambitious, so your support is more than
-welcome! 🤗
-
-If you are also excited about this project, there are many ways you
-can get involved. A good start is to visit the project on
-[GitHub][github-replica-io], subscribe for notifications, check and
-participate in open issues, pull requests, discussions. Please check
-the [project board][project-board] for a better overview. You can also
-follow the project on [X (former Twitter)][x-replica-io] for
-high-level updates or jump into an interactive discussion on
-[Discord][discord-replica-io]. Video materials will be published on
-[YouTube][youtube-replica-io].
-
-Please ask questions, suggest ideas, report problems, submit changes!
+These milestones represent general levels of maturity.
+Exploration, ideation, and prototyping happen throughout;
+later milestones may evolve as the work progresses.
+
+- [ ] [M0.1: Initial Ideas](https://github.com/replica-io/replica-io/milestone/1)
+      — exploring the state of the art and forming initial ideas
+- [ ] [M0.2: Core Concepts](https://github.com/replica-io/replica-io/milestone/2)
+      — developing rough ideas into clearly formulated concepts
+- [ ] [M0.3: PoC Implementation](https://github.com/replica-io/replica-io/milestone/3)
+      — testing the feasibility of the concepts in code
+- [ ] [M1: Prototype](https://github.com/replica-io/replica-io/milestone/4)
+      — sketching all essential features, selected part fully polished
+- [ ] [M2: Early Release](https://github.com/replica-io/replica-io/milestone/5)
+      — enabling some actual, though limited, use cases
+- [ ] [M3: Production Readiness](https://github.com/replica-io/replica-io/milestone/6)
+      — version ready for production use
+
+## 🤝 Get Involved
+
+A few ways to follow along and get involved:
+
+- [Blog](/blog) — the project's thinking, written up
+- [YouTube][youtube-replica-io] — talks and video materials
+- [GitHub][github-replica-io] — source code, issues, pull requests,
+  and discussions; the [project board][project-board] provides a
+  higher-level overview
+- [Discord][discord-replica-io] — interactive discussion
+- [X][x-replica-io] and [Bluesky][bsky-replica-io] — short updates
+  and highlights
+
+GitHub [Discussions][github-discussions] and
+[Discord][discord-replica-io] are good places to chime in — and don't
+miss the [blog](/blog)!
 
 [github-replica-io]: https://github.com/replica-io/replica-io
+[github-discussions]: https://github.com/replica-io/replica-io/discussions
 [project-board]: https://github.com/orgs/replica-io/projects/1
 [x-replica-io]: https://x.com/Replica_IO
-[discord-replica-io]: https://discord.gg/CzPfN75URD
+[bsky-replica-io]: https://bsky.app/profile/replica-io.bsky.social
+[discord-replica-io]: https://discord.replica-io.dev
 [youtube-replica-io]: https://www.youtube.com/@Replica_IO
-

src/pages/index.jsx

@@ -56,67 +56,13 @@ export default function Home() {
             <p className="row">
               <p className="col col--8 col--offset-2">
                 <p>
-                  Replica_IO is about making a breakthrough in designing
-                  and implementing distributed protocols for the future of
-                  decentralized computing! 🚀
+                  This is an independent, open-ended effort to rethink distributed and concurrent computing from first principles, searching for a most natural way to express it. The emerging ideas are to take shape in a minimalistic, Rust-based open-source framework for core mechanisms of decentralized, distributed systems — such as BFT consensus.
                 </p>
                 <p>
-                  The purpose of this project is to advance computing by
-                  making highly reliable distributed systems more
-                  practical to implement. The goal is to develop a
-                  well-supported and widely used state-of-the-art
-                  framework for building distributed replication
-                  mechanisms. Specifically, the framework should provide a
-                  carefully designed collection of primitives, components,
-                  tools, and guidelines for developing core mechanisms of
-                  fault-tolerant distributed systems. Possible areas of
-                  application include blockchain, cloud computing,
-                  distributed databases, etc. Following are the key areas
-                  of focus:
+                  For more details, check out the <a href="/about">About</a> page.
                 </p>
               </p>
             </p>
-            <p className="row">
-              <p className="col col--10 col--offset-1">
-                <div className="row margin-vert--lg">
-                  <div className="col">
-                    <h3>Simplicity</h3>
-                    <p>
-                      Making protocol implementations well structured
-                      and understandable.
-                    </p>
-                  </div>
-                  <div className="col">
-                    <h3>Flexibility</h3>
-                    <p>
-                      Keeping the framework adaptable, widely
-                      applicable, and evolvable.
-                    </p>
-                  </div>
-                  <div className="col">
-                    <h3>Reliability</h3>
-                    <p>
-                      Ensuring that protocol correctness is verifiable
-                      and the implementation is resilient.
-                    </p>
-                  </div>
-                  <div className="col">
-                    <h3>Efficiency</h3>
-                    <p>
-                      Allowing for various optimizations and
-                      delivering good performance.
-                    </p>
-                  </div>
-                  <div className="col">
-                    <h3>Maintainability</h3>
-                    <p>
-                      Catering for maintenance needs and providing
-                      great diagnostic mechanisms.
-                    </p>
-                  </div>
-                </div>
-              </p>
-            </p>
             <h2 className="text--center">
               Sponsors
             </h2>