Meter Docs
Learn
  • Welcome to Meter!
  • 中文版文档
  • Overview of Meter
    • Introduction to Meter
    • Hybrid PoV Consensus Mechanism
    • MTR - The Metastable Coin
    • MTRG - Meter Governance Coin
    • On-Chain Auctions
    • The Meter Reserve
    • Meter's Ethereum Emulation Mode
  • Wallet Setup
    • Interacting with Meter Mainnet Using MetaMask
    • Interacting with Meter Mainnet Using Ledger
    • Adding Custom Tokens to MetaMask
    • Getting MTR for Gas
    • Revoking Contract Spend Limits
    • Specifying gas (GWEI) for transactions
    • Speeding Up/ Canceling Transactions
  • Meter Passport V2.0
    • Meter Passport Architecture
    • Salient Features
    • Bridge Fee
    • Programming Meter Passport
    • Tutorials for Using Meter Passport
    • MTRG Crosschain Info
    • Onboarding Passport for Your Project
    • Technical Guideline for Meter Passport
    • Security Audit for Meter Passport V2.0
  • Staking and Validation
    • Staking MTRG
      • How to Stake MTRG
        • Choosing Candidates
        • Factors affecting Staking Rewards
      • How to Stake Incremental MTRG
      • How to Undelegate MTRG
      • How to Unbound MTRG
      • Frequently Asked Questions
    • Running a Full Node on Meter Mainnet
    • Configure the Full Node to Validator Node
    • Meter Incentive Programs to promote decentralization
  • Mining
    • Meter Mining Guide
  • NFT Collections
    • Meter Community NFTs
  • Developer Documentation
    • Meter Developer Incentives
      • Meter Developer Grant Program
      • Meter TVL Incentive Program
      • Meter Gas Monetization Program
      • Meter Co-marketing Program
      • Meter DAPP Referral Program
    • Introduction to Developer Documentation
    • Developing with Remix, Ethers.js and Web3.js
    • Index Data with SubQuery
    • Meter Native TX RESTful APIs
    • Meterify API Documentation
      • meterify.eth
      • meterify.eth.Contract
      • meterify.eth.accounts
      • meterify.utils
      • meterify.module.options
      • Callbacks Promises Events
      • json interface
    • Meterify DApp Tutorials
    • Meterify Code Examples
    • Contributing to Meter and Our Documentation
      • Documentation Guidelines
        • API Documentation Guidelines
        • Tutorial Creation Guidelines
        • Code Example Guidelines
        • Article Writing Guidelines
Powered by GitBook
On this page
  • Audience
  • Structure
  • Use of Examples

Was this helpful?

  1. Developer Documentation
  2. Contributing to Meter and Our Documentation
  3. Documentation Guidelines

Tutorial Creation Guidelines

PreviousAPI Documentation GuidelinesNextCode Example Guidelines

Last updated 4 years ago

Was this helpful?

The value of tutorials as an instructional tool cannot be underestimated. Tutorials help guide a reader through a sequence of instructional steps, including relevant and informative explanations, in a way that other types of content are not designed for.

Writing attention-grabbing tutorials that provide a solution to a clearly identified problem or challenge is important for Meter technical documentation. The objective is to explain how to accomplish a set of tasks that works towards developing the solution, and also why each step or instruction is important. Explanations should be brief, informative, and focused on the main topic.

This guide is provided to ensure writers are equipped to create clear and interesting Meter specific tutorials, for both and non-development purposes such as . It will outline some important features of tutorials, and include best practices, but is a work in progress. There is a lot that goes into tutorial writing, and as this guide further develops, this will become a more robust tutorial in itself.

Audience

Avoid promoting generic third-party tools that don't add much value in the context of Meter.

For example, you may safely assume that the reader is already a developer familiar with code editors and syntax highlighting, so there is no need to mention these topics. However, something that is blockchain-centric and can make the reader's job easier when it comes to the specifics of the Meter blockchain may be worthwhile suggesting. It might even be worth writing a full tutorial about how to use it in a Meter context.

An example of this could be an IDE that is focused on web3, which would likely then be relevant for meterify as well.

Structure

Tutorials have three main sections: an introduction, a body, and a conclusion.

The introduction should begin with a problem statement or an objective and describe a proposed solution. It should be 2 or 3 paragraphs long. This does not include any table of contents, which should also be included in the same section, just before the tutorial body.

The body is where to include sub-headings representing the sequential steps of the tutorial. It might also include other sub-headings, such as those that provide links to further reading. These sub-headings should be arranged in sequence, starting off small, and then building up the knowledge necessary to understand the final product.

A concluding statement at the end should be one paragraph long. It should be a review of the tutorial to help consolidate what the reader has learned, and insight into how the solution solves the original problem. The conclusion can also provide one or more links for further reading.

Use of Examples

Tutorials address the need for better context than is typically possible with the API documentation alone. Building an example, showing each sequential modification, and explaining each step, is a great tutorial strategy. It helps to organize the overall flow of the tutorial, delivers the necessary context, and is an opportunity to provide insight into how each step fits into the overall objective.

One example might be a tutorial for using a development tool or framework that is compatible with meterify development. Relevant code snippets within the tutorial itself may suffice in that type of scenario, rather than including a corresponding example as well.

Keep the code blocks short, representing only the portions of code relevant to that step. Put a link to the full working example code somewhere at the start of the tutorial. This is convenient for the reader to see what the end result is going to look like before they start any further reading. And above all, make sure the example works.

Tutorials for developers will almost always focus on the use of meterify, and therefore should almost always correspond to a working . There may however be topics of interest to a developer that are less code related, or perhaps not specific to meterify, and therefore will not require any code example.

development
mining
Audience
Structure
Use of Examples
code example