Decentralized Web

xholonWorkbook.xml

<?xml version="1.0" encoding="UTF-8"?>
<!--Xholon Workbook http://www.primordion.com/Xholon/gwt/ MIT License, Copyright (C) Ken Webb, Sat Oct 13 2018 13:31:32 GMT-0400 (Eastern Daylight Time)-->
<XholonWorkbook>

<Notes><![CDATA[
Xholon
------
Title: Decentralized Web
Description: 
Url: http://www.primordion.com/Xholon/gwt/
InternalName: 95987a164673a672547ff391e1084934
Keywords: 

My Notes
--------
September 9, 2018
DWeb

http://127.0.0.1:8888/XholonDWeb.html?app=Decentralized+Web&src=lstr&gui=clsc

References
----------
(1) https://www.theguardian.com/technology/2018/sep/08/decentralisation-next-big-step-for-the-world-wide-web-dweb-data-internet-censorship-brewster-kahle
    Decentralisation: the next big step for the world wide web
    The decentralised web, or DWeb, could be a chance to take control of our data back from the big tech firms. So how does it work and when will it be here?

(2) https://decentralizedweb.net/
    The Internet Archive's Decentralized Web Summit is dedicated to creating the web we want [and the web we deserve].
    We are convening those who want to build a web that...
    Remembers. Forgets. That’s safe. That cares about people. That’s a marketplace. That’s a public square. That learns.
    That’s magical. That’s fun. A web with many winners. A web that’s locked open for good.

(3) https://archive.org/

(4) https://blockstack.org/
    The easiest way to start building decentralized blockchain apps

(5) http://brewster.kahle.org/
    Brewster Kahle's Blog

(6) https://protocol.ai/
    Protocol Labs
    We believe the internet has become humanity's most important technology.
    We build protocols, systems, and tools to improve how it works.
    Today, we are focused on how we store, locate, and move information.

(7) https://protocol.ai/projects/
    IPFS is a new protocol to decentralize the web. IPFS enables the creation of completely decentralized and distributed applications, using content addressing and digital signatures.
    IPFS makes the web faster, safer, and more open.
    
    Filecoin is a cryptocurrency powered storage network. Miners earn Filecoin by providing open hard-drive space to the network, while users spend Filecoin to store their files encrypted in the decentralized network.
    
    libp2p is a modular networking stack. libp2p brings together a variety of transports and peer-to-peer protocols, making it easy for developers to build large, robust p2p networks.
    
    IPLD is the data model for the Decentralized Web. It connects all data through cryptographic hashes, and makes it easy to traverse and link to.
    
    The Multiformats Project is a collection of protocols to future-proof systems, today. Self-describing formats make your systems interoperable and upgradable.

(8) https://libp2p.io/
    A modular network stack.
    Run your network applications free from runtime and address services, independently of their location.

(9) https://github.com/libp2p

(10) https://github.com/libp2p/js-libp2p

(11) https://github.com/libp2p/js-libp2p-webrtc-star
    ibp2p WebRTC transport that includes a discovery mechanism provided by the signalling-star
    libp2p-webrtc-star is one of the WebRTC transports available for libp2p.
    libp2p-webrtc-star incorporates both a transport and a discovery service that is facilitated by the signalling server, also part of this module.

(12) https://filecoin.io/
    A MASSIVE AMOUNT OF STORAGE SITS UNUSED IN DATA CENTERS AND HARD DRIVES AROUND THE WORLD.

(13) https://openbazaar.org/
    OpenBazaar (a decentralised marketplace)

(14) https://www.graphitedocs.com/
    Graphite Docs (a Google documents alternative)
    All your work, files, and messages—encrypted, shareable, decentralized

(15) https://www.textile.photos/
    Textile Photos (an Instagram-like alternative for storing, managing, and sharing photos on the DWeb)

(16) https://matrix.org/blog/home/
    Matrix (which provides Slack and WhatsApp alternatives)

(17) https://d.tube/
    DTube (a YouTube alternative)

Social network alternatives include Akasha and Diaspora. There is also a new independent experimental browser for exploring the peer-to-peer web called Beaker Browser.
(18) https://akasha.world/

(19) https://diasporafoundation.org/

(20) https://beakerbrowser.com/
    A browser for the next-generation Web
    Beaker is an experimental browser for exploring and building the peer-to-peer Web.

(21) https://hacks.mozilla.org/category/dweb/
   ) https://hacks.mozilla.org/category/p2p-web/
    lists of articles

(22) https://hacks.mozilla.org/2017/06/introducing-humblenet-a-cross-platform-networking-library-that-works-in-the-browser/
    Introducing HumbleNet: a cross-platform networking library that works in the browser
    By Edward Rudd, Andre Vrignaud
    Posted on June 29, 2017
    HumbleNet provides an easy-to-use API wrapper around WebRTC that enables real-time UDP connections between clients using the WebRTC data channel.
    
    HumbleNet is a simple C API that wraps WebRTC and WebSockets and hides away all the platform differences between browser and non-browser platforms.
    The current version of the library exposes a simple peer-to-peer API that allows for basic peer discovery and the ability to easily send data (via WebRTC) to other peers.
    In this manner, you can build a game that runs on Linux, macOS, and Windows, while using any web browser — and they can all communicate in real-time via WebRTC.
    This means no central server (except for peer discovery) is needed to handle network traffic for the game.
    The peers can talk directly to each other.

(23) https://humblenet.github.io/
    HumbleNet - a cross-platform networking library that works in the browser

(24) https://try-dat.com/

(25) https://webtorrent.io/
    WebTorrent is a streaming torrent client for the web browser and the desktop.
    WebTorrent is written completely in JavaScript – the language of the web – and uses WebRTC for peer-to-peer transport whenever possible.
    No browser plugins, extensions, or installation is required to use WebTorrent in your browser.

(26) https://webtorrent.io/intro
    To start using WebTorrent, simply include the webtorrent.min.js script on your page.

(26) https://instant.io/
    Streaming file transfer over WebTorrent (torrents on the web)

(27) https://durian.blender.org/
    Sintel movie

(28) https://file.pizza/
    File.pizza - Free peer-to-peer file transfers in your browser (source code)

(29) https://filemap.xyz/
    LocalFiles - Share files by pinning them to geographic locations

(30) https://github.com/chr15m/bugout
    Bugout - build and run back-end web services in a browser tab.

(31) https://github.com/webtorrent/webtorrent
    Streaming torrent client for the web

(32) https://github.com/elendirx/web2web
    P2P web powered by torrents and blockchain.

(33) https://cheff.cuadranteweb.com/
    Cheff - Share food recipes between your devices. source code

(34) https://hacks.mozilla.org/2018/08/dweb-building-cooperation-and-trust-into-the-web-with-ipfs/
    Dweb: Building Cooperation and Trust into the Web with IPFS
    By Kyle Drake, Marcin Rataj
    Posted on August 29, 2018
    IPFS – The InterPlanetary File System

(35) https://github.com/ipfs/js-ipfs
    IPFS implementation in JavaScript https://ipfs.io

(36) https://ipld.io/
    InterPlanetary Linked Data
    IPLD is the data model of the content-addressable web.
    It allows us to treat all hash-linked data structures as subsets of a unified information space,
    unifying all data models that link data with hashes as instances of IPLD.
    
    WHY IPLD?
	A data model for interoperable protocols.
    Content addressing through hashes has become a widely-used means of connecting data in distributed systems,
    from the blockchains that run your favorite cryptocurrencies, to the commits that back your code, to the web’s content at large.
    Yet, whilst all of these tools rely on some common primitives, their specific underlying data structures are not interoperable.
    Enter IPLD: IPLD is a single namespace for all hash-inspired protocols.
    Through IPLD, links can be traversed across protocols, allowing you explore data regardless of the underlying protocol.

(37) https://github.com/multiformats

(38) https://multiformats.io/

(39) https://github.com/Agoric/SES
    Secure EcmaScript
    Secure EcmaScript (SES) is a frozen environment for running EcmaScript (Javascript) 'strict' mode programs with no ambient authority in their global scope,
    and with the addition of a safe two-argument evaluator (SES.confine(code, endowments)).
    By freezing everything accessible from the global scope, it removes programs abilities to interfere with each other, and thus enables isolated evaluation of arbitrary code.
    Still under development: do not use for production systems yet, there are known security holes that need to be closed.

(40) https://en.wikipedia.org/wiki/Solid_(web_decentralization_project)
    Solid (Social Linked Data)[1] is a web decentralization project led by Tim Berners-Lee, the inventor of the World Wide Web.
    The project is run from the Massachusetts Institute of Technology.
    The project "aims to radically change the way Web applications work today, resulting in true data ownership as well as improved privacy"
    by developing a platform for linked data applications that are completely decentralized and fully under users' control rather than controlled by other entities.
(41) https://github.com/solid/solid
(42) https://solid.mit.edu/
(43) http://ds.qcri.org/publications/2016-mansour-www.pdf

(44) http://www.subsect.net/
    a platform which allows individuals to have a persistent dynamic web presense hosted on their own internet connected mobile device

(45) https://infocentral.org/
    InfoCentral is..
    An Architectural Approach to Decentralization
    InfoCentral's minimalist, graph-oriented Persistent Data Model provides an ideal foundation to promote collaboration and cross-pollination among decentralized internet technology projects.

(46) https://www.urbit.org/
    A personal server is a virtual computer which stores your data, runs your apps, and manages your connected devices.
    Urbit is a secure peer-to-peer network of personal servers, built on a clean-slate system software stack.

(47) https://zeronet.io/
    Open, free and uncensorable websites, using Bitcoin cryptography and BitTorrent network

(48) https://www.boxcryptor.com/en/
    Boxcryptor | Security for your Cloud
    End-to-end encryption “Made in Germany” for Dropbox & Co.

(49) https://whisp.ly/en
    encrypted file transfer

webrtc
------

(101) https://github.com/webrtcHacks/adapter
    Shim to insulate apps from spec changes and prefix differences.

(102) https://github.com/webrtc/samples
    WebRTC Web demos and samples
    Most of the samples use adapter.js, a shim to insulate apps from spec changes and prefix differences.

(103) https://webrtc.github.io/samples/

(104) https://developer.mozilla.org/en-US/docs/Web/API/WebRTC_API

(105) https://github.com/feross/simple-peer
    Simple WebRTC video/voice and data channels

(106) https://www.npmjs.com/search?q=webrtc

(107) https://webrtc.googlesource.com/src

(108) https://peerjs.com/
   )  https://github.com/peers

