1. Introduction

In this tutorial, we will delve into the world of decentralized applications, or dApps, exploring some of the most popular platforms for their development, including Ethereum, EOS, and Tron. These platforms offer unique features and benefits that we will discuss in-depth.

By the end of this tutorial, you will understand:
- The strengths and weaknesses of Ethereum, EOS, and Tron as dApp platforms.
- What unique features each platform brings to the table.
- How to write simple contracts for each platform.

Prerequisites:
- Basic knowledge of Blockchain and Smart Contracts
- Familiarity with JavaScript and Solidity

2. Step-by-Step Guide

Ethereum

Ethereum is a decentralized platform that runs smart contracts. Contracts are written in a language called Solidity.

Strengths

• Mature and well-documented.
• Large developer community.
• Supports complex applications.

Weaknesses

• High transaction costs (gas fees).
• Scalability issues.

Here's an example of a simple contract in Solidity:

pragma solidity ^0.5.16;

contract SimpleContract {
    function sayHello() public pure returns (string memory) {
        return "Hello, World!";
    }
}

EOS

EOS is a platform for the development of dApps that focuses on speed, scalability, and user experience.

Strengths

• Fast transaction times.
• No transaction fees.
• Supports complex applications.

Weaknesses

• Less mature than Ethereum.
• Smaller developer community.

Here's an example of a simple contract in EOS:

#include <eosio/eosio.hpp>

using namespace eosio;

CONTRACT hello : public contract {
  public:
    using contract::contract;

    ACTION greet(name user) {
      print("Hello, ", name{user});
    }
};

Tron

Tron is a platform that focuses on content sharing and entertainment. It uses a unique protocol called Delegated Proof of Stake (DPoS).

Strengths

• High throughput.
• Lower fees than Ethereum.
• Good for entertainment-focused apps.

Weaknesses

• Less mature than Ethereum.
• Smaller developer community.

Here's an example of a simple contract in Tron:

pragma solidity ^0.4.23;

contract TronContract {
    function sayHello() public pure returns (string) {
        return "Hello, World!";
    }
}

3. Code Examples

You've already seen some simple contracts above. Let's dive a bit deeper.

Ethereum Contract

Here's a slightly more complex contract that stores and retrieves a number.

pragma solidity ^0.5.16;

contract StoreNumber {
    uint private number;

    function store(uint num) public {
        number = num;
    }

    function retrieve() public view returns (uint){
        return number;
    }
}

uint private number: This line declares a private variable number of type uint (unsigned integer).

function store(uint num) public: This function takes an unsigned integer as input and stores it in our private variable. The public keyword means this function can be called from outside the contract.

function retrieve() public view returns (uint): This function returns the currently stored number. The view keyword indicates that this function does not modify the state of the contract.

EOS Contract

Here's a contract that greets a specified user:

#include <eosio/eosio.hpp>

using namespace eosio;

CONTRACT greetuser : public contract {
  public:
    using contract::contract;

    ACTION greet(name user) {
      print("Hello, ", name{user});
    }
};

ACTION greet(name user): This action takes an EOS account name as input and prints a greeting message to that user.

Tron Contract

Here's a contract similar to our Ethereum example:

pragma solidity ^0.4.23;

contract StoreNumber {
    uint private number;

    function store(uint num) public {
        number = num;
    }

    function retrieve() public view returns (uint){
        return number;
    }
}

4. Summary

In this tutorial, we've explored Ethereum, EOS, and Tron as platforms for developing dApps. We've discussed their strengths, weaknesses, and unique features, and have seen some simple contract examples for each platform.

Next steps in your learning journey could include:
- Exploring more complex smart contract examples.
- Learning about other dApp platforms such as NEO or Cardano.

For additional resources, check out the official documentation of each platform:
- Ethereum
- EOS
- Tron

5. Practice Exercises

1. Write a contract that stores and retrieves a string instead of a number.
2. Write a contract that allows only the contract's creator to change the stored number.
3. Write a contract that keeps track of the number of times a function has been called.

Solutions and tips for these exercises will depend on the platform you're working with, but the goal is to get you thinking about and experimenting with the unique features of each platform. Happy coding!