DEV Community: Douglas James Butner

Mystick Mandalas: Wix Studio Challenge

Douglas James Butner — Mon, 15 Jul 2024 04:59:05 +0000

What I Built

Mystic Mandalas

Fractal Art

Sacred Geometry

Cosmic Vibes.

Given the prompt to leverage Wix's set of APIs, I saw the opportunity to learn Wix Studio, and give new light some of my old art, some of which was unreleased or unavailable for sale.

Demo

Preview Site

Development Journey

Having never used Wax before the contest, I highly underestimated the power that would soon be at my fingertips.

I spent a day reading documentation, playing with the example sites, and watching Wix-related Youtube videos in the background.

Way more coding went into the 15 test projects than this one I'm submitting, which was a lot of fun and challenging as well. I was a huge user of jQuery, so I love the syntax.

Then I spent some time trying to connect Wharfkit with Wix, which I never managed to get. Deciding to wait until I was ready to launch a site, I proceeded to learn about other APIs I could use right away.

I settled on the plan to just accept wallet names and save them so I could send a NFT that would unlock a future experience. This is better, because it doesn't exclude anyone like token-gating would.

Which APIs and Libraries

I started using wax studio and created two custom data sets, one to store quotes, and one to store WAX wallets.

Wix Editor Elements($w) API was used throughout.

I used the Wix Data API to get quotes as from the database, and store WAX wallets.

Boolean to track if they've been sent their NFT, WAX wallet, and date to reward early members.

My original plan

I want to talk a little bit about my original plan, a token-gated shopping experience using the Wix eCommerce API.

A shopper can purchase a downloadable item with dollars, or get it for free if they hold a NFT from Aquarius Academy.

Why?

My most influential code project is on WAX a blockchain focused on gaming and NFTs.

Token gating is a feature that hasn't been easy for non-technical projects in the WAX blockchain community I've been developing with for several years.

Riffs + Credits
I started with a blank canvas for this contest as per the rules, and used default WIX elements for my site.

All art is my own work, with exception of AI images all by Dall-E

Here's the elements I graciously borrowed. UFO animation
https://lottiefiles.com/free-animation/ufo-404-Nj3rN5178E?from=search
Portal Animation
https://lottiefiles.com/free-animation/portal-base-KQBBfnHizR?from=search

Team

This project was built by Douglas Butner in coordination, solo member of team. @dougbutner

Thank you for this opportunity to learn Wix. I enjoy the experience of coding in Wix.

Edit: added link to preview

Get longer responses from ChatGPT / GPT-4: New Personality Demo 🦾🧠

Douglas James Butner — Thu, 30 Mar 2023 18:15:04 +0000

Here's how it works. MaMi is a one-shot personality (like DAN), which stands for [Ma]chine [Mi]nds. For each type of work you'll find a one shot set up with parameters to fill out. MaMi will ask you for approval of her work plan, and once you approve what she wants to do for you, all you have to do is press 'y' until the work is completed.

You can jump in and not approve anything at any time, and mami will re-adjust according to your requests / requirements

✨ Unlock the Power of AI and Transform Your Life! ✨

🔥 Subscribe for FREE 🚀: https://machineminds.substack.com

Ready to revolutionize your life with cutting-edge AI technology? Discover Machine Minds AI, a leading provider of AI education that helps you unlock the potential of AI to create efficient, personalized, and fulfilling technological experiences.

🌟 Explore our offerings:
🤘 All Personas, PDFs + Prompt Packs: https://godsol.gumroad.com

🤑 👨‍💻 Prompt Engineering for Programmers (PREMIUM)
Master the art of prompt engineering and elevate your projects: https://godsol.gumroad.com/l/prompt-engineering-for-programmers

🤖 About Us 🤖
Machine Minds AI is dedicated to revolutionizing the way you interact with technology. We offer top-notch education on AI prompt engineering, programming, and integration, making AI more accessible and user-friendly.

🚀 Founding
Founded by Douglas Butner (a.k.a. Gudasol), Machine Minds AI was created with a vision to help people navigate the complex world of AI technology. Today, we're proud to be a leading provider of AI education, empowering individuals, businesses, and developers to harness the power of AI.

🧠 Education
We're transparent about our top premium product, Prompt Engineering for Programmers, and many of our free resources also promote this resource. We offer a range of educational programs in AI prompt engineering, AI programming, and AI integration, helping you gain the skills needed to create extraordinary applications and customer experiences.

🌐 Social Media Presence
Stay connected with us on Twitter (@MachineMindsAI), YouTube (@MachineMinds_AI), and Substack for the latest updates on free prompt packs, professional AI training, and more!

Embark on your AI journey with Machine Minds AI today! Subscribe for FREE and explore our premium products to achieve the ultimate AI experience. 💡🚀

Tags
Machine Minds AI,AI technology,AI education,prompt engineering,programming,Douglas Butner,Gudasol,artificial intelligence,accessible AI education,chatgpt,chat gpt,chatgpt examples,chatgpt explained,openai,productivity,ai,prompt engineering for programmers,programming prompts,coding prompts chatgpt,prompt engineering for code snippets,get better code from gpt,get better code from ChatGPT4,code in gpt4,gpt4 programming,gpt-4,gpt4 code,gpt-4 code

100+ Rust ChatGPT Prompts 👨‍💻 PDF [Free Resource]

Douglas James Butner — Wed, 08 Mar 2023 22:59:35 +0000

🤩 Download All the prompts free on Gumroad

due to length constraints, this article contains less than half

Turn these prompts into Real Apps.

For the Power-Programmer 👨‍💻☕️

Hungry minds will find wisdom in Prompt Engineering for Programmers our complete BUNDLE that includes all current + future training, prompts packs, PDFs & all updates.

Explore the power of Rust with ChatGPT.

Using these prompts

👨‍🏫 This resource is designed to quickly show you the power of chatGPT and serve as a starting point for exploration.

Copy and paste these into https://chat.openai.com/ to see what you get. I’ve also added some responses here. Further explore editing the prompts, trying to direct the AI, and taking the step-by-step responses as new prompts to feed the bot. Enjoy!

Next Step: We also sell advanced training for programming with ChatGPT.

Learning Rust (New Concepts)

Ownership and Borrowing:

What are the benefits of Rust's ownership and borrowing system?

How does Rust prevent common memory-related bugs like null pointers and dangling pointers?

Can you explain the difference between mutable and immutable borrowing in Rust?

Traits:

How do traits help with generic programming in Rust?

Can you provide an example of a custom trait in Rust?

What is the difference between a trait object and a generic type parameter in Rust?

Lifetimes:

What is a lifetime in Rust and how is it different from a scope?

How does Rust's borrow checker use lifetimes to prevent dangling pointers?

Can you explain the difference between 'static and 'a lifetimes in Rust?

Pattern Matching:

What is pattern matching and how is it used in Rust?

How can pattern matching be used with enums and structs in Rust?

Concurrency:

What are some of the built-in concurrency primitives in Rust?

How does Rust's ownership and borrowing system make writing concurrent code safer?

Can you provide an example of a multi-threaded Rust program?

Macros:

What are macros and how are they used in Rust?

Can you provide an example of a macro in Rust?

How can macros be used to generate code at compile time in Rust?

Error Handling:

What are some of the built-in error handling mechanisms in Rust?

How does Rust's error handling system differ from other programming languages?

Can you provide an example of how to use the Result and Option types in Rust?

Systems Programming

Build a system daemon that monitors system resource usage and logs events to a file using the Rust Standard Library. Use the log crate for logging and the signal-hook crate to handle system signals.

Develop a network application that implements a custom protocol using Rust's TCP and UDP socket libraries. Use the nix crate for low-level system programming and the futures crate for asynchronous programming.

Create a file management tool that allows users to copy, move, and delete files and directories using Rust's standard filesystem library. Use the clap crate for command-line argument parsing and the indicatif crate for progress bars.

Build a simple web server that handles HTTP requests and serves static files using the Iron web framework and Rust's standard HTTP libraries. Use the chrono crate for handling dates and times and the openssl crate for secure communication.

Develop a low-level library for interfacing with a hardware device using Rust's Foreign Function Interface (FFI) and the libc crate. Use the crossbeam crate for safe concurrent programming and the rust-crypto crate for encryption and hashing.

Create a CLI tool that allows users to manipulate audio files using the Rust's audio crate. Use the clap crate for command-line argument parsing and the hound crate for audio file I/O.

Build a network daemon that listens for incoming connections and manages a pool of worker threads using Rust's standard thread libraries and the crossbeam-channel crate for inter-thread communication. Use the rustls crate for secure communication.

Develop a command-line tool for converting between different image formats using Rust's image processing library and the clap crate for command-line argument parsing. Use the rayon crate for parallel processing.

Create a system service that monitors a directory for changes and logs events to a file using the notify crate. Use the chrono crate for handling dates and times and the slog crate for logging.

Build a command-line tool that encrypts and decrypts files using Rust's cryptography libraries and the clap crate for command-line argument parsing. Use the rand crate for generating random numbers.

Develop a low-level library for interfacing with a Bluetooth device using Rust's FFI and the BlueZ Bluetooth stack. Use the nix crate for low-level system programming and the futures crate for asynchronous programming.

Create a CLI tool that allows users to manipulate PDF files using the Rust's PDF processing libraries and the clap crate for command-line argument parsing. Use the rayon crate for parallel processing.

Build a system daemon that monitors and logs changes to system configuration files using Rust's standard filesystem libraries and the notify crate. Use the serde crate for serialization and deserialization.

Develop a command-line tool that generates random passwords using Rust's cryptography libraries and the clap crate for command-line argument parsing. Use the rand crate for generating random numbers.

Create a low-level library for interfacing with a USB device using Rust's FFI and the libusb library. Use the nix crate for low-level system programming and the futures crate for asynchronous programming.

Build a command-line tool that allows users to manage system processes using Rust's standard process libraries and the clap crate for command-line argument parsing. Use the regex crate for string manipulation.

Develop a system daemon that manages a pool of worker threads and communicates with them using Rust's standard thread libraries and the crossbeam-channel crate. Use the chrono crate for handling dates and times and the slog crate for logging.

Create a low-level library for interfacing with a Serial device using Rust's FFI and the serialport library. Use the nix crate for low-level system programming and the futures crate for asynchronous programming.

DevOps

Build a Continuous Integration/Continuous Deployment (CI/CD) pipeline using Rust's DevOps library, Rust CI/CD, and the Jenkins automation server. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Develop a tool for infrastructure automation using Rust's DevOps library, Rust Chef, and the Chef configuration management tool. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Create a tool for container orchestration using Rust's DevOps library, Rust Kubernetes, and the Kubernetes container orchestration system. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Build a serverless infrastructure using Rust's DevOps library, Rust Serverless, and the AWS Lambda service. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Develop a tool for continuous monitoring using Rust's DevOps library, Rust Prometheus, and the Prometheus monitoring system. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Create a tool for log management using Rust's DevOps library, Rust Logstash, and the Logstash logging pipeline. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Build a Continuous Integration/Continuous Deployment (CI/CD) pipeline using Rust's DevOps library, Rust Travis, and the Travis CI/CD platform. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Develop a tool for infrastructure testing using Rust's DevOps library, Rust Terraform, and the Terraform infrastructure as code tool. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Create a tool for container security using Rust's DevOps library, Rust Clair, and the Clair container security scanner. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Build a serverless application using Rust's DevOps library, Rust AWS Lambda, and the AWS Lambda service. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Develop a tool for infrastructure visualization using Rust's DevOps library, Rust Graphviz, and the Graphviz graph visualization software. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Create a tool for container monitoring using Rust's DevOps library, Rust Prometheus, and the Prometheus monitoring system. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Build a Continuous Integration/Continuous Deployment (CI/CD) pipeline using Rust's DevOps library, Rust CircleCI, and the CircleCI CI/CD platform. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Develop a tool for infrastructure as code using Rust's DevOps library, Rust Ansible, and the Ansible configuration management tool. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Create a tool for container orchestration using Rust's DevOps library, Rust Nomad, and the Nomad container orchestration system. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Build a serverless application using Rust's DevOps library, Rust Google Cloud Functions, and the Google Cloud Functions service. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