(109) search: webrtc game

(110) https://badootech.badoo.com/webrtc-making-a-peer-to-peer-game-using-javascript-f7123aed769e

(111) https://stackoverflow.com/questions/32171367/webrtc-on-local-network

(112) http://blog.brkho.com/2017/03/15/dive-into-client-server-web-games-webrtc/

(113) https://webrtchacks.com/
   )  https://webrtchacks.com/datachannel-multiplayer-game/

]]></Notes> 

<_-.XholonClass>
  <PhysicalSystem/>
  
  <WebTorrent superClass="Attribute_String"/>
  
  <Ipfs/>
  
</_-.XholonClass>

<xholonClassDetails>
  
</xholonClassDetails>

<PhysicalSystem>
  
  <!-- Sintel, a free, Creative Commons movie  .en.srt  .mp4 -->
  <WebTorrent fileType=".mp4" enabled="false"><![CDATA[
magnet:?xt=urn:btih:08ada5a7a6183aae1e09d831df6748d566095a10&dn=Sintel&tr=udp%3A%2F%2Fexplodie.org%3A6969&tr=udp%3A%2F%2Ftracker.coppersurfer.tk%3A6969&tr=udp%3A%2F%2Ftracker.empire-js.us%3A1337&tr=udp%3A%2F%2Ftracker.leechers-paradise.org%3A6969&tr=udp%3A%2F%2Ftracker.opentrackr.org%3A1337&tr=wss%3A%2F%2Ftracker.btorrent.xyz&tr=wss%3A%2F%2Ftracker.fastcast.nz&tr=wss%3A%2F%2Ftracker.openwebtorrent.com&ws=https%3A%2F%2Fwebtorrent.io%2Ftorrents%2F&xs=https%3A%2F%2Fwebtorrent.io%2Ftorrents%2Fsintel.torrent
]]></WebTorrent>
  
  <Ipfs enabled="true"/>
  
