# Neighbourhoods
Neighbourhoods is a design philosophy for Holochain hApps. As a new unit of social cohesion online, Neighbourhoods aim to evolve "platforms" and "DAOs", pointing the way forward for group organizing on the distributed web.
Neighbourhoods are formed around the Social Sensemaker, which we are building to help communities engage with each other, socially and commercially, while preserving what's unique about their group culture.
We hope this interoperable sense-making and reputation layer for the distributed web will unlock new forms of social coordination at scale.
**What?**
Community activators choose modules and widget-sized code blocks from the tokenized Neighbourhoods Bazaar. They can stitch these together, alongside the social sensemaker, to create micro-networks called neighbourhoods.
**How?**
A language for reaction and reputation data and computation enables groups to operate through the ratings and measurements of their choosing. That means that neighbourhoods can design for discovery, engagement, and interaction based on what matters to them and what's appropriate for their context.
The social sensemaker then enables different Neighbourhoods to get information from each other on their own terms. Neighborhoods are not meant to be mega-platforms -- they work to make behavior meaningful in small group contexts and portable outside of them.
Imagine being able to port your Uber or Lyft rating and comments into your new Couchsurfing account - The cultural premises of these groups are different, but if a trusted Couchsurfing node says "hey, that info can still help us get to know a person faster", then you don't have to start from scratch building a reputation on Couchsurfing!
> This is what we call "memetic mediation" across groups, and it doesn't require consensus or any other universal governance framework!
**Why?**
The distributed web needs a portable social layer that enables mass coordination rather than silos. When there's no central location for interpersonal data, helping people move from community to community with their reputation in tow is no small feat. It requires a language for expressing and understanding context-sensitive, interpersonal information and a cryptographic, p2p means of establishing data provenance.
Cultural lenses, the way we determine which behaviors matter for different purposes, define Neighborhoods. Social data that explain behavior in its original context creates coherence at the group level and greater individual autonomy - users can translate the reputation they earn from one Neighbourhood to another.
*Building bridges **between** Neighbourhoods is what makes this framework really useful.* We call these "memetic bridges".
# Powered by the Social Sensemaker
## What is the Social Sensemaker?
The distributed web relies on distributed social intelligence for discovery, engagement, recommendations.
> *The Social Sensemaker mediates between different groups' articulation of member behavior, credibility, and style.*
The Social Sensemaker aims to add context to personal data, countering the automatically generated, generically-cultivated data of today's web with human-verification that one context is relevant for another.
> It enables actions in one community find validation and resonance in countless other groups, reducing the costs of entering and exiting groups and connecting your past actions to your present credibility.
This increases individuals' capacity to move about the distributed web and enables cross-network cooperation through groups negotiation of *meaning* (rather than through the sheer coincidence of using the same corporate platform or tech stack).
## How does it work?
Think of the Social Sensemaker as a 'Cultural Computer' held by each person in a Neighbourhood. It enables:
1. **Easy articulation of culture:** Communities can create their own systems for meaning-making at the group level, to guide their interactions. The tools you use don't make assumptions about your culture (unlike the current social web).
2. **Cross-membrane coherence:** Well-defined 'Social Data Types' make it possible to make sense of data shared across contexts
3. **Efficient, contextual computations:** Computation on social data occurs locally and propagates through any given neighbourhood. Using Holochain's native validation rules, neighbourhoods are perfectly suited to drive computation efficiency within distributed environments.
{% content-ref url="/pages/-Mcl7dzQzZ2SkubWFebj" %}
[Architecture: The Cultural Computer](/powered-by-the-reputation-interchange/reputation-domain-specific-language-dsl)
{% endcontent-ref %}
# Architecture: Overview
This page describes the pieces that make up the Reputation Interchange.
## Sensemaker Composition
The Sensemaker uses a bespoke [rep language](https://app.gitbook.com/@sacred-capital/s/neighbourhoods/~/drafts/-MfhsFrpLGNS1vB1TzGC/powered-by-the-reputation-interchange/reputation-dsl) made to capture most or all of the changes to social system design and metrics a neighbourhood needs.
The Sensemaker is composed of:
* A core Holochain DNA which performs calculations, which we call the **Cultural Computer**
* **Social datatypes** as plugins
* By placing a social data interpreter into the DNA of the social sensemaker, it enables reading and modifying on the basis of DHT entries rather than hApp DNAs.
* **Score computations** as outputs ([TrustNet](https://github.com/trustgraph/trustgraph) "Trust Atom" compatible)
* This social data is stored in iterable, wrapped Rust data structures in isolated per-datum Holochain hApp [DNA](https://developer.holochain.org/glossary/#dna)s.
* Every computed score is an attributable, peer-verifiable and independently shareable artifact.
* Outputs are also pluggable as inputs, enabling more complex calculations
* **Cultural registries** that hold shared perspectives (neighbourhoods)
* **Neighbourhoods Access Membranes** that facilitate entry/exit from NHs
* **Memetic bridges** that link one Neighbourhood to another
## Architecture Diagrams - How to Read Them?
The solid lines indicate the creation of new data; i.e. dataflow paths where an agent is directly responsible for them & the thing is attributable to them.
The dashed lines indicate data flow between agents; i.e. the information has already been created and finalised elsewhere, but there is an implicit "dance of consent" where something external is being ingested into the local agent's personal environment.
The colored lines marked with a question mark indicate queries into the makeup of a neighbourhood.
The background of each agent indicates shared belonging to the corresponding neighbourhood.
# Architecture: The Cultural Computer
This page shows how the Social Sensemaker does cultural computations at the agent and p2p level.
Using the Social Sensemaker involves making sense of Social Data through "cultural computation" that analyzes it. Sharing this data and calculated Scores evolves into what we call a neighbourhood. It's easiest to understand the Sensemakere by looking at how it works on one and then two computers.
## Cultural Computer
Social data can be sourced from traditional web services or dWeb apps. Scores hold the results of these computations, while tying them to the sources of the raw social data with full provenance. This also makes auditing possible.
Scores can be fed back into the cultural computer to chain, stack, and complexify insights.
## Shared Cultural Computation
Two people can share and cross-verify calculated scores. Context is preserved by including metadata about the computation and its raw data sources.
# Neighbourhoods: Shared Perspectives
This page shows multiple people coming together to share cultural computations that comprise a Neighbourhood
## Registries of shared computations
Cultural computations and scores can also be placed in a cultural registry, which technically defines a Neighbourhood as a shared perspective in a network space. By sharing these computations and insights with each other, multiple people in a NH can build a shared context.
The coherence of a neighbourhood comes from inter-subjective scores. No problem if individual access to social data is varied -- people outside the network are able to see this nuance and come to their own conclusions (easing entrance/exit dynamics).
##
# Architecture: Cross-Membrane Sharing
This page shows how people can share nuanced calculations within and across neighbourhoods to make sense of affiliations, grow networks, and move between communities with social data in tow.
## Memetic bridges to other neighbourhoods
Neighbourhoods may also place "memetic bridges" in this registry - these are computers trusted by the neighbourhood to provide scores to outside parties (thereby representing the NH).
Outside parties may use this info to request verification of existing score data or to request new cultural computations (deeper insight) about the neighbourhood.
## Porting Context into a new neighbourhood
When Memetic Bridges are members of adjacent neighbourhoods, they can validate that agents joining a network space are supplying honest social data from the remote network. A condition for entry into a neighbourhood may include providing social data proving good standing elsewhere *and* validation by enough Memetic Bridges.
Through memetic bridges, agents can carry their prior, relevant contexts into a new Neighbourhood. Events in one Neighbourhood can ripple, contextually, across membranes. By porting context-bound personal data, prospective NH members don't start at square one; their activity in other groups can be easily understood and verified.
## Bridge-to-Bridge Requests for Validation
When Memetic Bridges have no visibility into the neighbourhoods that a joining agent has participated in, they can validate the provided data by requesting scores from the Memetic Bridges of those neighbourhoods. More Memetic Bridges in the foreign neighbourhood leads to greater trust in the results.
Since full attribution is preserved, any duplicated requests for Rep Scores get merged together automatically, lowering computational overhead.
# Peer Verification + Social Sensemaking
Guiding principles of Neighbourhoods are to bend the algorithmic cultures that we're all a part toward transparency, reduction of information asymmetries, and using collected data to support individual and collective autonomy.
But how does this happen in practice?
**Peer verification** is crucial, given the high impact of reputation data on individuals and communities. The Social Sensemaker facilitates "peer verification" at many socially-relevant junctures:
* asking the original creator of a score to re-compute it
* asking other agents with visibility into the Neighbourhood(s) to execute the same computation
* comparing computation results of many actors' subjective viewpoints in order to reason about a shared truth in a nuanced way
* verifying computations made by others using one's own visibility into a Neighbourhood
*We're focusing on peer verification to be able to include capabilities for individual computations on Neighbourhood-level data, and individual-level composability of different Neighbourhoods' cultural perspectives.*
# Community Activators
Community activators seek technical tools to promote group coordination, resource sharing, and advancement of common interests in communities.
*Community activators* *are the real creators of Neighbourhoods. Whether a single leader or a DAO-like group acting in concert, community activators create sets of generic tools to pair with intentional design of reputation and culture. Community activators and whole Neighbourhoods benefit from data portability across the distributed web by deciding to bridge to other Neighbourhoods.*
**Is the Neighborhoods framework for you?**
* [ ] We want to enable net-connected community interaction
* [ ] We want to avoid supporting big tech by experimenting with distributed systems
* [ ] We want to use lightweight, easy to use tools
* [ ] We want to be able to coordinate activity without operating as a business and without being confined to using money or voluntarism as incentives
* [ ] We want the community to relate, engage with, and discover each other on the basis of the culture we share, rather than the culture of a business imposing its agenda on us.
**Using Neighborhoods, Community Activators can…**
* explore and contribute to libraries containing useful ways to calculate member reputation scores.
* localize sense-making of members' actions in the communities in which these happen.
* build bridges to give and receive meaningful social data to other Neighbourhoods and online communities that members take part in and/or trust.
* assure members that they can contest or revoke data pertaining to their own actions, and promote other rights relating to the trustworthiness of personal and interpersonal data
# Developers
Developers create small, pluggable Holochain-based modules for use across various Neighbourhoods.
*Neighbourhoods presents a pathway for developers to experiment with Holochain in a meaningful way. By building general-use tools and placing them in the Neighbourhoods Bazaar, you help spread patterns of distributed computing to early adopter communities of all sorts.*
**Is the Neighbourhoods framework for you?**
* [ ] I want to experiment with leading edge, decentralized software without needing to start my own company or join someone else’s.
* [ ] I want the experience of building slim stacks rather than brittle, monolithic ones.
* [ ] I want to build tiny, super useful widgets that can be plugged into suites, bundled together by and for the communities that actually use them.
* [ ] I want to promote network cohesion over forking by participating in a framework that generates value when groups using modules of code bridge with other groups, creating meta-networks.
**Using Neighborhoods Developers can…**
* incorporate and send out social data between neighbourhoods, provided there is sufficient will and trust between them.
* take advantage of Holochain's open source libraries
* contribute to the NH Bazaar and earn credits for modules that get used by neighbourhoods.
# Neighbourhoods Bazaar
A neighbourhood of commercial exchange and social fabric, geared toward sustainable open-source development of applets
Neighbourhoods rely on 'generic software tools' for interactions, discoveries and engagement. Such modules are made available through the bazaar. *They are registered in our lobby, matched with social data types, and connected to Neighbourhoods wallets.*
The Social Sensemaker is at the center of the bazaar, making applets configurable yet interoperable -- that's what makes this not just any other app marketplace, but one for Neighbourhoods!
### Connecting Community Activators with Developers
These applets are small, modular, and useful. Think a chess game, seed-sharing, or meme-sharing tool.
*They do only and exactly these functions, leaving community activators and stakeholders the freedom to choose everything else!*
Developers leverage the modular nature of Holochain to generate applets that are compliant with the Social Sensemaker, which means social data that is generated within them is portable across membranes.
Community activators can use a codeless tool to select and bundle widgets, and configure their cultural lens based on their communities' activities.
Applets and components in the bazaar have unique hashes so that developer contributions can be tracked across their uses in particular Neighbourhoods. Applet developers are then paid by neighbourhoods for using modules.
## $NHT
$NHT is a currency used in the marketplace to pay developers, which means all issued credits correspond to actual or eventual modules made by developers. It is exchangeable for Neighbourhoods tokens ($NHT) which serve as on- and off-ramps to crypto markets.
Read more about $NHT's function in the Bazaar [here](https://whitepaper.neighbourhoods.network/white-paper-v.1/overview-of-the-neighbourhoods-ecosystem/neighbourhoods-tokens-usdnht).
# Why?
## Network Effects for Social Data, not for Platform Monopolies
The distributed web, as in protocols like Holochain, enable greater user autonomy and control over data. The things that client-server web models are known for, like algorithmic discovery, driving tons of engagement, and matching people and goods all over the world, remain challenges for technologists and communities.
> *Neighbourhoods delivers the benefits of network effects to individuals and communities instead of platforms.*
The success of the distributed web depends on its ability to do great things that the siloed, corporate web can't. Network science shows us that trust builds through transitive associations. So, the more vast the environment for meaningful reputation data to be carried across group contexts, the more freedom of interaction and overall utility there is on the distributed web.
Enabling a plurality of reputation systems also helps avoid centralized control and limits the harms individual reputation systems can impose on individuals.
> *Building bridges between Neighbourhoods is what it's all about.*
# Roadmap 2023
This is a full description of items in our roadmap for 2023. See our site homepage for a shorter, snappier version.
## Epic: Toolkit 0.0.1
An early version of our toolkit to scaffold your neighbourhood, demonstrating how to set up distributed, online communities with social intelligence features.
#### Toolkit 0.0.1: Sensemaker\_lite
Implementation of a Holochain app that enables groups to add extra metadata on any entry from any other hApp DNA, store, and process that metadata into useful insights via community-defined processes.
#### **Toolkit 0.0.1: NH Launcher - 'We' Fork**
A forked version of the 'We' hApp, serving as an entry point where applets are initially selected for use within a neighbourhood.
#### **Toolkit 0.0.1: Open standards for NH-compatible applets**
Documentation of standards enabling hApps to handle the social data ontology of the sensemaker-lite, plus an applet scaffolding tool.
*These standards reflect different degrees of NH compatibility of hApps:*
Low - Not dependent on the SenseMaker; all hApps can be loaded into the NH Launcher interface, scanned for [ResourceTypes](https://faq.neighbourhoods.network/our-terminology#resource) which are then imported. From here, [Dimensions](https://faq.neighbourhoods.network/our-terminology#objective-dimension), [Methods](https://faq.neighbourhoods.network/our-terminology#method), and [CulturalContexts](https://faq.neighbourhoods.network/our-terminology#cultural-context) can be created *by hand* to enable additional sensemaking capacities (e.g. adding ratings).
Medium - hApps customized and prepared for NH integration; Once such an applet is selected into a neighbourhood, it comes pre-packed with [ResourceTypes](https://faq.neighbourhoods.network/our-terminology#resource), [Dimensions](https://faq.neighbourhoods.network/our-terminology#subjective-dimension), [Methods](https://faq.neighbourhoods.network/our-terminology#method) and [CulturalContexts](https://faq.neighbourhoods.network/our-terminology#cultural-context), and the hApp UI allows [assessments](https://faq.neighbourhoods.network/our-terminology#assessment) using the Sensemaker and will have custom UI elements displaying data from the Sensemaker.
High - Everything above, plus the capacity to adapt the hApp UI automatically upon changing [Dimensions](https://faq.neighbourhoods.network/our-terminology#objective-dimension),[ Methods](https://faq.neighbourhoods.network/our-terminology#method) and [Cultural Contexts](https://faq.neighbourhoods.network/our-terminology#cultural-context). This enables fine-tuned control over how that neighbourhood wants to operate\*
#### **Toolkit 0.0.1: Sample Applets**
Demonstration of, and support for, applets using our template config files.
#### **Toolkit 0.0.1: Community Activation Wizard**
The Community Activation Wizard places cultural choices (e.g. resources, dimensions, and methods), into a configuration file that is used to compile into a neighbourhood. Community activators arrange the flow of resources, contexts, agents, modes of sense-making, and scoring computations.
#### **Toolkit 0.0.1: Sensemaker Dashboard**
Stakeholders of any given neighbourhood must be able to fully engage in their social contexts. For example, they may adjust and respond to data sharing requests from other neighbourhoods or alter how they compute scores. They may also browse and add additional hApp modules via early marketplace functionality.
## Epic: Ecosystem Development
Participatory events supporting the growth of the Neighbourhoods ecosystem.
#### **Applet Fest**
Series of online and in-person events demonstrating the NH framework and offering open standards, resulting in additional development of 'critical applet suite' for intial marketplace deployment.
#### **Cultural Hackathon**
Local events with community groups looking to use Neighbourhoods to develop specific cultural styles in their remote coordination.
## Epic: Sensemaker 0.0.2 computational complexity and digital identity
Buildout of the [Sensemaker](https://neighbourhoods.network/social-sensemaker/), including digital identity and agent-related features.
#### **Integration of hardcoded computations (Sensemaker 0.0.2)**
Additional capabilities built in to the Sensemaker, enabling more complex social intelligence:
* Count number of assessments
* Sum values of all assesments
* Ratio (count / sum)
* Mean value
* Median value
* String literal that has the most occurances
* Use only one dimension as input, and provide a seperation computation for result validation (i.e. minimum number of assessments)
#### **Agent roles and capabilities (Sensemaker 0.0.2)**
Intermediary, key forwarding steps enabling basic use of roles and capabilities prior to the planned integration of Holochain's 'Deepkey' system for digital identity.
#### **Integration of Deepkey, profiles, and personas**
Intra- and cross-neighbourhood use agent assessments and reputation via leaderboards, badges, and 'social CVs'
## Epic: Neighbourhoods' Bazaar
Prototyping and early releases of the Neighbourhoods bazaar, which connects applet developers and communities.
#### **Bazaar assumptions and actor behavior modeling**
Specification and modelling of in-bazaar accounting, solicitation and use of external investment, elements of community/dev relationships, etc.
#### **Neighbourhoods' Neighbourhood for community activators with bazaar features**
Bazaar prototype that rates, assesses, and tracks usage of applets and integrates native accounting features.
\*Not included in Toolkit 0.0.1
## ARCHIVE: Roadmap 2022
This table depicts our [2022 Roadmap](https://neighbourhoods.network). The visible and technical aspects of the project roll out concurrently, with the first items in the table released earliest.
| Visible | Technical |
| ---------------------------------------- | ----------------------------------------------------------------------------------------------------------------- |
| | Reputation Language |
| NHT Community Offering | Rep\_lang Playground |
| Meme Share Prototype (MVP 1.0) | hApp module <> Rep\_interchange plug-in architecture
Rep data type converter (bridging 1.0)
|
| Open standards for NH-compatible modules | Reputation Portability (in MVP 2.0) |
| Reputation Wallet & Profile | TBD |
| Community Activator Bootstrapping Wizard | Testing Transaction Settling in $NHT |
| NH Governance Dashboard | TBD |
| Hackathons for Reputation Design | |
## **Visible**
**NHT Community Offering**
Our Community Offering of $NHT ran from mid-November to mid-December 2021. During this time we doubled our target! Read more about the Offering [here](https://faq.neighbourhoods.network/).
**Meme Share Prototype (MVP 1.0)**
“MVP” demonstration of reputation dynamism and its effects. This module stores images as Holochain entries, associating them with reputation types (e.g. likes, claps), applying scoring computations, and swapping between choices of scoring computation to apply.
**Open standards for NH-compatible modules**
Documentation of standards for hApp modules that handle reputation data compatible with rep\_lang and the reputation interchange.
**Reputation Wallet & Profile**
Members of neighbourhoods have an accessible means of visualizing reputation for the purpose of sharing it beyond its context of origin.
**Community Activator Bootstrapping Wizard**
Neighourhoods bootstrapping wizard from which available modules, reputation data types, and entry rules are indexed and selected. Browsing and selecting modules within this wizard are core functions of the NH low code marketplace.
**NH Governance Dashboard**
Stakeholders of any given neighbourhood must be able to modify their social space. For example, they may adjust and respond to reputation data sharing requests from other neighbourhoods or alter how they compute reputation scores. They may also browse and add additional hApp modules via early marketplace functionality.
**Hackathon for Reputation Design**
Hackathons will be supported by the team, creating opportunities for early adopters to add designs that reflect their needs to the emerging set of reputation data types created internally.
## Technical
**Reputation Language**
`rep_lang` is an interpreter for a lambda calculus-based, simply typed language. Written in Rust, it was developed in-house, to be used on reputation data. `rep_lang` is the computational fabric of the Reputation Interchange that’s unique to Neighbourhoods.
**Rep\_lang Playground**
rep\_lang playground is a testing ground for `rep_lang`. It creates functions for, and computations on, reputation data as Holochain entries to utilize Holochain’s native validation rules.
Technically, it exposes rep\_lang to the network, allowing computations which could occur only "inside `rep_lang` " to be “paused” and sent "outside `rep_lang` " (from the POV if a single interpreter) into the network, then brought back "inside `rep_lang.`
**hApp module <> Rep\_interchange plug-in architecture**
hApp modules must be able to plug into the rep\_interchange so that reputation data can be sent from hApps and converted to data the `rep_lang` and interchange can compute from, and pulled from the interchange and converted into data that hApps can use (e.g. to sort a feed).
**Rep data type conversion (bridging 1.0)**
Conversion between an interchange instance and a hApp which is able to interface with the interchange. Such hApps have their own Holochain Entry types which may be convertible into/out-of `rep_lang` data types
**Reputation Portability (in MVP 2.0)**
Passage of rep data between two interchange instances, both in cases when the same rep data type is shared across interchange instances and when different data types are shared, requiring conversion (e.g. likes into claps and vice versa).
**Testing Transaction Settling in $NHT**
We will test accounting for a set of composable hApp modules, with transactions settled in $NHT.