DevOps and Infrastructure

Create an infrastructure deployment tool that utilizes the Terraform library to provision and manage cloud infrastructure resources. Use Rust's standard HTTP and JSON libraries to communicate with cloud provider APIs. Use the clap crate for command-line argument parsing.

Build a continuous integration and continuous deployment (CI/CD) pipeline that utilizes the Gitlab CI/CD platform and Rust's standard process libraries for build and deployment automation. Use the log crate for logging and the dotenv crate for environment variable management.

Develop a monitoring and alerting tool that utilizes the Prometheus monitoring system and Rust's standard HTTP libraries to monitor system metrics and generate alerts. Use the chrono crate for handling dates and times and the serde crate for serialization and deserialization.

Create a tool for managing and orchestrating Docker containers using the Docker SDK for Rust and Rust's standard process libraries. Use the clap crate for command-line argument parsing and the log crate for logging.

Build an infrastructure-as-code (IaC) tool that utilizes the CloudFormation template language to provision and manage cloud infrastructure resources. Use Rust's standard HTTP and JSON libraries to communicate with cloud provider APIs. Use the clap crate for command-line argument parsing.

Develop a tool for managing and automating Kubernetes cluster deployments and configuration using the Kubernetes API and Rust's standard HTTP libraries. Use the chrono crate for handling dates and times and the log crate for logging.

Create a tool for managing and automating AWS Lambda functions using the AWS SDK for Rust and Rust's standard process libraries. Use the clap crate for command-line argument parsing and the log crate for logging.

Build a tool for managing and automating AWS EC2 instances using the AWS SDK for Rust and Rust's standard process libraries. Use the chrono crate for handling dates and times and the serde crate for serialization and deserialization.

Develop a tool for automating cloud backup and recovery using Rust's standard filesystem libraries and cloud provider APIs. Use the clap crate for command-line argument parsing and the log crate for logging.

Create a tool for managing and automating AWS S3 object storage using the AWS SDK for Rust and Rust's standard process libraries. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Build a tool for managing and automating AWS DynamoDB NoSQL databases using the AWS SDK for Rust and Rust's standard process libraries. Use the chrono crate for handling dates and times and the serde crate for serialization and deserialization.

Develop a tool for automating infrastructure security audits and vulnerability scans using the RustScan network scanner and Rust's standard process libraries. Use the log crate for logging and the serde crate for serialization and deserialization.

Create a tool for automating cloud cost optimization using the AWS Cost Explorer API and Rust's standard HTTP libraries. Use the clap crate for command-line argument parsing and the chrono crate for handling dates and times.

Build a tool for managing and automating AWS Elastic Load Balancers using the AWS SDK for Rust and Rust's standard process libraries. Use the log crate for logging and the clap crate for command-line argument parsing.

Develop a tool for automating the management of DNS records using the AWS Route 53 API and Rust's standard HTTP libraries. Use the chrono crate for handling dates and times and the serde crate for serialization and deserialization.

Create a tool for automating the management of SSL/TLS certificates using the Let's Encrypt API and Rust's standard HTTP libraries. Use the clap crate for command-line argument parsing and the log crate for logging.

Data Science

Develop a data preprocessing pipeline using Rust's ndarray library for numerical computing and the csv crate for data loading and serialization. Use the clap crate for command-line argument parsing and the chrono crate for handling dates and times.

Create a tool for exploratory data analysis using Rust's statistical computing library, Statrs, and the ggplot crate for data visualization. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Build a machine learning model for classification using the Rust machine learning library, Leaf, and the mnist crate for image data loading. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Develop a tool for natural language processing using Rust's NLP library, rust-nlp, and the conllx crate for parsing and serialization of CoNLL-X format data. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Create a tool for time series analysis using Rust's Time Series Library, TSL, and the chrono crate for handling dates and times. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Build a recommender system using the Rust recommendation library, rusty-machine, and the MovieLens dataset for collaborative filtering. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Develop a tool for clustering using Rust's machine learning library, Leaf, and the kmeans crate for clustering algorithms. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Create a tool for anomaly detection using Rust's machine learning library, rusty-machine, and the credit-card-fraud dataset for supervised anomaly detection. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Build a tool for feature selection using Rust's machine learning library, rusty-machine, and the bioactivity dataset for selecting features in drug discovery. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Develop a tool for deep learning using Rust's machine learning library, tract, and the MNIST dataset for image recognition. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Create a tool for data visualization using Rust's plotting library, plotters, and the iris dataset for plotting scatterplots and histograms. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Build a tool for time series forecasting using Rust's machine learning library, rusty-machine, and the electric load dataset for forecasting electric load. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Develop a tool for association rule mining using Rust's machine learning library, rusty-machine, and the Adult dataset for market basket analysis. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Create a tool for hyperparameter tuning using Rust's machine learning library, rusty-machine, and the iris dataset for tuning classification models. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Build a tool for data cleaning using Rust's data cleaning library, scrubcsv, and the adult dataset for cleaning and transforming data. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Develop a tool for regression using Rust's machine learning library, rusty-machine, and the wine quality dataset for predicting wine quality. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Game Development

Develop a 2D game using the Amethyst game engine and Rust's 2D graphics library, gfx-hal. Use the specs crate for entity-component-system architecture and the nalgebra crate for linear algebra.

Build a 3D game using the Piston game engine and Rust's 3D graphics library, gfx-hal. Use the specs crate for entity-component-system architecture and the nalgebra crate for linear algebra.

Create a tool for generating procedural terrain using Rust's 3D graphics library, gfx-hal, and the noise crate for noise generation. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Build a physics engine using Rust's physics library, nphysics, and the nalgebra crate for linear algebra. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Develop a tool for creating custom shaders using Rust's 3D graphics library, gfx-hal, and the spirv-reflect crate for reflection of shader code. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Develop a tool for level design using Rust's game engine, Bevy, and the Tiled Map Editor. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Create a tool for game asset management using Rust's game engine, Piston, and the Glium crate for graphics. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Build a real-time strategy game using Rust's game engine, Amethyst, and the nphysics crate for physics simulation. Use the nalgebra crate for linear algebra and the specs crate for entity-component-system architecture.

Develop a tool for game audio using Rust's game engine, GGEZ, and the Rodio crate for audio playback. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Create a tool for game scripting using Rust's game engine, RustyScript, and the rhai crate for scripting. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Build a puzzle game using Rust's game engine, Bevy, and the Ggez crate for graphics. Use the nalgebra crate for linear algebra and the specs crate for entity-component-system architecture.

Develop a tool for game localization using Rust's game engine, Amethyst, and the Fluent crate for localization. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Create a tool for game networking using Rust's game engine, Rust Multiplayer, and the ENet crate for networking. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Build a platformer game using Rust's game engine, Amethyst, and the nphysics crate for physics simulation. Use the nalgebra crate for linear algebra and the specs crate for entity-component-system architecture.

Develop a tool for game replay using Rust's game engine, Rust Replay, and the Serde crate for serialization and deserialization. Use the clap crate for command-line argument parsing.

Create a tool for game profiling using Rust's game engine, Rusty Profiler, and the cpuprofiler crate for profiling. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Build a multiplayer game using Rust's game engine, Bevy, and the WebSocket crate for real-time communication. Use the nalgebra crate for linear algebra and the specs crate for entity-component-system architecture.

Develop a tool for game AI using Rust's game engine, Rust AI, and the smai crate for AI programming. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Create a tool for game physics simulation using Rust's game engine, Rust Physics, and the nphysics crate for physics simulation. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Build a racing game using Rust's game engine, Amethyst, and the nphysics crate for physics simulation. Use the nalgebra crate for linear algebra and the specs crate for entity-component-system architecture.

Create a tool for debugging and profiling Rust game code using the gperftools crate for profiling and the log crate for logging. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Build a 2D game engine using Rust's 2D graphics library, Piston, and the specs crate for entity-component-system architecture. Use the serde crate for serialization and deserialization and the nalgebra crate for linear algebra.

Develop a tool for creating custom game assets using Rust's 2D graphics library, gfx-hal, and the image crate for image loading and serialization. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Create a tool for generating game levels using Rust's 2D graphics library, Piston, and the noise crate for noise generation. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Build a 3D game engine using Rust's 3D graphics library, gfx-hal, and the nalgebra crate for linear algebra. Use the specs crate for entity-component-system architecture and the serde crate for serialization and deserialization.

Develop a tool for creating custom particle systems using Rust's 2D graphics library, gfx-hal, and the specs crate for entity-component-system architecture. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Create a tool for debugging and profiling Rust game code using the tracing crate for tracing and the log crate for logging. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Build a 2D platformer game using Rust's 2D graphics library, Piston, and the specs crate for entity-component-system architecture. Use the nalgebra crate for linear algebra and the serde crate for serialization and deserialization.

Develop a tool for creating custom animations using Rust's 2D graphics library, gfx-hal, and the specs crate for entity-component-system architecture. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Create a tool for generating game music using Rust's audio library, rodio, and the cpal crate for audio processing. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

https://youtu.be/mMGC9aHpAFI

Hi there 👋 I'm Gudasol, Welcome to my Hive Blog

🧙‍♂️ Mystic ~ 👨‍🏫 Teacher ~ 👨‍💻 Coder ~ 🎙 Rapper ~ 🎨 Designer

I built cXc.world 🗺

I teach a model of Universal Consciousness 🪐

I'm the rapper Gudasol 🜛 🌞

my php 🏡 douglas.life

🔭 I’m currently building: cXc.world, Aquarius.Academy and side project $GOLD + $SILVER
🌞 I’m looking to collaborate on: cXc.world Smart Contracts (EOSIO) and Web 4
✋ Grow with us, join cXc discord, Aquarius Academy discord, and Gudasol discord
💬 I love to talk about: Web 4, Geotemporal Systems, Biomimetic Economics, Fractal Information, Platonic Solids, Collective Participation Income (CPI), Time Tokens, Channeling, Flow State, Galactic Consciousness.
🌎 Fun fact: I have been a Digital Nomad for over 5 years!! Living mostly in Latin America. Currently in Medellin, CO.

Let's Connect

Instagram | Telegram | Twitter | Discord

Find My Latest on Linktree 🔗🌳

🗳 Freebies + Downloads on Gumroad ✅

Turn these prompts into Real Apps.

For the Power-Programmer 👨‍💻☕️

Hungry minds will find wisdom in Prompt Engineering for Programmers our complete BUNDLE that includes all current + future training, prompts packs, PDFs & all updates.

🤩 Download All the prompts free on Gumroad

due to length constraints, this article contains less than half

Explore the power of Rust with ChatGPT.

Douglas James Butner — Wed, 08 Mar 2023 21:49:37 +0000

Using these prompts

👨‍🏫 This resource is designed to quickly show you the power of chatGPT and serve as a starting point for exploration.

Download All the prompts free on Gumroad
due to length constraints, this article contains less than half

Learning Rust (New Concepts)

Ownership and Borrowing:

What are the benefits of Rust's ownership and borrowing system?

