Git Product home page Git Product logo

roadmapping's People

Contributors

serapath avatar

Watchers

avatar avatar avatar avatar

roadmapping's Issues

transition ethereum/play/issues and ethereum-play issues to playproject-io

@todo

curriculum planning

@todo

  1. LISTS:
  1. UNSORTED:

POTENTIAL PARTNERS: (we should get content from them)

inspiration
banner

open & maintain legal entity to do business

@todo

  • opening a company integration
  • accounting logic integration
  • add self employment guide in form of a generated workshop
  • built-in accounting system with automated reporting
  • automation of opening a legal entity (ltd?)

how to open a UK Ltd.?
what rights and duties does a director have?
what taxes to take care of?
what to include in an invoice?
@todo: document the process of paid contributions for self employed people who want to use a UK Ltd. company

org cleanup

@todo

2019.09.10-15:00Z | weekly partner meeting

location https://talky.io/play

AGENDA

  1. What was done since last meeting?
    • @ninabreznik
      1. try out hypertrie to fetch data for smartcontract.codes
      2. planning smartcontract-ui refactoring
      3. web3 foundation grant research
      4. mythx meeting
      5. social media marketing communication (twitter/gitter/facebook/feedbackform/...)
      6. planning new meetings (consensys) + interview planning
    • @serapath
      1. roadmapping#23 - transition ethereum/play repo and ethereum-play repos to playproject-io
      2. roadmapping#4 - curriculum planning
        • make hyper modular web component workshop
      3. fix smartcontract.codes to send compiler version to editor
      4. make pull request to gitter to theme embedded gitter chat
    • @polo13999
      1. put contracts into hypertrie structure on digital ocean
      2. change data structure regarding how to store contracts in hypertrie
    • @fionataeyang
      1. make input-payable component
      2. make input-bytes component
      3. review and fix styling in smartcontract-ui
      4. learning hyper modular web component development
      5. research & analysis of different approaches to styling and themes
    • @0mkara
      1. researching solidity ASTs
    • @shonemik
    • @alincode
    • @ookangzheng
    • @RangerMauve
    • @joshua-mir
      1. gather inforamtion about web3 foundation grants
      2. pull request for datdot (=pinning service for dats)
  2. How do roadmapping priorities currently look like?
  3. Create new meeting and plan what issues we will do until then

Devcon follow up

Chainsecurity:

  • get list of contracts audited by them (source + authors)
  • plan verX integration (app connect)
  • a call with Greg about the business models? gw@chain...

Sooho:

  • plan interaction (app connect)

BlockScout:

  • document how to run a node (+ syncing)
  • document how to add new contracts to the node

CurveGrid:

  • document how to run a node (+syncing)
  • see their JS VM (works same as Ethers.js, so no code adaptation needed) (app connect)
  • integrate their tool in smartcontract.codes (app connect)

EthPM:

  • figure out how to integrate it to smartcontract.codes flow

Solidity compiler (Daniel):

  • setup a repo with Budo & DB with contracts

Etherscan:

  • share how they can run a node and contribute new verified contracts to it
  • [email protected]

Waleth:

  • show how to run a node and retreive data

Brownie:

  • integration to post contracts to the DB

Truffle:

  • integration to post contracts to the DB

Remix:

  • integration to post contracts to the DB

Alpha wallet:

  • show how to run a node and retreive data

Jade research

  • Gary & Jim - schedule a call

Ammar (Consensys)

  • how he can contribute

Embark:

  • see module for subscribing to events/state changes etc.
  • integration to post contracts to the DB

Barry Whitehat

  • snarks/mixers examples (filters on smartcontract.codes)

Aragon

  • Aragon contracts

Open Zeppelin

  • Aragon contracts

make interaction-graph module

@todo

  • make interaction-graph module
  • use play themed interaction-graph for displaying roadmap & tasks with progress
  • use play themed interaction-graph module for skilltree/curriculum
    • crawl workshop.json to print skilltree as json (network structure)
    • find or build a json graph visualisation library (e.g. "graph dracula" or "cytoscape")
      • maybe based on interactive SVGs?
    • visualise play skilltree json so users can navigate to individual workshops
    • use to make landing page (code camp module) for play.ethereum.org
    • improve the edges between nodes
    • display workshop icons in nodes
    • add cool themes for the skilltree

use cases

IMPORTANT

  • think about how to make sure we find all workshops hosted anywhere (but keep it decentralised)
  • It might be necessary to scroll or "drag" the skilltree around to see all parts.
  • the skilltree should ideally have a "deterministic layout", so that if new workshops are being added, the skilltree map structure looks the same to somebody who returns to it after some time