</PhysicalSystem>

<WebTorrentbehavior implName="org.primordion.xholon.base.Behavior_gwtjs"><![CDATA[
var me, client, beh = {
postConfigure: function() {
  me = this.cnode.parent()
  //$wnd.xh.require("webtorrent.min.js") // NO this does not work
  client = null
  if (me.enabled == "true") {
    this.testWebtorrent()
  }
},
act: function() {
  //me.println("testing")
},
testWebtorrent: function() {
  if ($wnd.WebTorrent && !client) {
    client = new $wnd.WebTorrent()
    me.println("OK WebTorrentbehavior")
    
    var torrentId = me.text().trim()
    
    client.add(torrentId, function (torrent) {
      // Torrents can contain many files. Let's use the .mp4 file
      var file = torrent.files.find(function (file) {
        me.println(file.name)
        return file.name.endsWith(me.fileType)
      })
      
      // Display the file by adding it to the DOM.
      // Supports video, audio, image files, and more!
      file.appendTo('#xhimg')
    })
  }
}
}
//# sourceURL=WebTorrentbehavior.js
]]></WebTorrentbehavior>

<Ipfsbehavior implName="org.primordion.xholon.base.Behavior_gwtjs"><![CDATA[
var me, ipfs, beh = {
postConfigure: function() {
  me = this.cnode.parent()
  ipfs = null
  if (me.enabled == "true") {
    this.testIpfs()
  }
},
act: function() {
  //me.println("testing")
},
testIpfs: function() {
  if ($wnd.Ipfs && !ipfs) {
    ipfs = new $wnd.Ipfs()
    me.println("OK Ipfsbehavior")
    
    const data = 'Hello from IPFS, Licorice Cat!'
    // Once the ipfs node is ready
    ipfs.once('ready', async () => {
      $wnd.console.log('IPFS node is ready! Current version: ' + (await ipfs.id()).agentVersion)
      
      // convert your data to a Buffer and add it to IPFS
      $wnd.console.log('Data to be published: ' + data)
      const files = await ipfs.files.add(ipfs.types.Buffer.from(data))
      
      // 'hash', known as CID, is a string uniquely addressing the data
      // and can be used to get it again. 'files' is an array because
      // 'add' supports multiple additions, but we only added one entry
      const cid  = files[0].hash
      $wnd.console.log('Published under CID: ' + cid)
      
      // read data back from IPFS: CID is the only identifier you need!
      const dataFromIpfs = await ipfs.files.cat(cid)
      $wnd.console.log('Read back from IPFS: ' + String(dataFromIpfs))
      
      // Compatibility layer: HTTP gateway
      $wnd.console.log('Bonus: open at one of public HTTP gateways: https://ipfs.io/ipfs/' + cid)
      // https://ipfs.io/ipfs/QmYZt84WYF7Vyc8uZPuHrXu81RgmJ2qpoVqvtkr7Ty2wxo
    })
  } // end if
}
}
//# sourceURL=Ipfsbehavior.js
]]></Ipfsbehavior>

<SvgClient><Attribute_String roleName="svgUri"><![CDATA[data:image/svg+xml,
<svg width="50" height="10" xmlns="http://www.w3.org/2000/svg">
  <g>
    <title>WebTorrent</title>
    <rect id="PhysicalSystem/WebTorrent" fill="#98FB98" height="10" width="10" x="0" y="0"/>
  </g>
  <g>
    <title>Ipfs</title>
    <rect id="PhysicalSystem/Ipfs" fill="#FB98FB" height="10" width="10" x="20" y="0"/>
  </g>
</svg>
]]></Attribute_String><Attribute_String roleName="setup">${MODELNAME_DEFAULT},${SVGURI_DEFAULT}</Attribute_String></SvgClient>

</XholonWorkbook>