How does Rust prevent common memory-related bugs like null pointers and dangling pointers?

Can you explain the difference between mutable and immutable borrowing in Rust?

Traits:

How do traits help with generic programming in Rust?

Can you provide an example of a custom trait in Rust?

What is the difference between a trait object and a generic type parameter in Rust?

Lifetimes:

What is a lifetime in Rust and how is it different from a scope?

How does Rust's borrow checker use lifetimes to prevent dangling pointers?

Can you explain the difference between 'static and 'a lifetimes in Rust?

Pattern Matching:

What is pattern matching and how is it used in Rust?

How can pattern matching be used with enums and structs in Rust?

Concurrency:

What are some of the built-in concurrency primitives in Rust?

How does Rust's ownership and borrowing system make writing concurrent code safer?

Can you provide an example of a multi-threaded Rust program?

Macros:

What are macros and how are they used in Rust?

Can you provide an example of a macro in Rust?

How can macros be used to generate code at compile time in Rust?

Error Handling:

What are some of the built-in error handling mechanisms in Rust?

How does Rust's error handling system differ from other programming languages?

Can you provide an example of how to use the Result and Option types in Rust?

Systems Programming

Build a system daemon that monitors system resource usage and logs events to a file using the Rust Standard Library. Use the log crate for logging and the signal-hook crate to handle system signals.

Create a CLI tool that allows users to manipulate audio files using the Rust's audio crate. Use the clap crate for command-line argument parsing and the hound crate for audio file I/O.

Create a system service that monitors a directory for changes and logs events to a file using the notify crate. Use the chrono crate for handling dates and times and the slog crate for logging.

Build a command-line tool that encrypts and decrypts files using Rust's cryptography libraries and the clap crate for command-line argument parsing. Use the rand crate for generating random numbers.

Develop a command-line tool that generates random passwords using Rust's cryptography libraries and the clap crate for command-line argument parsing. Use the rand crate for generating random numbers.

DevOps

Build a Continuous Integration/Continuous Deployment (CI/CD) pipeline using Rust's DevOps library, Rust CI/CD, and the Jenkins automation server. Use the clap crate for command-line argument parsing and the serde crate for serialization and deserialization.

Download All the prompts free on Gumroad
due to length constraints, this article contains less than half

Provable Democracy 🗳 The Web 4 Manifesto

Douglas James Butner — Sat, 10 Sep 2022 00:26:47 +0000

What is Web 4 🗳

Web 4 is a set of four modular paradigms (time tokens, provable personhood, information entropy, and geosocial systems) that allow integration of provable democracy in any social system that seeks to be more collaborative (organization, government, community, etc.). Modularity allows any project to adopt one or more of these principles to increase the accuracy, fairness, and transparency of each individual's role in collaboration. Furthermore, web 4 is designed to be biomimetic, defined as reflecting natural cycles and systems.

Web 4 is built on top of web 3 (it's blockchain-based) while being fundamentally different and providing enough benefit to society warrant the new title of web 4.

In essence, web 4 is guide for building consensus tools that helps to manifest a shared desire, opinion, or solution by providing a fair system of accounting using time-limited votes, real people, and existing geopolitical stratification.

Web 4 combines real-world components like time and geography with existing blockchain technology.

In this manifesto, I will define each of the components of web 4, provide psudeocode to illustrate the minimum integration into web 2/3, introduce the benefits to society, and offer a roadmap to adopting these concepts.

The Problem

Democracy, society's biggest and most successful consensus and collaboration mechanism, has become inefficient, inaccurate and too slow to keep up with the modern world. Groups of people organizing, whether to turn a profit as a company, or to live together in a community, are often under-, mis-, or not represented at all in the decision making processes that affect their lives and work. In both governments and companies it is the few that make the decisions for the many, even with the illusion of "having a say" that exists in a representative system.

The Solution

By providing each individual with equal power in a transparent decision making process, the true intent of the majority can not only be known, it can be acted upon in predetermined ways through smart contracts. Though this solution seems simple, there are issues that will need to be addressed according to the needs of each group of collaborating people, such as ensuring one person per account, tying tokens with time, accounting for times when some collaborators have more influence than others based on defined actions and roles, as well as protecting the privacy of decision makers where appropriate. This paper will detail these solutions, and recommend that each system decide what components of web 4 to use or not use. For example, systems can (and should) be built using time tokens that do not use biometric data at all, a common concern in our modern world.

Background

Before we detail web 4, we must look briefly at the concepts of web 1, web 2, and web 3.

Web 1
Static web. Files are served from a remote server to a user's browser.
Web 2
Dynamic web. Web pages take a user's information and desires into account to build a unique experience for them. Asynchronous requests allow single page applications to thrive. Applications are still served from a central server.
Web 3
Decentralized web. Applications, often open-source, exist in distributed networks instead of a central server. This unfederated model trades control and censorship for freedom and autonomy.
Web 4
Biomimetic web. Time-limited tokens are given to each individual, and used as a measure of opinion or desire in collaborative systems exhibiting a biomimetic, or fractal, architecture. (Alternatively called Time Web or Democratic Web)

Today, the top 100 websites/apps by traffic are all web 2-based. The web 2 paradigm fits closely with the wider environment of corporate-owned information.

As more and more individuals and societies are reconsidering the place of government, censorship, centralization and federated power, web 3 has emerged as a powerful, provable option to shape the evolution of information and society on planet Earth.

A growing portion of web 2 websites and applications today have elements of web 3, like cryptoblogs and games. While web 2 and web 3 can operate independently. Web 3 apps can be completely on-chain, or integrated into any web 2 website (ie. tokenization) to access web 3 features. Similarly, web 3 and web 4 can operate independently, but it makes the most sense for web 4 to be built on blockchains (web 3) to gain the benefits of reliability and transparency.

Guiding Philosophy

Web 4 seeks to implement biomimetic systems in harmony with the universe itself by replicating nature: the abundance of the Sun, rising entropy, and the similarity + uniqueness of each human being.

Web 4 tests the hypothesis that when we create information systems in harmonic resonance with natural systems, our society will be able to advance more rapidly than ever before, as we will be able to synchronize energetically with the larger systems of bioelectromagnetic information processing around us (the Earth, Sun, and Galactic core).

Web 4 catalyzes free will by empowering collective decision making to manifest common goals and desires. Web4 strive to make systems that are public, provable, and powerful. These systems find use in curation, community, and consensus.

Defining Web 4

Web 4 introduces four modular components for provably democratic systems, suggested to be built on top of web 3's open-source decentralized networks.

There are four conceptual underpinnings (modules) of web 4

Time Tokens Individuals may claim time-limited tokens at given intervals, which represent that interval and the recipient themselves. Only one time token can represent a given interval and individual. Time tokens have functionality to the original recipient only.
Proof of Individuality (One Person, One Account) Biometric Secrets, Social Verification, Proof of Liveness, white lists, etc. are used to guarantee no individual can collect two time tokens for a given interval by holding two accounts.
Information Entropy Information degradation over time, increasing cost to call smart contracts over time, and other mechanisms replicating entropy ensure that a system stays malleable, enabling a greater degree of biomimicry and systemic evolution.
Geosocial Systems Fair (according to each system's specific metrics) and transparent collaboration through accounting the opinions and desires of participants in geographic bounds which may be defined by geopolitical tradition, or voluntary declaration.

Each module can be implemented separately or in tandem. This paper invites you to involve any of these ideas into your current or future projects. We will discuss these concepts one at a time, but first let's examine why we need them in the first place.

Why we must grow from web 3 to evolve democracy, society and consciousness

Provable democracy cannot be fully achieved in web 3 as-is because there is no inherit limit over how many accounts a user may control.

Democracy is essentially reaching a consensus with the idea that each person is equal in their influence on that consensus within defined bounds.

Many different consensus models have been developed in web 3, most notably, proof of work (POW), proof of stake (POS), and delegated proof of stake (DPOS). These paradigms of consensus are used primarily to determine which chain of transaction records (blocks) is considered valid, "securing" a blockchain.

POS and DPOS are additionally used in projects like Hive to allow users to "vote" on valuable content. DPOS is also used for networks to determine who can access network resources, such as in EOSIO blockchains.

However, both of these POS/DPOS use cases (curation and resource allocation) are not democratic in the sense that each account is not equal. In both cases, the root of democracy is in the token, not the individual, and the ownership of tokens determines the voting power or computing power held by an individual.

In the end, the only way to implement true democracy in any system is through giving each individual equal power. The only way to do this while keeping web 3's decentralized nature is to implement the technological and idealogical advancements needed for a one individual, one account system. These advancements needed for provable high-fidelity democracy are, for simplicity and communication, called web 4. These principles aren't intended to be used for block production consensus, but for

Finally, there are many times that we don't want each person to be granted equal power in a democratic system simply for being born a human in a place. Merit-based (requires certification), choice-based (chosen by members of the system) or action-based (pre-vote action like education) requirements may be implemented in smart contracts as long as that action or merit is represented in data objects, such as the badge system in Hypha DHO. High-fidelity democracy (many integer-voting units per person's vote) can give an individual fractional or multiplied influence in a transparent way by using whole numbers as a multiplier of a set, system-wide voting power defined as the granted influence on consensus every voting member is given.

Let's review web 4 concepts one by one.

1 Time-issued cryptocurrency (Time Tokens)

Time tokens may be offered or directly distributed to users' wallets periodically. They work by hashing a unique personal identifier (address) with a time identifier, linking each token to a person and a span of time. This information can be stored on the token, like a non- or semi-fungible token, or be metadata that is later compiled by the system by reading a tx memo or other transaction history of the wallet/account.

The Gears of Time Tokens

Time tokens rely on the following concepts:

Time Tokens
Individuals may claim time-limited tokens at given intervals, which represent that interval and themselves. Only one time token can exist with one interval and wallets, and one individual can't hold another's time tokens.
These tokens provide the user with a function or action. The action burns the token, which may cause some change in the state of a system, such as minting another token, registering a vote, or any other action. Thus, each time token is unique yet semi-fungible. Time tokens can also be checked for freshness when needed, for example a user may have to use a certain time period's token to cast a vote in an election, which should also exclude that particular time token from all other election.
Time Unit
A time unit is a time interval that is a sub- or superset of a timestamp. This means that a time unit is some amount (or fraction) of seconds. Each time token MUST be the only one in existence stamped with a particular time unit and account/wallet (requires both).
Time Faucet
A time faucet is a smart contract that offers any qualified account EXACTLY one time token per unit of time passed since their last faucet. This can be an active faucet; requiring some action by the recipient, or a passive faucet; automatically sending the cryptocurrency to the user.
Qualified Accounts
Qualified accounts adhere to the individuality requirements of a given system. Each web 4 system will do this differently according to their needs, perhaps with a whitelist, social verification, biometric verification, proof of liveness, or other means.

How do Time Tokens work?

Time tokens operate like non-fungible tokens in their structure, storing a time unit (integer) with a unique user identifier (string) as the payload data.

The user's identifier may also be linked to a biokey discussed in the next section.

Time tokens are platform-independent, and need only the ability to store or imply simple data: a time unit and a user identifier.

In practice, a time unit is an integer that counts up the number of pre-defined time spans that have passed since an epoch. The epoch is typically when the system went live, and represents the first time unit.

Provable Democracy with Time Tokens

If we were to create a time token for a US citizen to vote in the US presidential election, the time span would be 126144000 seconds (four years), and the epoch would be at a timestamp representing the start of the election day previous to the first election to use time tokens. On election day, an active faucet would send/offer one time token to each registered voter (requires module 2: provable individuality) with a payload of the user's unique identifier and the integer 1 as the time unit (the next election would be 2, and so on.) The user would then send the token to the election's smart contract address with a memo of their vote. The system would check the identity of the voter as the one the token was minted to, validity of the memo, and the time unit against their list to ensure they are voting in the correct election, then burn the token (or else reverse the transaction if malformed), and send the user back another token representing a "I Voted" sticker.

This example intentionally doesn't account for anonymity

This example is simply implementing an existing system. It becomes beneficial when we realize that we can just as easily send the person 12 voting tokens so they can vote on their first, second and third choice. It becomes even more interesting when we send tokens every month (or so) and allow the people to vote directly on the bills that are being presented to their respective legislative bodies, just for fun, equivalent to a poll. It becomes even more expansive when we have the faucet smart contract require educational actions, such as opening a link to information on these bills (summary and the full text) to receive their votable time tokens.

It seems that the only way to beat misinformation is with information. By enforcing the integrity of voter informedness according to known metrics, a solution may be developed where opinion can be trusted to be at least well-representative of the population's desires.

A Simple Example in web 2

Here is the minimum information stored in a time token, using JSON Web Token (JWT) as an example

{
  "header": {
    "typ": "JWT",
    "alg": "HS256"
  },
  "payoadData": {
    "time-unit": 294957,
    "userid": "7f3e873a2c3d"
  }
}

Below is a brief pseudocode example of how one could use a signed time token as a JWT.

See Appendix A for more detailed pseudocode of a time token.

const passedBioData = {..} // biodata from user

const header = {
        "typ": "JWT",
        "alg": "HS256"
      }

const payloadData = {
    "time-unit": "294957", 
    "userid": "7f3e873a2c3d", 
    "appData": {
        "gold": 479,
        "honey": 23,
        "axe": 0 
    }
}

const bioKey = bioKeyGenerator(passedBioData); // Biometric provider's key or one generated direcly by user

// --- Here we have the signature, to be used for any purpose --- \\
signature = HMACSHA256(
    base64UrlEncode(header) + "."+
    base64UrlEncode(payloadData), 
    bioKey
)


function bioKeyGenerator(bioData){
    // Function takes data in the form of user input into their browser or smartphone.
    // Data is normalized (explained in Appendix A, not shown here)
    bioKeyChecked = bioData;
    // Return biokey 
    return sha256(bioKeyChecked)
}

The notable parts here are the time-unit and userid in the payload, and the biokey which is generated by a user's biometric data.

We have said web 4 is based on web 3 (blockchain), but this example intentionally used web 2 technology. Much of the rest of this paper goes over ways to avoid trust by incorporating biometric data in a specific way, but that's not always needed, or helpful. We have to trust a government to run our elections. We trust social media platforms with our photos. We trust the Sun will rise, and a giant meteor won't crash into Earth.

The truth is, all systems have some level of trust, even if that's just in the system itself. If we try to get rid of this trust by implementing a system so good we are our own private key, it can backfire, and when it does, if we built it because we were fearful instead of trusting, that's super lame.

While I'm going to lay out a possible solution to use biometrics in a "trustless" way that fits with web 3 ideals, personally I think it's a bad idea in general, and I won't be designing my Web 4 apps with it for quite some time, if ever, because I think social verification is more trustworthy for all stakeholders.

Are Time Tokens needed?

For a minimal system, there is no need for a token to track time. Any stored time point can be calculated in real time to determine the user's weight in curation or consensus forming. Any on-chain datastore would do, and there's even possibilities for manual input through photo-hashing pictures of a user's inked response on a printed paper.

2 Proof of Individuality - Biokeys, Biosecrets, + Social Verification

Please Note: This paper originally only spoke of biokeys and has been expanded to include social verification. There are solutions available today (like FaceTec and BrightID) that solve the same issues presented here. This paper seeks to outline a web 3-based system (decentralized + open source) that can run without a centralized actor, while not providing specifics to accomplish these goals. This is more of a thought experiment than a suggestion or requirement.

Biometric secrets (biosecrets) are akin to any cryptographic private key, but they are your actual biological data, or, more specifically, a four dimensional expression of your humanness from which biometric data is collected. The difference between a biosecret and a fingerprint or retinal scan is a biosecret involves a short expression (movement and/or sound) AND a physical attribute, not just one.

Instead of a private key generated alongside a public key, a hash of quantized biometric data becomes your public key, which is paired with your actual flesh-and-blood-and-sound-and-movement-data, your private/secret key, or as we call it "biosecret" which isn't stored on any server or blockchain.

Keys

Biometric Key: Digital identity keys generated static assessments of an individual's physical characteristics. (Fingerprint, Iris, Facial recognition)
Biokinetic Key: Digital Identity keys generated is a specific biometric expression measured over time via movement. (Voice Recognition)
Biokey: Any type of private key generated by an individual's measurable characteristics or expression. (Includes Biokinetic and Biometric)

How this can go wrong

In today's biometric space, static images are most commonly used for things like fingerprint and facial recognition, and geometry is the means to compare this data. Biometric secrets generated from static images are not secure, as static images can be faked. [2] Video offers a better solution to this problem, as it is harder to fake, can include audio, and lets developers create a whole new set of algorithms based on a changing stream of data. Facetec is one company using video for biometric verification.

What could be used to generate a biokey?

This stream of data (video + audio biometric expression) could be a user doing a series of hand gestures, singing a part of a song, speaking a phrase, speaking a phrase in different voices, clapping, making a series of facial expressions or movements, or anything else one can imagine.

For security, biometric expressions (used to make a biokey) must be unique (for example, which combination of words to speak) and many types must be available (gestures, movement, singing, clapping, etc) and used in combination. If each person's biokey was generated from the same single biometric expression, it would be a matter of time before specific AI could be developed to deepfake it for anyone. If the user is the only one that knows their biometric expressions it becomes nearly impossible to guess the type and nature of the expression, and even if that is known, difficult to use the same technique on more than one account. It also means this expresion can be forgotten, making accounts not recoverable. The nature of the uniqueness could be chosen by the user, or generated at random from the biokey software which would prompt the user to complete an action in a specific way.

With a wallet storing your encrypted key, you will only need to preform your biosecret in the event of adding to a new wallet or in case of account recovery. There is also the option to create a hybrid system where a normal private key is generated in tandem with a *recovery *, used only in the event of a compromised account, similar to the Mandel (formerly EOSIO) software.

Why do we need this, again?

Democratic systems certainly are being built without biometric verification, and will continue to be even after suitable biometric technology develops along the open source, client-side requirements. For now, decentralized solutions like Civic, and centralized tech like Facetec provide the necessary individuality at the cost of trust and requirement of citizenship. Additionally, biometric data can be avoided entirely by using a social verification platform like BrightID or piggybacking a community like Eden on EOS that has a list of socially verified accounts on-chain. As different projects implement web 4 in their own ways, the ideas presented thus far will develop as flaws are found. And there's always the ability to use a whitelist, the most low-tech, high-trust, and simplest solution.

Integrations

Solutions exist to allow any developer to prompt for a fingerprint scan or facial scan, even from the browser. [4] This makes integration of an already-accepted biokey type on a cellphone into any web3 application feasible.

Trust Issues

The biggest issue with biometrics is the lack of trust the general population has (or should have) with giving up their biometric data, including the growing number of facial recognition softwares and databases. The lack of trust is almost always associated with an individual's lack of clear consent, and lack of understanding the technology itself.

To alleviate the trust issue, biokey generators must be:

1) open-source
2) entirely run on the individual's hardware (client-side), and
3) not expose any biometric data to any other users or to a web 4 system itself (the biosecret is never stored or transmitted in any way).