A single entry in the skilltree might later include information about:

The skilltree module should be usable to generate:

  • a codecamp static page, which displays exactly a manually selected set of workshops (sub-skilltrees)
  • a skilltree displays all workshops it can find by crawling workshop.json's and needs/unlocks and continues indefinitely as long as it finds more workshops

publish/create/display (paid) tasks

@todo

  • test your knowledge with paid tasks (bounties/gitcoin - either 5$ tasks or real client tasks, always earn while you learn)
  • ensure legal compliance

2019.08.27-15:00Z | weekly partner meeting

location https://talky.io/play

AGENDA

  1. What was done since last meeting?
  2. How do roadmapping priorities currently look like?
  3. Create new meeting and plan what issues we will do until then

planned code camps & coding meetup bootstraps & presentations (workshops, talks, ...)

@todo

automate devops

@todo

  • concept for devops (tests, CI, releases, ...)
  • archive finished versions from roadmap into comment and link to github releases
  • define browser compatibility standard
  • setup basic testing
  • setup: alpha, beta & stable deployments
  • optimize bundle until eventually switching to import https://github.com/browserify/tinyify
  • add semi-automated release process e.g. https://github.com/ethereum/remix/releases
  • community outreach & decentralised social scaling as a standardized regular output

future plans

@todo

  • build hyper data wallet
    • @output ❓ hyper data wallet
  • build wizardamigos e-learning system to teach ppl how to build p2p apps
    • @input ❓ hyper data wallet
    • @output ❓ wizardamigos elearning system
  • build discord like gig chat system
    • @input ❓ hyper data wallet
    • @input ❓ wizardamigos elearning system
    • @output ❓ discord like gig chat system
  • buildhyper based email system - maybe partner with telios
    • @input ❓ hyper data wallet
    • @input ❓ discord like gig chat system
    • @output ❓ email management system
  • buildhyper personal health communication and record management system
    • @input ❓ email management system
    • @output ❓ personal health communication and record management system

@info

...

smart contract workshop (fitbit, oraclize)