There will always be security concerns with biometrics. For example, if a user uses their biometric secret to unlock their mobile device, another app could be secretly recording the camera in the background. A person could record them doing their secret, and try to play that video back to the camera to gain access. Also, deepfakes exist. These concerns must be addressed before this module of web 4 reaches mass adoption.

The upside of biosecrets is they virtually cannot be lost, as the account should always be recoverable by the individual. In a web 4 ecosystem, where time tokens are distributed daily and often spent daily, a hack would be much less catastrophic. The attacker will be able to access the user's balance, but not alter the past transactions, nor continue to collect the future deposits, because the real user will (in theory) quickly recover the account and change the biometric secret generation means so that the hacker's biofake is no longer working. In a system where a user must remember the particular expression of their biokey, there is a greater chance that the user will forget, but a smaller chance of a successful fake.

3 Information Entropy

Web 3 focuses on storing information forever in a provable way. Web 4 introduces a counter-model which may be optionally adopted by any time-token-based system. In this model, who did what becomes harder and harder to know the more time that passes.

This idea hinges upon incremental time units, the number of which is used to decide how difficult information about a particular account or contract is to access. This can be implemented by increasing the difficulty required to verify a transaction chain, or economically by increasing the fees associated with accessing or interacting with old smart contracts.

With information entropy, it is difficult, but not impossible, to piece together a story about an individual user by knowing they are responsible for a set of transactions over time. The further back in time a transaction is, the harder it is to link it to another transaction with any certainty. This difficulty may be overcame with resources or tokens required to execute a smart contract.

An extension of this idea is to require more and more time tokens be accumulated by an account to interact with a smart contract. For example, you could require an account needs to receive 1 event participation token to interact with an event modification contract, then increase this requirement as more events take place, which would be represented by referencing passing time units in a smart contract.

Other examples can make it more expensive to change a record from the past, make it more expensive to join a group, change probabilities an action causes another action, or even limit any past state's effect on the future of a blockchain.

Information Entropy and Biosecrets

Information fidelity requirements can also be degraded over time. For example, when generating a user's biokey, it can be assumed that the more time that passes, the more the biometrics of the individual will change.

Degradation of Biokeys

Biokeys are generated from a range of biometric values. This range of values can be expanded over time based on specific, well researched paths. The effect is, instead of having one hashed biokey for eternity, the generation process will create a set of biokeys from an increasingly wide range of data. This concept may be needed to keep people in control of their accounts as they age. There is considerable work to be done to develop this concept, as each data type has its own considerations and complications.

In this case, as time goes on, someone attempting to prove their individuality would have to spend a lot more effort to run the algorithms against their collected biodata, and the data precision needed to match the person's identity is actually lower. This is an example of increasing information entropy lowering information fidelity. This is possible because of the granularity of the matrix used to generate a biokey. You can compute the millions of possible hashes related to these quantized pieces of data, and expand the acceptable range over time.

Proceed with Caution

While the inclusion of this concept into web 4 may seem unnecessary at the moment, it is another guarantee of the privacy that is needed for many social applications. Philosophically, degradation of information also fits in with the general web 4 desire to reflect systems in nature.

Before moving on, I do wish to stress the modularity of web 4, and that this (perhaps the most radical idea presented) is not going to fit into every web 4 system, nor should it. This idea will find its usefulness when it is time, and should NOT be adopted without clear reasoning.

4 GeoSocial Systems: Geotribes + Geodomains

Collaborative geosocial systems are always happening everywhere humans live. Currently, we are collectively deciding what direction we should be moving as a society, from representative governments, to social media. However, human growth in the past few centuries has been focused on technological improvements rather than social improvements. [3] To harness the power of the information age for the collaboration of humans, web 4 should be used to enhance, introduce, and replace current structures that organize our societies.

Web 4 proposes that geosocial systems based in time token are the most apt to create and improve existing social layers.

What is a GeoSocial System?

A geosocial system is something that affects people (social) at a given bounded area (geo). We will introduce a model to create a bounded geosocial system on blockchain.

Concepts

Geodomain: A bounded area that may contain or be contained by other geodomains and may have an associated group of people (geotribe).
Geotribe: The group of people associated with a geodomain that are participants in a web 4 system.

Geodomains are akin to a level of organization like city or state, with a finite set of smaller areas making up the larger area, with the smallest area being a community of humans with shared desires (such as how to live), and the largest area being Earth. Geodomains could be overlapping, or the geographic aspect can be replaced by a spatial or ideological relationship, like metaverse land or fans of sports teams. We will continue to focus on a geospatial aspect in relation to Earth geopolitics.

Geodomain Levels

Across the globe, one geopolitical (geodomain) pattern seems to emerge, though names vary. Communities are within Cities, are within Counties, are within States, are within Nations, are within the World.

Community
Cities (aka Towns, Commonwealths, etc.)
Counties (aka Divisions, etc)
States (aka Districts, Provinces)
Nations (aka Countries, States, Republics, etc)
Global

Using this existing geopolitical stratification is recommended for those wishing to build a web 4 system because it makes varying global systems easily storable in a one relational database model, smart contract, or similar data structure, and is understood by local people, governments, etc. Any other system is possible if one is willing to create it.

Once we have our geodomains, we must define what makes a geotribe.

Geotribal Bonds

Traditionally, it's a presence within a certain area, such as a place of residence or business, that is of importance for things like taxes, voting, and citizenship. This is no longer a necessity, as there are other metrics to measure an association with a region, including amount of time spent there (provable with checkins via a phone GPS) or voluntary declaration (proofless).

It is important for every system that each individual declare only one geodomain/geotribe so that their "vote" isn't counted twice, or half (if divided). Checking in once in a while within the region using GPS is an easy way to show association with a geodomain.

When using stratified geodomains, such as geopolitically-based ones, Geodomains are layered, with each level adding definition by refining larger Geodomain layers into smaller parts.

If a geopolitically-based geodomain system allows geotribe members to declare their own associated location without proof, the member is incentivized to be honest, as they will receive the most benefit from having their opinion heard where it matters to them.

All "non-proof" systems should place restrictions on switching voluntarily-given geodomain association too often (such as once per 6 months) to prevent influencing foreign affairs.

High-Fidelity Democracy

By offering time tokens to the individual that correspond to each stratum we can create high-fidelity democratic systems that better represent each and every person's desires. We can know exactly what the people want, with no guesswork and 0 middlemen, in a very short period of time.

For example, a person may be given 12 time tokens per month at each stratum to vote on the initiatives that they would like to see passed. They may vote all 12 tokens for an initiative they are most passionate about, or 1 token to 12 different initiatives (or 2 to 6 initiatives, etc). By collecting and counting these tokens, the governing body can know exactly what their constituents want, without the direct need to elect a representative who only estimates these desires.

The democratic system described in this paper does not solve all problems, as there are still issues of voter informedness, unseen actors, and more, but it is a skeleton to build a collaborative social system that are an improvement to the representative governments which were once as revolutionary as these ideas are.

The Road to Web 4 Reality

Phase One

Implementing time tokens

Time Tokens are implemented on any and all blockchains where developers see the value. These developers provide open-source instructions and tools to helps other developers incorporate time tokens into their applications. Services develop to allow any dapp to integrate a provider's time tokens.

Provable individuality for Time Token issuance is up to each application and blockchain, and these application can choose to ignore this requirement, risking their systems' integrity. Federated (Facetec) and decentralized (Civic) options may be used, and so can social verification (BrightID), as well as simpler development libraries for common web development frameworks like Vue, Angular and React.

Information entropy and geosocial systems are starting to be theorized, but not showing up.

Phase 1 Action Points:

Time Token ERC proposal on Ethereum + EVM (and similar for other blockchains like EOSIO)
Developers exploring use cases for Time Tokens

Phase Two

dApps and discovering issues

Applications using Time Tokens are widespread, and issues in implementations are becoming known and solved. Developers who open time token faucets are seeing their token be used in third-party apps in ways they didn't foresee.

Provable identity issues are becoming apparent, as certain applications with lax rules are being manipulated, showing the need for true provable identity. The best solutions are becoming known alongside the problems.

Information entropy principles are starting to be implemented, when required.

Geosocial systems are starting to be built, but not used for "real applications" like running a government because of lack of true provable individuality, and social inertia.

Phase 2 Action Points:

Proposing the best uses for geosocial systems using time tokens
Incorporating different provable identity methods
Developers implementing Time Token in unexpected ways

Phase Three

Implementing Provable Identity

Provable Identity is now possible as suggested in this manifesto through the maturity of the biometric secrets. Standards are being created openly, or, it is decided that the way presented here is not needed as a better way is found. Or, biokeys are completely abandoned as a form of social verification is found that can replace it.

Geosocial systems are being used to run and govern communities which are not dependent on traditional representative government. Existing municipalities are adopting time tokens to get a better read on what legislation the people want.

Organizations of all sizes are using time tokens to shift power to employees.

Phase 3 Action Points:

Picking proof of individuality solutions that satisfy all requirements
Possibly abandoning biometric system presented here
Communities running on web 4
Governments benefiting from web 4
Organizations using web 4

Phase Four

Geosocial systems

Information entropy is added to the systems where it can be of use. For example, this could make a person's (anonymous) voting record less knowable over time by increasing the amount of CPU time needed to associate one vote with another.

Geosocial systems are being used as a replacement for representative government where it is the will of the people. Voter informedness is measured and known, as are the exact desires of the people. This creates collaboration and a renewed faith in democracy, and a feeling of belongingness and appreciation for each individual.

Phase 4 Action Points:

Building and operating geosocial systems for the benefit of society and any collaborating group
Exploring use cases and integrating information entropy where appropriate

Author notes

Change Without Conflict

No one can stop us from building collaborative systems with web 4 and even self-governing. We don't need to "tear down the system" or separate from society to do so. Web 4 can exist fully embedded in the geopolitical systems around us, while implementing and improving the four concepts, the underpinnings of biomimetic democracy.

If and when the "old system" meets its demise, as all things do, we can transition rapidly to a web 4 system like Effective Collective or any other, as this solution will already be in place.

Why use the term "Web 4"

It is my belief that each version of the web must 1) be built on top of the previous version, 2) be fundamentally different than the previous version by introducing new technology, and 3) have meaningful impact on society.

This proposal for the next iteration of the web is an effort to both expand and shift the path of information science in a direction where the meaningful impact of society involves: 1) empowerment of each individual, which serve as the basis for collective (social), economic, and novel applications; 2) provable identity verification while maintaining complete separation from any federated system, including government, with the side-benefit of lifelong recoverability of biokeys with biosecrets; and 3) resonance with our contained and containing systems, like our human organs and the Solar system, which provide us with life and free energy daily, akin to free time tokens.

While an argument could easily be made that DeFi is Web 4, or another emerging tech, like "layer 2" blockchains (rollups) are web 4, both of these are not new. DeFi mimics and improves the systems of the past. Rollups are merely making web 3 more efficient.

It is my hope and desire that the information presented here will be expanded on and implemented by many developers and systems in the coming years, not for the benefit of the few, but for the empowerment of each individual and the harmony of the human collective, and every layer of Gaia.

Notes + References

[1] - Solutions like Civic and Facetec have proved to be effective in verifying individuality. KYC services rely on government-issued identification, physical signature, and minimal, often human-checked bioverification. Until the technology is developed for a biometric system resembling the ideas here, these options (as well as social verification) are viable, though not fully embodying the idea of web 4.

[2] - Hao, K. & O'Neill P. (2020, August 06). The hack that could make face recognition think someone else is you. Originally Published at https://www.technologyreview.com/2020/08/05/1006008/ai-face-recognition-hack-misidentifies-person/

[3] - Nishimura H., Kanoshima E., Kono K. (2019) Advancement in Science and Technology and Human Societies. In: Abe S., Ozawa M., Kawata Y. (eds) Science of Societal Safety. Trust (Interdisciplinary Perspectives), vol 2. Springer, Singapore. https://doi.org/10.1007/978-981-13-2775-9_2 (Specifically section 2.1.3)
web link

[4] - Face.io Integration Guide - Web link

See Changelog + Latest Updates: Web4 paper on Github

Appendices

Appendix A: Time Token Implementation

Here's a sample function to convert from timestamp to a time unit. Time-based systems don't always need a token linking the account owner, and you can compute from native time types.

// --- Returns the current Time Unit --- \\
function getTu() { // Returns the current Time Unit
  // 1561139700 is the first Time Unit
  let nowts = new Date().getTime(); 
  let tu_ = Math.floor((Math.floor(nowts/1000) - 1561139700) / 300);  // Divide by the length of a Time Unit in seconds
  return tu_;
}//END getTu()

Here's an example of a smart contract structure implementing the time token concept on EOSIO blockchain technology to make a democratic music map. The missing functionality in this example is the distribution of Time Token, handled in another contract.

In this contract, the tokens used to do the voting are Time Tokens for the dapp cXc.world. The contract listens for transfers of this time token to the contract, and assigns an equal amount of weight to each vote in logup(). To view the full contract an actions, review the open-source contract on Github and to understand what the concepts are, view the explainer document.

#include "eosio/eosio.hpp"
#include

using namespace std;
using namespace eosio;
using std::string;

class [[eosio::contract]] ups : public contract {

using contract::contract;
public:

#include "songs.hpp"

struct song {
string title;
vector links;
vector geoloc;
uint8_t genre;
uint8_t mood;
uint8_t format;
string atomictempid;
};

uint32_t timeunit;

std::string AUTH_ACCOUNTS[6] = { "authorized", "accounts" };

enum up_type {
SOL = 1,
BLUX = 2,
BIG = 3,
BIGSOL = 4 // -- This allows one call to send both Sol and Big Ups, greedy for all 64 Ups to make one Big Up (Won't work otherwise)
};

private:

TABLE upslog {
uint upid;

uint32_t songid;
uint32_t totalsolups;
uint32_t totalbluups;
uint32_t totalbigups;
uint32_t tuid;

  uint64_t primary_key() const { return upid; }
  uint64_t by_songid() const { return (uint64_t) songid; }
  uint64_t by_solups() const { return (uint64_t) totalsolups; }
  uint64_t by_bluups() const { return (uint64_t) totalbluups; }
  uint64_t by_bigups() const { return (uint64_t) totalbigups; }
  uint64_t by_tuid() const { return (uint64_t) tuid; }
};

using upslog_table = multi_index<name("upslog"), upslog,
  eosio::indexed_by<"bysongid"_n, eosio::const_mem_fun<upslog, uint64_t, &upslog::by_songid>>,
  eosio::indexed_by<"bysolups"_n, eosio::const_mem_fun<upslog, uint64_t, &upslog::by_solups>>,
  eosio::indexed_by<"bybluups"_n, eosio::const_mem_fun<upslog, uint64_t, &upslog::by_bluups>>,
  eosio::indexed_by<"bybigups"_n, eosio::const_mem_fun<upslog, uint64_t, &upslog::by_bigups>>,
  eosio::indexed_by<"bytuid"_n, eosio::const_mem_fun<upslog, uint64_t, &upslog::by_tuid>>
>;

TABLE totals {
  uint32_t songid;
  uint32_t totalsolups; 
  uint32_t totalbluups;
  uint32_t totalbigups;
  uint32_t updated;

  uint64_t primary_key() const { return songid; }
};

using totals_table = multi_index<name("totals"), totals>;

TABLE songs { //CHECK need to store the type of account here?
  uint32_t songid;
  name artistacc;
  uint8_t artisttype;
  song song;

  uint64_t primary_key() const { return (uint64_t) songid; }

};

using songs_table = multi_index<name("songs"), songs>;

// --- Activity stats for Listeners (For future awards) --- \\
TABLE listeners {
  name upsender;
  uint32_t firstup;
  uint32_t lastup;
  uint32_t totalsolups;
  uint32_t totalbluups;
  uint32_t totalbigups;

  uint64_t primary_key() const { return upsender.value; }
};