@todo

  • when the user signs up, the encrypted token should be stored in the contract (it's encrypted and because it's used to get beginStep it's now bound to our contract, so nobody else who would copy the encrypted token could use it
  • the methods kill and ownerWithdrawal should be removed
    • because we don't want to replace centralised servers with almighty owners
  • for funders, the minimum funding should be bigger than the users signup fee of 0.1
  • users should NEVER have to update their steps
    • instead, the frontend should fetch current steps from the fitbit web api to compare it to beginStep to show the user his progress
  • when the owner closes the round, the contract should now loop over all users and use their fitbit token to get their end steps
    • maybe you also need to save a beginDate and then compare the endDate to check if the average daily steps were 10.000
    • the user can close the round only once, so calling the method again will not be possible so the contract can never use the encrypted token again to check step data from users
  • if possible - this probably expensive transaction to get all steps from all users should be either paid by the funds in the contract or the owner should be re-imbursed for this by taking that amount from the funds
  • when users come to the page after the round was closed, they should be able to "withdraw" their funds from the contract to get them into their metamask account
  • add ability to set a custom duration (like e.g. 5 minutes) when deploying a contract instance, but (by default it's 30 days) => owner should only be allowed to close contest rount AFTER duration is over
  • allow https://alincode.github.io/fitbit-dapp#dev to show "debug buttons"
    • e.g. beginning of all javascript checks localStorage.debug = locatin.hash === "#dev"
    • including a button to load a different "contract address"
  • when in #dev mode, display a button to change contract instance address, so app loads with different contract
  • switch the entire contract to ROPSTEN test network
  • display on website how much time is left until the contest can close
    • e.g. steps in the next ${duration} ${unit ="days"} (10.000 steps per day)
    • add The Fitbit Contest ends in ${ duration - (now - start)} ${unit}
  • display to owner a button to "end contest" (but if duration is not over yet alert('wait for ' + duration - (now - start))
  • fix: updateAllUserStep should add userAddr parameter.
  • oraclize often out of gas, it is hard to test.
  • use public test chain, it need to waiting very long time to get callback
  • Oraclize Token Encryption
  • Fitbit: Presentation for distributed health
    • prepare videos/screencasts for learners
    • Can you try to find "test fitbit accounts"? so that learners can sign in and use the dapp?
    • Could you make 1-5 minute screencast videos to explain the topics used in the dapp?
      • fitbit and how to use fitbit api (get token to make requests)
      • use fitbit api to get steps (javascript fetch)
      • use oraclize web api (to encrypt request/token)
      • use web3.js to call contract methods (e.g. send encrypted request token to contract)
      • use oraclize in a solidity contract ("computational query?" and what it can do)
    • people can join the competition, pay the entrance fee & those who actually successfully finish split the funds amognst themselves
    • some sponsors can join and add funds to the pool
  • Prepare Fitbit Demo for Remix folks
  • Can you make a PR to update the english "wording" to improve/change some variable or function names and maybe some other text (...maybe code comments, etc...)
  • fix metamask issue alincode/fitbit-dapp@99c2348

RESULT:

It would:

  1. use fitbit's api https://dev.fitbit.com/build/reference/web-api/
  2. so fitbit users can "sign up" and stake some "money/tokens" (alternatively a health insurance provider could take a small percentage of peoples monthly insurance payment and stake it)
  3. and fitbit users then get personalised fitness challenges
  4. ...if people achieved or over achieved those challenges, they get back what they staked OR they get back money from their health insurance provider - essentially making their insurance cheaper
  5. ...if people under achieved their staked tokens or part of their monthly insurance fee goes to all the ones who achieved or over achieved :-)

THIS could be the "baseline scenario" and now we could

  1. connect to the fitbit API using some kind of oracle provider service thing (and teach people how to use those)
  2. build the contract
  3. build the frontend (dapp)
  4. write some tests
  5. maybe figure out a good scenario which can be used for debugging
  6. etc....

The result should be presentable in multiple short captured screencasts:

  1. The resources we produce should be chunked into parts that are consumable in 5-10 minutes at most for each of the chunks
  2. We can then later use those in online workshops (or documentation) for other people to learn it

the above is meant as a theme (or use case) on which we can show all the different aspects ethereum users might need to think of when using the ecosystem + we can come up with a "story line" that presents all of the remix features - and then split the presentation in small individually presentable chunks :-) ...because in the real world, people want to use existing web services and databases to either fetch some data from or write some new data to.

Links:

To try out:

I build a base function for use Integration call api, and Integration dapp.

Good news is work now, even code still ugly.

https://github.com/alincode/devon4

This is the smart contract information page.
https://rinkeby.etherscan.io/address/0x696a92a0d6b36628dc92e32daba92b85df1c5d5c

1st line: oraclize callback
2st line: 2st call smart contract callUserAPI method
3st line: oraclize callback
4st line: 1st call smart contract callUserAPI method, it should don't need to pay any ether, because 1st call for free.
5st line: it is created smart contract transaction.

Bad news is, it is very unstable in test chain. Even I paid 1 ether, it always out of gas. it should don't need so many gas, it is just so simple smart contract. I asked the oraclize team, I am waiting for the their reply.

the function is correct, because not always happened "out of gas", I can get correct callback sometime.
oraclize

2018-08-17 16 30 47

2018-08-17 16 32 21

https://github.com/oraclize/ethereum-bridge
https://github.com/oraclize/truffle-starter

oraclize1
oraclize2
oraclize3

The goal is to code a dapp (solidity + frontend) that pulls data from a regular web API.
diagram

slides

Prepare the slides

To include:

  • oraclize price provable-things/ethereum-api#10
  • question of privacy (if token is sent over blockchain vs. if all the competition is hosted on centralized server, problem of trust (escrow), problem of transparency (did they pay all contestants?))
  • don't replace central server with a smartcontract which has an almighty owner
    • part of workshop: improve concept of contract by thinking through edge cases
      • (e.g. does the contest happen if only one participant signs up?)

Story

Problem

Lack of trust in NGOs creates problems when trying to raise donations for a cause. With the use of Smart contracts we can make the flow of donations from donors to recipients transparent.

Cause - example

DONORS
Help us promote a healthy lifestyle by incentivizing people to be more active in their daily life.

CONTESTANTS
Win 1.000$ reward for tracking your steps every day for a month. To make it hassle-free for you to get rewarded for staying active, the smart contract automatically syncs your steps from Fitbit. It checks at the end of the month if you hit your step goal every day. If you did, you will receive the full reward, if not, your reward will be reduced by -33$ for every day you didn't manage to hit your goal.

standardize user feedback

@todo

  • add chat integration to apps
  • add report a bug button
  • standardize a way to get in touch with the "supply network" of components/apps/...

2019.09.17-15:00Z | weekly partner meeting

location https://talky.io/play & https://gitter.im/ethereum/play

AGENDA

  1. What was done since last meeting?
  2. How do roadmapping priorities currently look like?
  3. Create new meeting and plan what issues we will do until then

virtual agent generator

@todo

  • use play-ed#6: minimal "browser first" testing library + test reporter
  • exercise/lesson validation (dressed as a "virtual customer" regarding the user experience)
  • add technical concept around how to enable this without centralised servers
  • implement infrastructure
  • create task creating virtual-customers and pay with a made up "play token"
    • think about play token mechanics

Idea

  1. The workshop app lists tasks (exercises, exams, ...)
  2. Users choose a task and solve the code inside the editor and then submit
  3. In case of exercises, the submitted code is checked/validated by a bot
    • if pass => bot merged the users pull request to solve the exercise
    • if fail => bot comments on pull request and asks user to try again
  4. User codes until pull request is merged and gets rewarded (eventually with a payment)

goal:
Refining this workflow for users helps us to tune our tooling until it is good enough to add exams (=paid tasks) where the bot is replaced with a real "customer" who wants to outsource work and pays the learner.

@bit-shift

Related

more

implementation inspiration

INSPIRATION (helper librarys for AST checking)

These are used for JavaScript, but to have something similar for solidity could be very useful

If so - we could brainstorm about the API and how to make it module (e.g. AST tree walker, etc...)
Also - the alternative to a convenient AST checking library would be to focus on the compiler output and compare metadata and abi, but this won't help us a lot when it comes to figure out details about implemented methods :-) ...so yeah, what do you think?

roadmapping concept & updates

@todo

  • #32
  • delete all files but README.md, .github/ and LICENSE
  • add description
  • #33
  • #9
  • #29
  • sort roadmapping issues
  • define process of outsourcing tasks and how to pay for it
    • How to earn if you areca middle man (affiliation) - brainstorm incenive models
    • add bounties (first manual outsourcing process, later define automated with smart contracts)
    • people who want to get paid for working on tasks need to be self employed
    • we want to outsource tasks to remote working self employed individuals and pay for it
    • initially we might have contractors to work 8 - 15 hours per week until we switch to pure task based
    • we integrate http://github.com/ethereum/financial-tools/
    • we want to cater easy tasks to beginners who have never worked remote
    • initially we want to prefer outsourcing paid tasks to self employed individuals from underprivileged backgrounds
      • where the average hourly payment is ~3-5 USD/h and want to at least pay double (6-10 USD/h)
    • as soon as people are more experienced and want to work more regular, we want to slowly raise compensation to "western levels"
  • standardise github issue format + tooling
  • in-browser compatible multi-repo-management tooling concept
    • and develop a form to interact with standardized issue so that we can make sure to not break the parseability by editing the issue manually (=> essentially github issues become the "backend" for the tool)
    • develop a library to checkout and parse the issue to be able to setup all code & repo's involved for development to solve the issue
    • context
      1. Every development issue is related to code in files in one or more modules (e.g. dependencies).
      2. In order to solve the issue, a developer who wants to contribute needs to clone all involved repositories, solve the issue and commit and push the changes to make a pull request.
    • goal
      1. standardize issues to automatically be able to check out and set up all involved code and repositories in a way that a developer can start immediately with solving the issue and knowing where to look.
      2. do (1.) in a way that will work inside a browser, so that it wont be necessary to use the command line
  • show ROADMAP and SPEC on page
  • show a list of all ecosystem modules in alphabetical order on github page
  • create organisation page module for https://playproject-io.github.io/roadmapping/ to display project management
  • add convenience editor to consistently add/edit issues and sync with github issues via API
  • add notifications about upcoming tasks/events
  • sync all github issue etc... activity to file changes in a "backup" repository to have planning under version control in git
  • factor out all code into seperate tool module and make a static page specifying the data in standard format, but using tool module to generate the page
    • playproject-io/roadmapping - to contain the tool as a module and to use "dashboard" tool and sync to "roadmapping" repo data, but work on github and/or data
    • playproject-io/roadmapping - to contain the backup of all issues, etc... activity in files/folders
      • issues, etc... as "staging area" which is (can be) committed to the "organisation" repo
  • make concept of how to switch data from mono /organisation backup repo to a module specific repo folder to make it multi repo rather than mono repo when it comes to issues
  • switch from github accounts to authorise to dat backend
  • organisation - introduce and practice using playproject-io/roadmapping tool
  • repository management (e.g. bot to replace hackmd?)
    • add bot to track all stats of play ecosystem contributions (e.g. modules, contributors, PRs, commits, ...)
    • display activity in ethereum/play repo static page
  • roadmapping#20: make interaction-graph module
  • roadmapping#3: automate devops

check:

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❤️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.