  using listeners_table = multi_index<name("listeners"), listeners>;

// --- Store record of who to pay --- \\ 
// CHECK (in .cpp) that we are paying both the upsender + upcatcher
TABLE ious {
  uint64_t iouid;
  name upsender;
  name upcatcher;
  uint8_t artisttype;
  uint32_t upscount; // Should be either BIGSOL or sol up or both
  uint8_t upstype;
  uint32_t initiated;
  uint32_t updated; 

  uint64_t primary_key() const { return iouid; }
  uint64_t by_upcatcher() const { return upcatcher.value; }
  uint64_t by_artisttype() const { return (uint64_t) artisttype; }
  uint64_t by_upscount() const { return (uint64_t) upscount; }
  uint64_t by_initiated() const { return (uint64_t) initiated; }
  uint64_t by_updated() const { return (uint64_t) updated; }
};

using ious_table = multi_index<name("ious"), ious,
  eosio::indexed_by<"byupcatcher"_n, eosio::const_mem_fun<ious, uint64_t, &ious::by_upcatcher>>,
  eosio::indexed_by<"byartisttype"_n, eosio::const_mem_fun<ious, uint64_t, &ious::by_artisttype>>,
  eosio::indexed_by<"byupscount"_n, eosio::const_mem_fun<ious, uint64_t, &ious::by_upscount>>,
  eosio::indexed_by<"byinitiated"_n, eosio::const_mem_fun<ious, uint64_t, &ious::by_initiated>>
>;

// --- Keep record of Artists (recipient in _songs) to pay --- \\
TABLE artists {
  name artistacc;
  string artistalias;
  vector<string> artistinfo;

  uint64_t primary_key() const { return artistacc.value; }
};
using artists_table = multi_index<name("artists"), artists>;

TABLE artistgroups {
  string groupname;
  name intgroupname; // abcdef.cxc // CHECK is there benefit to a name (uint64_t) vs a simple uint32_t? 
  vector<name> artists;
  vector<int8_t> weights;
  vector<string> groupinfo; // CHECK this will work, can pass empty strings, or is there an <auto> type, key value pairs
  uint8_t payposition;  

  uint64_t primary_key() const { return intgroupname.value; }
};

  using groups_table = multi_index<name("artistgroups"), artistgroups>;



TABLE internallog {
  uint32_t lastpay;
  uint32_t lastfullpay; 
  bool remaining; // Did we reach the end of who is owed to pay? 

  uint64_t primary_key() const { return (uint64_t) lastpay; } 
};

using cxclog_table = multi_index<name("artistgroups"), artistgroups>;


void updateup(uint32_t upscount, uint8_t upstype, name upsender, uint32_t songid); 
void logup(uint32_t upscount, uint8_t upstype, name upsender, uint32_t songid); 
void removeups(name user); 
void updateiou(uint32_t upscount, uint8_t upstype, name upsender, uint32_t songid, bool subtract); 
void removeiou(name sender, name receiver); 
void updatelisten(uint32_t upscount, uint8_t upstype, name upsender);
void removelisten(name upsender);
void removesong(uint32_t songid); 
void deepremvsong(uint32_t songid); 


void updateartist(name artist_wax, vector<string> artistinfo, string artistalias); 
void updateartistgroup(name intgroupname,  vector<string> groupinfo, string group_alias, vector<string> artists, vector<int8_t> weights);


// --- Declare the _tables for later use --- \\ 
ious_table _ious;
upslog_table _upslog;
songs_table _songs;
listeners_table _listeners;
artists_table _artists;
groups_table _groups;
totals_table _totals;

public:

[[eosio::on_notify("sol.cxc::transfer")]] 
void sol_catch( const name from, const name to, const asset quantity, const std::string memo );

ACTION payup(void); // Default call

ACTION payup(name upsender); // User's call to pay themselves

ACTION updateartist(name upsender, vector<string> artistinfo, string artistalias);

ACTION updategroup(name intgroupname, string group_alias, vector<string> artists, vector<int8_t> weights, vector<string> groupinfo);

ACTION updatesong(uint32_t songid, song dasong);

};

Appendix B: Pseudocode Example of Biometric Function

function bioKeyGenerator(bioData){

    // Function takes data in the form of user input into their browser or smartphone.

    let recievedData = bioData;

// With data, quantifyable points are taken algorithmically
let processedBioData = {
    point1:recievedData.point1,
    point2:recievedData.point2,
    point3:recievedData.point3
    ...
}



// These points expanded to a pre-defined margin of error geometrically for each input type

const expander = 20; // Set amount to expand dataset based on data type

let rangedBioData = {

    point1: {

        upperRight: {

            x : processedBioData.point1.x + expander,

            y : processedBioData.point1.y + expander

        },

        lowerLeft: {

            x : processedBioData.point1.x - expander,

            y : processedBioData.point1.y - expander

    },

    point2: {

    ...

    },

    ...

}

let snappedBioData = snapBioDataToGranularPath(rangedBioData);

// For this to work, a matrix-like object containing every single possible hashed value for every point of data

// ..must be stored on an authentication server for each data input.

// Data must also exhibit granularity (snap to an integer path).

// Without granularity, the hashes will never match a new input's hash.

// This matrix of values is used to compare the biokey with in the future

// This must be made more efficient to use with today's computers

let x;

let y;

let bioMatrix = {};

for (x = snappedBioData.point1.lowerLeft.x; x <= (expander*2) ; x++) {

    let curXRow = "x"+x;

    let bioMatrix[curXRow] = [];

    for (y = snappedBioData.point1.lowerLeft.y; y < (expander*2) ; y++) {

        curYRow = "y"+y;

        bioMatrix[curYRow].push(sha256(y));

    }

}

// Finally, the real biokey is returned as an object of hashed biometric data, 

// which will be checked by comparing each granular piece of data's hash to the incoming granular hashes

return bioMatrix; // Biokey

}

function snapBioDataToGranularPath(rangedBioDataParam){

    //returns data snapped to grid (recursively scans object passed)

}

Pretty Photos of the Code

Image Credits

Paper by Douglas James Butner
douglas@cxc.world

[![Mentioned in Awesome Web 4](https://awesome.re/mentioned-badge.svg)](https://github.com/dougbutner/awesome-web4)

👉 Passionate about these ideas? Support us on Gitcoin ☕️

cXc.world Releases Music NFT Schema Standard built on Atomic Assets 🤘🎸

Douglas James Butner — Wed, 16 Jun 2021 11:18:18 +0000

We built this standard to use in our Music NFT creator coming to cXc.world. Our NFT creator will allow you to fill out a form and mint the NFT to your own collection, or, if you qualify, you can mint to our exclusive collection.

So why did we make a whole recommendation?

Here at cXc, we like to get down to the nitty-gritty of how things work. That’s why we invented a whole new blockchain curation system to run cXc.world instead of using an existing algorithm.

We carried this love over to the NFT scene to offer anyone - project, band, or individual - some suggestions to help structure the data attached to a Music NFT. This will make it easier for low-techy artists to mint their NFTs. Of course, we’ll make it even easier for no-techs to mint using our NFT creator, but releasing the standard separately invites all levels and needs to interact with cXc, Atomic Assets, and the WAX ecosystem. A Win-Win-Win!

Below you’ll find cXc’s Music NFT Recommendation.

This recommendation is being updated as new needs are presented, but this article is not, so check out cXc’s Music NFT Recommendation on Github for the latest + greatest music NFTs.

cXc Music NFT Schema Recommendation 🎸

The cXc Music NFT Schema serves as a recommendation for any individual, collection, or application to publish a music NFT.

The benefits of using this schema include forward compatibility (Geotags) monetizing NFT plays with traditional platform players, infinite credits and links, and more.

This Schema exists within Atomic Asset's NFT standard on the atomicassets contract.

Feel free to use or modify this schema for your own purposes.

Summary 🗞️

This standard includes:

Name of the NFT (Can be different than track title)

One audio file

One video file

Three images [Main, Back, and Promo]

Title [If different than name]

Album name

Track # [If it's just one track]

Any number of custom credits

Any number of custom platform links

ISO Country code

Readable locale

Pin as GeoJson Point

License

Rarity

Technical Summary ⚙️

All media fields use IPFS.

All other info fields are strings (except "track" is int64)

String arrays are used to store unlimited Credits and Platform links.

Ex.

credits ["Band":"Boaty & The Boats","Bassist: Tim Leary", "Vocalist: Boaty McBoatface"]

platform ["youtube.com/v/gf75ja5","soundcloud.com/my/song"] or ["Soundcloud: soundcloud.com/my/song"]

Geo 🌍

ISO country codes (ISO 3166-1 alpha-3)

Locale string intended to be used in this format "City, County, State" or corresponding values for a given locality

geotag is a GeoJson point stored as a string

License is for codes like "CC-BY", or possibly declaring some privilege grant upon receiving NFT.

Field name	Type	Description
name	string	NFT name
img	string	Primary image / Cover image
audio	string	Audio file IPFS hash
video	string	Music video file IPFS has
backimg	string	Back cover of album / single
promo	string	Extra image for promo poster, QR code, etc
title	string	The actual title of the track
album	string	Title of the album
track	int64	Number of the track on the album
about	string	Description field with info about
credits	string[]	Array of song credits
youtube	string	Youtube URL
spotify	string	Spotify URL
soundcloud	string	Soundcloud URL
platforms	string[]	How scarce is this NFT?
nation	string	Three-letter ISO (USA, BRA, AUS, etc)
locale	string	Concatanation of lower locales (State, County, City in USA)
geotag	string	GeoJSON Point stored as string
license	string	Declare license if needed, (CC0, etc)
rarity	string	How scarce is this NFT?

To use this Standard

Paste the following array into the idata field using the Atomic Assets createschema action to create your own schema on Atomic Assets, and then create template from the schema for each NFT you release. Because this standard uses the string[] (string array) type, it's currently not possible to use directly on Atomichub UI, but should be in the future.

ℹ️ Important

Using this schema does not mean that each template must have every field filled, but you can only choose from fields in your future templates. You may add fields to the schema later, but not remove them. New fields will appear at the end, thus, best modify this standard to your needs before deploying.

cXc Music Schema 🕺

[
  {
    "name": "name",
    "type": "string"
  },
  {
    "name": "img",
    "type": "image"
  },
  {
    "name": "audio",
    "type": "ipfs"
  },
  {
    "name": "video",
    "type": "ipfs"
  },
  {
    "name": "backimg",
    "type": "image"
  },
  {
    "name": "promo",
    "type": "image"
  },
  {          
    "name": "title",
    "type": "string"
  },
  {
    "name": "album",
    "type": "string"
  },
  {
    "name": "track",
    "type": "int64"
  },
  {
    "name": "about",
    "type": "string"
  },
  {
    "name": "credits",
    "type": "string[]"
  },
  {
    "name": "youtube",
    "type": "string"
  },
  {
    "name": "spotify",
    "type": "string"
  },
  {
    "name": "soundcloud",
    "type": "string"
  },
  {
    "name": "platforms",
    "type": "string[]"
  },
  {
    "name": "nation",
    "type": "string"
  },
  {
    "name": "locale",
    "type": "string"
  },
  {
    "name": "geotag",
    "type": "string"
  },
  {
    "name": "license",
    "type": "string"
  },
  {
    "name": "rarity",
    "type": "string"
  }
]

Create a Template 🛠️ 🖼️.

Use this example (also below) to create a template you can use to drop your own Music NFTs using tools like Atomichub and Neftyblocks.

Modify this schema 🛠️

Change any field you wish when making your own schema

Suggestions:

Artist - If you'd rather have your name here than in credits

Multiple Audio fields - Duplicate the audio fields to include all songs on an album (DYOR on support)

Metadata - Add custom metadata like the key, BPM, time, whatever you want

If you'd rather include all of your links in the Platform field, you can remove the Spotify, Soundcloud, and Youtube field.

Removing Youtube will also disable Youtube player from showing up on Atomichub and likely other marketplaces.

Power of the Schema ✨ 🧙‍♂️

There is no magical benefit (yet) of using this standard, just practical ones. Youtube plays can bring extra revenue, as will the links to other players. You may credit all involved, and geographic data opens up new use cases for your NFT.

In the future it's possible a mapp / dapp (like cXc) to allow users to register their own schemas that adhere to this standard, creating a Music-NFT exclusive platform that doesn't rely on accounts or collection names alone.

Evolution of the Schema 🚀 🛸

This schema will grow and evolve. Feel free to open issues on this repo with your suggestions.

If you translate to another blockchain or NFT standard, please send a pull request adding a file named .md in the main directory containing the code needed to deploy, or open an issue with the code and I can update the repo if you prefer.

Music NFT Template for Atomic Assets

Here is an example of how to format a template according to this reccommendation. You will see not every field is used, as you can use only what you need.

To do this you will have to use the atomicassets => createtempl action.

View this template on Atomichub

[
  {
    "key": "name",
    "value": [
      "string",
      "Bluebirds 🥇"
    ]
  },
  {
    "key": "img",
    "value": [
      "string",
      "QmP1gc43EsmXoaYuT2XPZFWx9SDKk9JxAzpPMP4AUm3aof"
    ]
  },
  {
    "key": "promo",
    "value": [
      "string",
      "QmYzu7Dz7LqZP3jq4zmt84rpmjWm2AfhH1SF4Et5LbxVJy"
    ]
  },
  {
    "key": "audio",
    "value": [
      "string",
      "QmWGFx5epoiQBJ3CwBQ3VpNKNJ5VFoKoKDbXExiNLF5zAQ"
    ]
  },
  {
    "key": "about",
    "value": [
      "string",
      "Watching a bird opening it’s wings, Bluebirds is a soul’s reflection on the path through this marvelous galaxy. Over a classy beat Douglas expresses an egoic journey, and the desire to look past it while seeking meaning beyond science and religion."
    ]
  },
  {
    "key": "credits",
    "value": [
      "STRING_VEC",
      ["Artist: Sir Douglas Fresh","Beat: Blue Birds by Ours Samplus, live-mixed by Scarfinger"]
    ]
  },
  {
    "key": "youtube",
    "value": [
      "string",
      "youtube.com/watch?v=trpj6qmLflk"
    ]
  },
  {
    "key": "soundcloud",
    "value": [
      "string",
      "soundcloud.com/sirdouglasfresh/bluebirds-beat-by-ours-samplus-live-mix-by-scarfinger"
    ]
  },
  {
    "key": "platforms",
    "value": [
      "STRING_VEC",
      ["music.cxc.world/?id=1948"]
    ]
  },  
  {
    "key": "album",
    "value": [
      "string",
      "The Evolution of Sir Douglas Fresh (Mixtape)"
    ]
  },
  {
    "key": "nation",
    "value": [
      "string",
      "USA"
    ]
  },
  {
    "key": "locale",
    "value": [
      "string",
      "Accident, Garrett County, MD"
    ]
  },
  {
    "key": "geotag",
    "value": [
      "string",
      "[39.555,-79.240]"
    ]
  },
  {
    "key": "rarity",
    "value": [
      "string",
      "Epic"
    ]
  }
]

💥 FIND OUT MORE ABOUT cXc 💥

Current X Change is dedicated to harmonizing Humans, Collectives, and Gaia. Our media Mapps are just the start. As we refine Purple, we also seek to redefine what it means to come together as humans and co-create. We hope you'll enjoy the tools already here, and are infinitely stoked for what the future holds.

🗺️ Experience cXc.world 🌎

👁️ Step into our vision

🎥 Add Music to cXc.world

💸 Get to know our Economy

💰BUY & TRADE PURPLE, BLUx 📈

🟣 PURPLE/WAX 🔵 BLUx/WAX 🟣🔵 PURPLE/BLUx

Get specifics about these tokens in our Economic Brief

🎁 OFFICIAL cXc MERCH 🛍️

👕 Shop cXc High-fashion (Made in 🇨🇦)

🔴 cXc Stickers, shirts + More on Redbubble

Follow cXc on Social Media 📱🌎

🖼️ Instagram
🐦 Twitter
📺 YouTube
🐝 Hive
🏘️ Hive Community
🔑 Discord Musician Community (Collab + more)
🔺 Reddit
✈️ Telegram
🌊 Wavvy Music Accolades (NFT Music Awards)

💰🤑 Swaps (Instant Liquidity) 🟡🟣 WAX/PURPLE ~~ 🟡🔵 WAX/BLUx

What are BLUx and PURPLE? Find out in our Purple Explainer

(cXc) Roadmap 🛣️

🖼️ Introducing cXc.world's Music NFTs Standard: Request for Feedback 🎸🤘

Douglas James Butner — Fri, 14 May 2021 23:38:29 +0000

In this post, we'll introduce the cXc Music NFT standard first draft, and welcome your feedback

Making Music NFTs work for all artists

Background

There's been a lot of talk and anticipation on Music NFTs across the whole blockchain space, not just WAX. On WAX, we've seen a few music NFT projects take shape, including Uplift, YoshiDrops and Shawn Dall (all friends)

Currently, Music NFTs are near-monopolized by big-name artists, but we want to change that.

Every artist should be able to mint a professional Music NFT with little effort, and without all the guesswork + technical knowledge.

In cXc Beta, we're going to offer a NFT builder that gives you the option to mint to your own collections by duplicating our schemas for you, or, if you meet the requirements of minimum Ups on cXc.world, you can mint to our exclusive collection that will give you added credibility, yet is within reach of every artist, whether just starting out or already a local legend.

cXc's Music NFT Specification

Our goal is to empower the ARTIST, including promoting their centralized platforms (that usually pay for streams) and also set up the NFT with useful geospatial information that future Dapps can use, meaning this NFT could have a long and useful life, even outside of cXc.

Keep in mind all of these fields are OPTIONAL. Meaning if you don't want to have the location information, or don't have a promo image, that's okay!

See an example asset with a song from cXc's founder here and an updated template with the changes we added here (most accurate example)

The NFT Data

name: name (Example: Bluebirds [Beat by Ours Samplus] [Scarfinger Remix])
type: text

name: img (This is the main image, and will show first up by default)
type: image

name: audio (Only one audio file. We may release another specification that allows multiple audios later on)
type: ipfs

name: video (One optional video, like a music video, uploaded to IPFS. You can also skip this for youtube, but it won't show up on the NFT)
type: ipfs

name: backimg (Supposed to be like an album back cover, but flexible to your use case )
type: image

name: promo (Optional image which you can use to put more information about the song, a QR code, whatever you like )
type: image

name: credits (Put all your credits here, not in the title. Example: ["Artist: God Sol One Love","Beat: Ours Samplus, Scarfinger"] Note: You provide the credit 'type' and 'name' We'll format this in the NFT builder on music.cXc.world)
type: text array

We've put our three supported players separate from other platforms to highlight them, but you'll have to option to ignore these and just include all links in the "platforms" field later if you prefer

name: platforms (This is another text array [like credits] which we'll format from your links using our built-in NFT creator. You can put any platform's links you want, not just those supported by cXc)
type: text array

name: nation (Example: USA. This is a ISO standard abbreviation, and putting it here means future dapps can sort your music better)
type: text

name: locale (Example: Accident, Garrett County, Maryland. Optional, and allows other dapps to organize your music, plus shows others where you're creating from.)
type: text

name: geoloc (Example: [75.355, 15.256] You can share the recording location info here, just if you want! It's a GeoJson point, so it can mean your NFT can be put on any map in the future)
type: text

name: rarity (Can be set automatically by cXc by the max, or manually set for custom values)
type: text

Requesting your input

Tell us what you would like to see in the spec that you don't already. I'm also curious what you think about putting the SoundCloud and Spotify and YouTube links separate from the other platform links. This is optional, but still shows opinionation in our standard.

Chances are, you see things we don’t, so don’t hesitate to share!

You may notice that we don't have a cXc link by default. That's because we are going to suggest that users put it as one of the platforms, but not force anyone to include their cXc link if they don't want to. We’re making this to help artists first, no matter how they want to represent themselves.

Open Standard

Use this standard as you like and modify it to your needs. You'll find the exact data you'll need to make a matching schema on Atomichub in the comments.

💥 FIND OUT MORE ABOUT cXc 💥

👁️ Step into our vision

🎥 Add Music to cXc.world

💸 Get to know our Economy

🛣️ Roadmap

🔗 cXc Linktree

Trade 🟣 PURPLE/WAX ~~ 🔵 BLUx/WAX

Get a quick overview of these tokens in our Economic Brief

cXc Launches 🟣 Purple, a Co-Creative Economy on WAX Blockchain

Douglas James Butner — Sat, 17 Apr 2021 11:45:45 +0000

Purple’s tokenomics unveil revolutionary mechanics geared towards rewarding creators for creating, and generating local Top Charts.

Today Current X Change LLC (cXc) released Purple, a blockchain-based multi-token economy with a stated purpose to empower cocreation. This cocreation system works by providing each participant with up to 288 tokens, called SOL, per day for free. Participants then use 1 SOL to “Up” (short for upvote) content which other creators have posted to cXc.world, cXc’s map-based dapp (decentralized application).

After receiving an Up on their content, the creator is rewarded with another token, one BLUX. One BLUX can be spent to give an Up like one SOL, helping content get exposure by appearing larger on cXc.world, and also showing up on the Top charts. Top charts contain the final piece of the economy, PURPLE, which is rewarded daily to creators who make it into the Top 64 by getting the most Ups.

While supplies of BLUX and SOL are both inflating each day, and deflating as they are spent on Ups, PURPLE has a Max Supply of 35,831,808 tokens, 1/3 of which are reserved in a Creators Fund that is used to reward the Top 64 Creators for years to come.

PURPLE’s functionality lies in it’s ability to be staked for the owner’s choice of one daily Up on any piece of content or one BLUX token paid daily to their account. One staked PURPLE activates 1 Up or BLUX per day, but if you stake multiple PURPLE, you can get a much better rate, up to 6.75 Ups or BLUX per day for each PURPLE at 64 Purple staked.

Daily Ups are valuable because cXc.world only shows content that has received Ups that day, though viewers can also choose to see monthly trends, or any other time span in the “time machine”. Local charts are generated by the dapp for every Nation in the world, and in the United States for every State, County, and City.

Starting next release (Beta), Purple will work on cXc’s flagship application, cXc Music. In the future, cXc will release other media mapping applications like cXc Scribe, cXc Art, cXc Video, and more.

Purple’s designer Douglas Butner had this to say

“What’s even more exciting than launching Purple is to know that this is just the beginning. As a musician, I’m stoked to launch Purple on cXc Music because I’ve seen great music go unnoticed my whole life, including from my good friends. Looking forward and imagining this system not only helping musicians, but all kinds of creators goes beyond my wildest imagination.“

PURPLE token is now available for purchase on Alcor Exchange at the starting price of 20 WAX / PURPLE, though only 3,190 PURPLE will be listed at this price. A maximum of 1/12 max supply of PURPLE will ever be offered, always in small batches that go up in price each listing. The other tradable token, BLUX, will never be sold directly by cXc; it can only be earned on cXc.world and through staking PURPLE. BLUX and PURPLE are both available to trade and swap in DeFi pools on Alcor Exchange.

More information about the Purple economy can be found in the Purple Explainer.

💥 FIND OUT MORE ABOUT cXc 💥

👁️ Step into our vision

🎥 Add Music to cXc.world

💸 Get to know our Economy

🛣️ Roadmap

Trade 🟣 PURPLE/WAX ~~ 🔵 BLUx/WAX

Get a quick overview of these tokens in our Economic Brief

(cXc)'s Creator Rewards Token 🎸 Info on 🟣 $PURPLE ~ April 17, 2021 Noon GMT 📅

Douglas James Butner — Sat, 17 Apr 2021 02:46:28 +0000

$PURPLE's unique tokenomic model rewards creators daily for co-creating on cXc.world (receiving Ups), whilst directing traffic to streams on paying services.

Learn more about PURPLE

PURPLE's initial release starts April 17, 2021 on Alcor

Because of the very limited supply of PURPLE, ascending pricing + time-limited sell orders will be used to ensure that everyone has a chance to acquire the PURPLE they need to benefit fully from cXc.world. There are no per-account limits on purchases.

PURPLE Utility: Digital Advertising Gold

What can you do with PURPLE?

PURPLE can be staked for daily Blu Ups (or BLUX) to a piece of content; a rare form of digital advertising purchase that allows someone to buy once and hold continual attention for all of time. This attention means huge value, particularly to independent creators and creative organizations such as independent labels and artist collectives.

Furthermore, PURPLE need only be unstaked for the holder to receive back the same amount of tokens. This means an artist can advertise their art and meanwhile hold something of increasing utility as each future cXc.world mapp is released, and future uses of PURPLE are announced.

Today Musicians, Tomorrow All Creators

PURPLE has a unique utility for musicians, as cXc Music is the first cXc.world mapp, but this utility will expand to all creators and creative collectives when cXc Video, cXc Photo, cXc Scribe, cXc Art + more mapps are available.

Initial Sell Orders

Starting 4/17/2021, 1/12th of the 1/12 Max Supply designated for sale will be listed with pricing starting at 20 WAX per PURPLE.

These sell orders will be offered one at a time, with a one week gap between each listing starting after the previous listing's completion.

Tokens for Sale: 1/12 Max Supply or 12⁶ (2,985,984), issued + offered 12⁵ (248,832) at a time. Here's how we'll price the April 17th tokens.

Price	🟣 PURPLE Available
20 WAX	3,190 (April 17, Noon GMT)
21 WAX	6,380 (TBD)
22 WAX	9,570
23 WAX	12,760
24 WAX	15,950
25 WAX	19,140
26 WAX	22,330
27 WAX	25,520
28 WAX	28,710
29 WAX	31,900
33 WAX	35,090
36 WAX	38,280

Liquidity Promise

Of the first 1,000,000 WAX raised by the direct listing of PURPLE, no less than 500,000 WAX will serve as liquidity on Alcor exchange and DeFi swap.

Proceeds

WAX earned will be used to pay for all end-user transactions on cXc.world, and also purchase RAM for our records and accounts who interact with our tokens, mapps, and NFTs.

Remaining Proceeds from the listing will go towards development of cXc.world, including the final 1.0.0 release of cXc Music, native mobile apps, and the creation of other cXc.world mapps like cXc Video, cXc Art, cXc Ideas, cXc Pueblo and more. Funds will also pay for all other cXc operational costs, employees, promotion, events, etc. cXc will publish a running list of expenses with corresponding transactions on Github.

cXc spending transactions are inherently transparent and can be tracked here: dplug4purple and here currentxchng.

Requirements & Restrictions

Participating in the direct listing requires that you adhere and agree to the requirements, restrictions, terms and conditions laid out in disclaimer.md and legal-agreement.md

💥 FIND OUT MORE ABOUT cXc 💥

🗺️ Experience cXc.world 🌎

👁️ Step into our vision

🎥 Add Music to cXc.world

💸 Get to know our Economy

Follow cXc on Social Media 📱🌎

🖼️ Instagram
🐦 Twitter
📺 YouTube
🐝 Hive
🏘️ Hive Community
🔑 Discord Musician Community (Collab channels + more)
🔺 Reddit
✈️ Telegram
🌊 Wavvy Music Accolades (NFT Music Awards)

(cXc) Roadmap 🛣️

Top 64 Charts on cXc.world 🟣 PURPLE Rewards Daily 🌞 for Top Youtube Music 🧞🎸

Douglas James Butner — Thu, 15 Apr 2021 16:01:13 +0000

One 🟣 PURPLE is rewarded every 5 minutes to Top 64 Charts in each cXc Music Dapp, starting with cXc Music

This 1 🟣 PURPLE / Time Unit reward will be given out daily as 288 🟣 PURPLE divided linearly among the Top 64 tracks ranked by Sol Ups. When we release the next cXc Mapps, the reward will be 288 🟣 PURPLE each.

288 SOL per person and 288 PURPLE for Top Charts of cXc.world mapps daily. These are the gears of the Purple Economy.

Youtube Music + Purple Rewards

Artist rewards go to the owner of the Youtube channel which uploaded the song embedded in a cXc.world post. Through linking a WAX account to the channel that uploaded the video, we can pay the rightful account PURPLE, and even split payments up to 12 ways. If a Youtube video's owner is not on cXc.world, pending reward is reserved and will be claimable upon linking the Youtube account.

Top Charts 🌎

Top Charts show up tailored to every search you do on cXc.world.

The Top Charts shown on cXc.world rank the top music by adding up Blu Ups + Sol Ups for any time period a viewer wishes.

Default Ranking on cXc.world = Total Blu Ups + Sol Ups

In addition to the default ranking, users on cXc.world can choose to see Top Charts by the following:

Only Sol Ups
Only Blu Ups
Only Big Ups Ups

PURPLE Rewards + Top 64 Charts 🌎🟣

Total Blu Ups + Sol Ups ranking is used when we send out emails and updates about current music trends. It's the default for everything except PURPLE rewards.

The Top 64 Charts used to reward creators in PURPLE use Only Sol Ups to determine who gets rewarded.

Linear rewards are used where #1 gets 64 times what #64 gets 1.

Using Only Sol Ups gives PURPLE rewards a more democratic nature, as no one can buy SOL (unlike BLUX).

Also, because cXc executes the Sol Up actions on-chain (unlike BLUX) we can have a say in preventing fake accounts, etc from trying to game the system.

Note: This algorithm is subject to change. We plan to incorporate rewards for local charts as well as global charts after cXc.world is more popular. That's going to change things, but the linear rewards will always remain.

What if a charting creator doesn't have an account on cXc.world?

We'll keep a record on how much each account is owed using the Youtube video's account information. Later, when they create an account, they will be able to claim all the PURPLE owed to them automatically by connecting the youtube account to their WAX account, used as cXc.world login.

🔵 BLUX Value Beyond Charts

🔵 BLUX gives you the same exposure for people looking at the map. With this boost in exposure, good music should attract more Sol Ups, which in turn earns more 🔵 BLUX. So good music has a good ROI using 🔵 BLUX, subjectively bad music = bad ROI.

All the while, the Sol Ups that a creator attracted will have the potential to earn them 🟣 PURPLE

An artist could buy 🔵 BLUX, spend it to Blu Up their latest song, which could attract organic Sol Ups, giving them more BLUX. 🔵 BLUX can be sold or spent for more Blu Ups, so the artist can get back the money they spent, or more. If the Sol Ups were enough that they made the Top 64 Global Charts for the day, they'll earn 🟣 PURPLE too.

💥 FIND OUT MORE ABOUT cXc 💥

🗺️ Experience cXc.world 🌎

👁️ Step into our vision

🎥 Add Music to cXc.world

💸 Get to know our Economy

🎁 OFFICIAL cXc MERCH 🛍️

👕 Shop cXc High-fashion (Made in 🇨🇦)

🔴 cXc Stickers, shirts + More on Redbubble

Follow cXc on Social Media 📱🌎

🖼️ Instagram
🐦 Twitter
📺 YouTube
🔑 Discord Musician Community (Collab channels + more)
🐝 Hive + 🏘️ Hive Community
🔺 Reddit
✈️ Telegram
🌊 Wavvy Music Accolades (NFT Music Awards)

💰🤑 Swaps (Instant Liquidity) 🟡🟣 WAX/PURPLE ~~ 🟡🔵 WAX/BLUx

📈 Trade 🟣 PURPLE/WAX 🔵 BLUx/WAX 🟣🔵 PURPLE/BLUx

Looking for deets? Dive into our Purple Explainer

🛣️ Roadmap 🚙

Blockchain music service cXc Music debuts “Gold Version” of Music Mapp, Teases Beta Release on WAX Blockchain

Douglas James Butner — Wed, 28 Oct 2020 21:26:19 +0000

One Hive Dapp already turning heads gets a fresh, gilded makeover, and teases fans with what’s to come.

Today, Current X Change LLC released a new version of their flagship web app, cXc Music Gold Version (cxc.world). This release features an improved interface, with brand new map theme and updated dot styles. Gold Version is the final minor version of Alpha before cXc Music will move to the highly-anticipated Beta release, which will include advanced geotemporal music charts and an economic system built on the WAX blockchain.

cXc Music is a colorful mapp (map app) of music that any artist can use as a free platform to get their music heard. Gold Version features three new map styles:

Gold Version, which will be the default until Beta is released,
Pumpkin, a limited-time seasonal style, and
Pachamama. In addition, the dots have been improved at the wider zoom levels, offering a better view of the spectrum of music around the world.

When an artist adds their music, by simply double-clicking the location recorded, it shows up as a small dot. As listeners upvote the music, it becomes bigger, increasing the chances a visitor will find it.

Already, the mapp is home to over a thousand pieces of unique music from around the world, which are color-coded by Genre. A quick look at cxc.world shows that the majority of music has been posted to United States and Europe, and the most popular genres are Hip Hop and Electronic.

How to Apply a new Map Style

Go to cxc.world 📱 + 💻

Click 🗺️ Style -> 🗺️ Background

CHOOSE

🟨 Gold Version 🟨 ⬛

🎃 Pumpkin 🟧 🟪

🌍 Pachamama 🟦 🟩

cXc Music’s creator Douglas Butner had this to say about the release.

“Gold Version symbolizes the first ray of light shining as we open the door to the future. Minor release is mostly cosmetic, but it signals that we are just one step away from Beta, where the real magic starts.”

That magic is the world’s first curation system based on time-backed currency, a concept that Douglas believes will cause a massive redistribution of attention and information flow.

“Time-backed currency, given freely to each individual can be applied to re-shape how information flows and where attention goes. I believe this idea can change everything from media to society itself, and music is a wonderful place to start.”

Experience Gold Version at cxc.world on mobile or desktop.

Press Info

Release Date
28 October 2020

Company Info
Current X Change LLC (cXc) is a software company based in Maryland, USA. For more info about cXc, visit currentxchange.com

Contact Info
Douglas Butner
douglas@cxc.world