DEV Community: superXdev

Tutorial install Ghost CMS di VPS Ubuntu

superXdev — Fri, 01 Aug 2025 11:56:43 +0000

Ghost CMS adalah platform Content Management System (CMS) open-source yang dirancang khusus untuk penulisan dan penerbitan konten seperti blog, artikel, dan newsletter. Berbeda dari CMS lain seperti WordPress yang lebih serbaguna, Ghost berfokus pada pengalaman menulis yang bersih, cepat, dan minim gangguan dengan UI yang minimalis.

Ghost dibangun menggunakan Node.js, sehingga memiliki performa yang tinggi dan efisien dibanding CMS yang berbasis PHP. Platform ini banyak digunakan oleh blogger, jurnalis, dan penerbit digital karena kemudahan integrasi, kecepatan loading, dan fitur modern seperti editor Markdown, real-time preview, dan dukungan berbagai media (gambar, video, embed). Ghost juga bisa berfungsi sebagai headless CMS yang fleksibel untuk kebutuhan pengembangan web lebih lanjut.

Secara garis besar, Ghost cocok untuk mereka yang ingin membuat blog atau portal konten yang ringan, cepat, dan mudah dikelola tanpa fitur kompleks yang tidak diperlukan. Ghost adalah proyek open-source sehingga dapat dihosting sendiri secara gratis, atau menggunakan layanan hosting resmi berbayar di https://ghost.org

Berikut tutorial lengkap dan terstruktur untuk install Ghost CMS di VPS Ubuntu:

1. Persiapan Awal

Pastikan kamu memiliki VPS dengan sistem operasi Ubuntu (disarankan versi 20.04 atau 22.04 LTS).
Pastikan sudah memiliki akses root atau user dengan hak sudo.
Domain sudah diarahkan ke IP VPS (jika ingin menggunakan domain).
Perbarui sistem VPS:

  sudo apt update && sudo apt upgrade -y

2. Instalasi Prasyarat

A. Install Nginx (web server)

sudo apt install nginx -y
sudo ufw allow 'Nginx Full'

B. Install dan Konfigurasi MySQL

sudo apt install mysql-server -y
sudo mysql_secure_installation

Setelah itu login ke MySQL dan buat database untuk Ghost:

sudo mysql -u root -p
CREATE DATABASE ghost_db;
CREATE USER 'ghost_user'@'localhost' IDENTIFIED BY 'strong_password';
GRANT ALL PRIVILEGES ON ghost_db.* TO 'ghost_user'@'localhost';
FLUSH PRIVILEGES;
EXIT;

3. Install Node.js LTS dan npm

Ghost CMS berjalan menggunakan Node.js, jadi pasang Node.js versi terbaru (LTS):

# Download and import the Nodesource GPG key
sudo apt-get update
sudo apt-get install -y ca-certificates curl gnupg
sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key | sudo gpg --dearmor -o /etc/apt/keyrings/nodesource.gpg

# Create deb repository
NODE_MAJOR=22 # Use a supported version
echo "deb [signed-by=/etc/apt/keyrings/nodesource.gpg] https://deb.nodesource.com/node_$NODE_MAJOR.x nodistro main" | sudo tee /etc/apt/sources.list.d/nodesource.list

# Run update and install
sudo apt-get update
sudo apt-get install nodejs -y

4. Install Ghost-CLI secara global

Ghost-CLI memudahkan instalasi dan setup Ghost CMS.

sudo npm install -g ghost-cli

5. Buat Direktori untuk Ghost dan Atur Permission

Misal menggunakan domain domainkamu.com:

sudo mkdir -p /var/www/domainkamu.com
sudo chown $USER:$USER /var/www/domainkamu.com
sudo chmod 775 /var/www/domainkamu.com
cd /var/www/domainkamu.com

6. Instalasi Ghost CMS di Direktori

Jalankan perintah instalasi Ghost dengan CLI:

ghost install

Selama proses instalasi, kamu akan diminta memasukkan beberapa konfigurasi penting:

URL Blog (misal: https://domainkamu.com)
MySQL Hostname (biasanya localhost)
MySQL Username (contoh: ghost_user)
MySQL Password (password untuk user database MySQL)
Nama Database (contoh: ghost_db)
Pilih untuk mengaktifkan konfigurasi Nginx (Yes)
Pilih untuk mengatur SSL otomatis dengan Let’s Encrypt (Yes)
Pilih mengaktifkan Systemd untuk manajemen service (Yes)
Pilih untuk memulai Ghost setelah instalasi selesai (Yes)

7. Konfigurasi Nginx dan SSL

Ghost-CLI biasanya akan mengkonfigurasi Nginx dan SSL otomatis menggunakan Let's Encrypt jika kamu memilih opsi tersebut saat instalasi. Jika tidak, kamu dapat membuat konfigurasi Nginx manual seperti ini:

server {
    listen 80;
    server_name domainkamu.com www.domainkamu.com;

    location / {
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header Host $http_host;
        proxy_pass http://127.0.0.1:2368;
    }
}

Aktifkan konfigurasi dan restart Nginx:

sudo ln -s /etc/nginx/sites-available/domainkamu.com /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl restart nginx

Untuk SSL, jika belum otomatis, gunakan Certbot:

sudo apt install certbot python3-certbot-nginx -y
sudo certbot --nginx -d domainkamu.com -d www.domainkamu.com

8. Mengakses Ghost CMS

Buka browser ke alamat https://domainkamu.com untuk melihat blog Ghost.
Untuk mengakses panel admin, buka https://domainkamu.com/ghost.

9. Manajemen Layanan Ghost

Beberapa perintah dasar pengelolaan Ghost menggunakan CLI:

Restart Ghost:

  ghost restart

Stop Ghost:

  ghost stop

Start Ghost:

  ghost start

Download ebook Solidity gratis

superXdev — Mon, 28 Oct 2024 06:48:47 +0000

Setelah berbulan-bulan menyusun materi, akhirnya saya dapat membagikan ebook yang dirancang khusus untuk membantu teman-teman yang tertarik menjadi web3 developer atau solidity engineer. Ebook ini lebih dari sekadar tutorial; ini adalah panduan komprehensif dari dasar hingga tingkat lanjut, ditulis dengan gaya ringkas yang merangkum berbagai dokumentasi menjadi satu sumber yang mudah dipahami.

Apa yang Akan Kamu Pelajari di Ebook Ini?

Dasar-Dasar Blockchain, Ethereum, & Solidity:
Pelajari fondasi utama dari teknologi blockchain, pengenalan terhadap Ethereum, dan bagaimana Solidity digunakan untuk mengembangkan smart contract.
Konsep Dasar Pemrograman di Solidity:
Buku ini membahas setup environment yang dibutuhkan, tipe data, fungsi, dan berbagai konsep dasar yang akan membantu kamu membangun pemahaman teknis yang solid.
Materi Lanjutan:
Setelah menguasai dasar-dasar, kamu akan dibimbing untuk mendalami topik lanjut seperti event, error handling, debugging, dan keamanan dalam smart contract—hal-hal yang wajib dipahami seorang Solidity engineer.
Pola Desain (Design Patterns):
Dalam pengembangan smart contract yang efisien, pola desain seperti ownership, factory, dan proxy sangat diperlukan. Ebook ini akan membantu kamu memahami cara menggunakan pola-pola ini dalam proyek kamu.
Bonus Repositori Kode Smart Contract:
Sebagai tambahan, ebook ini juga menyertakan akses ke repositori kode smart contract sebagai referensi langsung yang bisa dipelajari dan diadaptasi ke dalam proyek kamu.

Unduh Ebook “Mastering Solidity” 100% Gratis!

Ebook ini tersedia secara gratis untuk kamu yang serius ingin menjadi seorang Solidity engineer atau web3 developer. Jangan lewatkan kesempatan untuk memiliki ebook ini secara cuma-cuma! Kamu dapat mengunduhnya melalui tautan berikut: Mastering Solidity Ebook.

Exclusive Free eBook: Mastering Solidity and Ethereum Development

superXdev — Sat, 22 Jun 2024 06:26:53 +0000

Are you ready to dive into the world of blockchain development and master the art of writing smart contracts with Solidity? I’m thrilled to offer the first 50 readers an exclusive opportunity to download my newly released eBook for free.

Why This eBook?

“Mastering Solidity: Comprehensive Guide to Solidity Development” is not just a book; it’s a complete resource designed to take you from a novice to a proficient Solidity developer. Drawing on my extensive experience in blockchain development, this eBook covers everything you need to know, from the basics of Solidity to advanced techniques in writing smart contracts. Here’s what you can expect inside:

Introduction to Blockchain Technology: I provide a thorough introduction to blockchain, highlighting its transformative impact across industries.
Solidity Fundamentals: Learn the syntax, structure, and core concepts of the Solidity programming language.
Smart Contract Development: Follow my guidance on creating, testing, and deploying smart contracts on the Ethereum network.
Advanced Solidity Concepts: Explore inheritance, libraries, and design patterns that are crucial for writing secure and efficient smart contracts.
Real-World Examples: I share practical examples and case studies from my experience to demonstrate the application of Solidity in real-world scenarios.
Best Practices and Security: Discover my top tips and techniques for writing secure, scalable, and maintainable code.
Comprehensive Reference Material: Access a wealth of resources and references to deepen your understanding and stay updated with the latest in Solidity development.

Whether you’re just starting or looking to enhance your existing skills, this eBook is your ultimate companion in the world of blockchain development.

Who Should Read This eBook?

This eBook is perfect for:

Beginner Developers: Those new to blockchain and Solidity who want a clear, structured introduction.
Intermediate Developers: Developers with some experience looking to deepen their knowledge and tackle more complex projects.
Experienced Developers: Seasoned developers seeking to stay current with the latest best practices and trends in Solidity development.
Tech Enthusiasts and Students: Individuals with an interest in blockchain technology who want to expand their understanding and skill set.

Exclusive Offer

For a limited time, I’m offering this invaluable resource for free to the first 50 readers. Don’t miss out on this opportunity to elevate your blockchain development skills. By downloading my eBook, you will:

Gain Early Access: Be among the first to explore this comprehensive guide and enhance your development skills.
Get Future Updates: Receive notifications about updates and additional resources related to Solidity and blockchain development.

How to Claim Your Free Copy

To claim your free copy of “Mastering Solidity: Comprehensive Guide to Solidity Development”, simply click the download link below. Hurry, as this offer is only available to the first 50 readers!

https://store.skydope.xyz/l/mastering-solidity-ebook

Advanced Solidity: Event Logging and Error Handling

superXdev — Wed, 29 May 2024 07:34:11 +0000

Solidity, the primary language for writing smart contracts on Ethereum, has unique features to handle logging and error management. Understanding these mechanisms is essential for developing robust and maintainable decentralized applications (dApps). This article delves into the intricacies of event logging and error handling in Solidity, providing a comprehensive guide for both beginners and experienced developers.

Introduction to Event Logging

What are Events?

In Solidity, events are a convenient way to log data on the Ethereum blockchain. They facilitate communication between smart contracts and their external users, enabling the creation of logs that can be easily accessed and monitored.

Events are typically emitted by smart contracts to signal that something significant has occurred. Once emitted, events are stored in the transaction logs of the blockchain, making them accessible for future reference.

Use Cases of Events

Events have several practical applications in smart contract development, including:

Transaction Notifications: Informing external applications when a particular action has taken place within the smart contract.
State Changes: Logging changes in the state of the contract for auditing and debugging purposes.
Data Storage: Storing historical data in an efficient manner that is cheaper than using contract storage.

Defining and Emitting Events

Syntax and Examples

Defining an event in Solidity is straightforward. The syntax involves the event keyword followed by the event name and parameters.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract EventExample {
    // Define an event
    event DataStored(uint256 indexed id, string data);

    // Emit the event
    function storeData(uint256 id, string memory data) public {
        emit DataStored(id, data);
    }
}

In this example, we define an event DataStored with two parameters: id and data. The event is emitted inside the storeData function, logging the values passed to it.

Indexed Parameters

Indexed parameters allow for efficient filtering of event logs. By marking a parameter with the indexed keyword, you can create up to three indexed parameters per event, enabling faster and more targeted searches.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract IndexedEventExample {
    // Define an event with indexed parameters
    event DataStored(uint256 indexed id, address indexed sender, string data);

    // Emit the event
    function storeData(uint256 id, string memory data) public {
        emit DataStored(id, msg.sender, data);
    }
}

In this example, both id and sender are indexed, allowing for efficient querying based on these parameters.

Subscribing and Listening to Events

Using Web3.js

To listen for events emitted by a smart contract, you can use Web3.js, a popular JavaScript library for interacting with the Ethereum blockchain.

First, you need to set up a Web3 instance and connect to an Ethereum node.

const Web3 = require('web3');
const web3 = new Web3('https://mainnet.infura.io/v3/YOUR_INFURA_PROJECT_ID');

// ABI of the contract
const abi = [/* Contract ABI here */];

// Address of the deployed contract
const address = '0xYourContractAddress';

// Create contract instance
const contract = new web3.eth.Contract(abi, address);

Then, you can subscribe to the event using the events property of the contract instance.

contract.events.DataStored({
    filter: {sender: '0xSpecificAddress'}, // Optional filter
    fromBlock: 0 // Start from block 0
}, (error, event) => {
    if (error) {
        console.error(error);
    } else {
        console.log(event.returnValues);
    }
});

This code listens for the DataStored event, optionally filtering by the sender address and starting from block 0.

Real-World Examples

Let's consider a more practical example: a simple voting contract.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract Voting {
    // Define events
    event VoteCasted(address indexed voter, uint256 proposalId);
    event ProposalAdded(uint256 indexed proposalId, string proposal);

    struct Proposal {
        string description;
        uint256 voteCount;
    }

    Proposal[] public proposals;

    // Add a new proposal
    function addProposal(string memory description) public {
        proposals.push(Proposal(description, 0));
        emit ProposalAdded(proposals.length - 1, description);
    }

    // Cast a vote
    function vote(uint256 proposalId) public {
        proposals[proposalId].voteCount++;
        emit VoteCasted(msg.sender, proposalId);
    }
}

In this example, we define two events, VoteCasted and ProposalAdded, to log voting activities and the addition of new proposals. These events can be listened to in a dApp to update the UI in real-time whenever a vote is cast or a new proposal is added.

Introduction to Error Handling

Importance of Error Handling

Error handling is crucial in smart contract development to ensure the integrity and reliability of the contract. Effective error handling helps prevent unexpected behaviors, secure funds, and provide meaningful feedback to users and developers.

Common Error Types

In Solidity, errors can be broadly categorized into:

Assertion Failures: Using assert to enforce invariants and check internal errors.
Requirement Failures: Using require to validate inputs and conditions.
Reversions: Using revert to handle errors explicitly and revert the state.

Assert, Require, and Revert

Differences and Use Cases

Assert

assert is used to check for conditions that should never be false. It is typically used to enforce invariants within the code. If an assert statement fails, it indicates a bug in the contract.

function safeMath(uint256 a, uint256 b) public pure returns (uint256) {
    uint256 result = a + b;
    assert(result >= a);
    return result;
}

In this example, assert ensures that the addition operation does not overflow.

Require

require is used to validate inputs and conditions before executing the rest of the function. It is commonly used for input validation and to check conditions that should be true before proceeding.

function transfer(address recipient, uint256 amount) public {
    require(balance[msg.sender] >= amount, "Insufficient balance");
    balance[msg.sender] -= amount;
    balance[recipient] += amount;
}

Here, require checks if the sender has sufficient balance before proceeding with the transfer.

Revert

revert is used to handle errors explicitly and revert the state changes. It can be used with or without an error message.

function withdraw(uint256 amount) public {
    if (balance[msg.sender] < amount) {
        revert("Insufficient balance");
    }
    balance[msg.sender] -= amount;
    payable(msg.sender).transfer(amount);
}

In this example, revert is used to handle the case where the balance is insufficient, providing an explicit error message.

Custom Errors

Solidity 0.8.4 introduced custom errors, which are more gas-efficient than revert strings. Custom errors allow developers to define and use specific error types within their contracts.

Example

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract CustomErrorExample {
    error InsufficientBalance(uint256 available, uint256 required);

    mapping(address => uint256) balance;

    function withdraw(uint256 amount) public {
        uint256 available = balance[msg.sender];
        if (available < amount) {
            revert InsufficientBalance(available, amount);
        }
        balance[msg.sender] -= amount;
        payable(msg.sender).transfer(amount);
    }
}

Security Best Practices in Solidity

superXdev — Sun, 19 May 2024 07:08:18 +0000

Security is a paramount concern in smart contract development due to the irreversible nature of blockchain transactions. Vulnerabilities in smart contracts can lead to significant financial losses and damage to reputations. In this chapter, we will explore essential security best practices for writing secure Solidity contracts, covering common vulnerabilities and strategies to mitigate them.

Common Vulnerabilities

Several common vulnerabilities have historically plagued smart contracts. Understanding these issues is the first step towards writing secure code.

1. Reentrancy

Reentrancy attacks occur when a contract makes an external call to another untrusted contract before updating its state. This allows the untrusted contract to call back into the original contract, potentially leading to unexpected behavior or draining of funds.

Example:

// Vulnerable contract
contract VulnerableBank {
    mapping(address => uint) public balances;

    function deposit() public payable {
        balances[msg.sender] += msg.value;
    }

    function withdraw(uint amount) public {
        require(balances[msg.sender] >= amount, "Insufficient balance");
        (bool success,) = msg.sender.call{value: amount}("");
        require(success, "Transfer failed");
        balances[msg.sender] -= amount;
    }
}

Mitigation

Use the Checks-Effects-Interactions pattern.
Employ a reentrancy guard.

Example:

// Safe contract using Checks-Effects-Interactions pattern and reentrancy guard
contract SafeBank {
    mapping(address => uint) public balances;
    bool private locked;

    modifier noReentrancy() {
        require(!locked, "No reentrancy");
        locked = true;
        _;
        locked = false;
    }

    function deposit() public payable {
        balances[msg.sender] += msg.value;
    }

    function withdraw(uint amount) public noReentrancy {
        require(balances[msg.sender] >= amount, "Insufficient balance");
        balances[msg.sender] -= amount;
        (bool success,) = msg.sender.call{value: amount}("");
        require(success, "Transfer failed");
    }
}

2. Integer Overflow and Underflow

Integer overflows and underflows occur when an arithmetic operation exceeds the maximum or minimum value a variable can hold. This can lead to unintended behavior.

Example:

// Vulnerable contract
contract Overflow {
    uint8 public value;

    function increment(uint8 _amount) public {
        value += _amount;
    }
}

Mitigation

Use the SafeMath library (in older versions of Solidity).
Utilize built-in overflow checks (Solidity 0.8.0 and later).

Example:

// Safe contract using built-in overflow checks
contract SafeMath {
    uint8 public value;

    function increment(uint8 _amount) public {
        value += _amount; // This will automatically revert on overflow in Solidity 0.8.0+
    }
}

3. Access Control

Improper access control can allow unauthorized users to perform critical operations on a contract.

Example:

// Vulnerable contract
contract AdminOnly {
    address public owner;

    constructor() {
        owner = msg.sender;
    }

    function changeOwner(address newOwner) public {
        owner = newOwner;
    }
}

Mitigation

Implement proper access control using modifiers.
Use libraries such as OpenZeppelin's Ownable.

Example:

// Safe contract using OpenZeppelin's Ownable
import "@openzeppelin/contracts/access/Ownable.sol";

contract AdminOnly is Ownable {
    function changeOwner(address newOwner) public onlyOwner {
        transferOwnership(newOwner);
    }
}

4. Denial of Service (DoS)

DoS attacks can prevent users from interacting with a contract by exploiting gas limits or other vulnerabilities.

Example:

// Vulnerable contract
contract Auction {
    address public highestBidder;
    uint public highestBid;

    function bid() public payable {
        require(msg.value > highestBid, "Bid too low");
        if (highestBidder != address(0)) {
            (bool success,) = highestBidder.call{value: highestBid}("");
            require(success, "Refund failed");
        }
        highestBidder = msg.sender;
        highestBid = msg.value;
    }
}

Mitigation

Avoid using call for sending funds.
Use pull over push pattern for withdrawals.

Example:

// Safe contract using pull over push pattern
contract Auction {
    address public highestBidder;
    uint public highestBid;
    mapping(address => uint) public refunds;

    function bid() public payable {
        require(msg.value > highestBid, "Bid too low");
        if (highestBidder != address(0)) {
            refunds[highestBidder] += highestBid;
        }
        highestBidder = msg.sender;
        highestBid = msg.value;
    }

    function withdrawRefund() public {
        uint refund = refunds[msg.sender];
        refunds[msg.sender] = 0;
        (bool success,) = msg.sender.call{value: refund}("");
        require(success, "Refund failed");
    }
}

5. Front-Running

Front-running occurs when a malicious actor intercepts and exploits a pending transaction before it is mined.

Mitigation

Use commit-reveal schemes.
Implement gas price limits.

Example:

// Simple commit-reveal scheme
contract SecureAuction {
    struct Bid {
        bytes32 blindedBid;
        uint deposit;
    }

    address public highestBidder;
    uint public highestBid;
    mapping(address => Bid) public bids;

    function placeBlindedBid(bytes32 _blindedBid) public payable {
        bids[msg.sender] = Bid({
            blindedBid: _blindedBid,
            deposit: msg.value
        });
    }

    function revealBid(uint _value, bytes32 _secret) public {
        Bid storage bidToCheck = bids[msg.sender];
        require(bidToCheck.blindedBid == keccak256(abi.encodePacked(_value, _secret)), "Invalid bid reveal");
        require(bidToCheck.deposit >= _value, "Insufficient deposit");

        if (_value > highestBid) {
            highestBid = _value;
            highestBidder = msg.sender;
        }
        bidToCheck.deposit = 0; // Reset deposit after reveal
    }
}

General Security Best Practices

1. Use Libraries and Standards

Use well-audited libraries such as OpenZeppelin for common functionalities like access control, token standards, and more.

2. Avoid Floating Pragma

Lock the Solidity version in your contracts to avoid incompatibility issues and unexpected behavior due to compiler updates.

Example:

// Good practice
pragma solidity ^0.8.0;

3. Conduct Security Audits

Regularly audit your smart contracts with professional security firms to identify and fix vulnerabilities.

4. Write Tests

Write comprehensive unit tests to cover various scenarios and edge cases. Use testing frameworks like Truffle or Hardhat.

5. Follow Best Practices for Contract Design

Implement the Checks-Effects-Interactions pattern to minimize reentrancy risks.
Use the pull over push pattern for handling funds.

6. Use Multisig Wallets

For contracts handling significant funds, use multisig wallets to increase security for fund management.

Example:

// Simple multisig wallet using OpenZeppelin
import "@openzeppelin/contracts/access/AccessControl.sol";

contract MultisigWallet is AccessControl {
    bytes32 public constant SIGNER_ROLE = keccak256("SIGNER_ROLE");
    uint256 public approvalsNeeded;
    mapping(bytes32 => uint256) public approvals;

    constructor(uint256 _approvalsNeeded) {
        approvalsNeeded = _approvalsNeeded;
        _setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
    }

    function submitTransaction(address to, uint256 value) public onlyRole(SIGNER_ROLE) {
        bytes32 txHash = keccak256(abi.encodePacked(to, value));
        approvals[txHash]++;
        if (approvals[txHash] >= approvalsNeeded) {
            (bool success,) = to.call{value: value}("");
            require(success, "Transaction failed");
        }
    }

    function addSigner(address account) public onlyRole(DEFAULT_ADMIN_ROLE) {
        grantRole(SIGNER_ROLE, account);
    }

    function removeSigner(address account) public onlyRole(DEFAULT_ADMIN_ROLE) {
        revokeRole(SIGNER_ROLE, account);
    }
}

7. Implement Circuit Breakers

Use circuit breakers to halt contract operations in case of emergencies.

Example:

// Circuit breaker pattern
contract EmergencyStop {
    bool private stopped = false;
    address private owner;

    modifier stopInEmergency() {
        require(!stopped, "Stopped in emergency");
        _;
    }

    modifier onlyOwner() {
        require(msg.sender == owner, "Not the owner");
        _;
    }

    constructor() {
        owner = msg.sender;
    }

    function toggleContractActive() public onlyOwner {
        stopped = !stopped;
    }

    function deposit() public payable stopInEmergency {
        // deposit logic
    }

    function withdraw(uint amount) public stopInEmergency {
        // withdraw logic
    }
}

8. Be Cautious with External Calls

Minimize and carefully handle external calls to prevent unexpected behaviors and vulnerabilities.

How to Set Up Your Development Environment for Solidity

superXdev — Fri, 17 May 2024 05:44:55 +0000

Setting up your development environment for Solidity is the first crucial step to diving into the world of Ethereum smart contract development. In this guide, we’ll walk you through the essential tools and configurations you need to get started, ensuring a smooth and efficient workflow.

Step 1: Install Node.js and npm

Node.js is a JavaScript runtime that is required for most blockchain development tools. npm is the package manager for Node.js, and you'll use it to install various development tools.

Download Node.js: Visit the official Node.js website and download the LTS (Long Term Support) version for your operating system.
Install Node.js: Follow the installation instructions for your OS.
Verify Installation:

   node -v
   npm -v

Step 2: Install Truffle

Truffle is a popular development framework for Ethereum that provides a suite of tools for smart contract development.

Install Truffle:

   npm install -g truffle

Verify Installation:

   truffle version

Step 3: Install Ganache

Ganache is a personal blockchain for Ethereum development that you can use to deploy contracts, develop applications, and run tests.

Download Ganache: Visit the Ganache page and download the version suitable for your OS.
Install Ganache: Follow the installation instructions for your OS.
Launch Ganache: Open Ganache to start your local blockchain.

Step 4: Install a Code Editor

Visual Studio Code (VS Code) is a popular choice for Solidity development due to its extensive range of extensions and ease of use.

Download VS Code: Visit the VS Code website and download the version for your OS.
Install VS Code: Follow the installation instructions for your OS.
Install Solidity Extension:
- Open VS Code.
- Go to the Extensions view by clicking the Extensions icon in the Activity Bar on the side of the window or by pressing Ctrl+Shift+X.
- Search for "Solidity" and install the Solidity extension by Juan Blanco.

Step 5: Initialize a Truffle Project

Create a New Directory for Your Project:

   mkdir MySolidityProject
   cd MySolidityProject

Initialize a Truffle Project:

   truffle init

This command sets up a basic Truffle project structure with the necessary directories and configuration files.

Step 6: Connect Truffle to Ganache

Configure Truffle to Use Ganache:

Open the truffle-config.js file in your project directory.
Add the following network configuration:

 module.exports = {
   networks: {
     development: {
       host: "127.0.0.1",     // Localhost (default: none)
       port: 7545,            // Standard Ethereum port (default: none)
       network_id: "*",       // Any network (default: none)
     },
   },
   // Other configurations...
 };

Step 7: Write a Simple Smart Contract

Create a Solidity File:

In the contracts directory of your project, create a new file named SimpleStorage.sol.
Add the following code to SimpleStorage.sol:

 pragma solidity ^0.8.0;

 contract SimpleStorage {
     uint256 public storedData;

     function set(uint256 x) public {
         storedData = x;
     }

     function get() public view returns (uint256) {
         return storedData;
     }
 }

Step 8: Compile and Deploy the Smart Contract

Compile the Contract:

   truffle compile

Deploy the Contract:

Create a new migration script in the migrations directory. Name it 2_deploy_contracts.js.
Add the following code:

 const SimpleStorage = artifacts.require("SimpleStorage");

 module.exports = function (deployer) {
   deployer.deploy(SimpleStorage);
 };

Run the migration:
```
 truffle migrate
```

Step 9: Interact with the Deployed Contract

Open the Truffle Console:

   truffle console

Interact with the Contract:

   let instance = await SimpleStorage.deployed();
   await instance.set(42);
   let value = await instance.get();
   console.log(value.toString()); // Should print '42'

Congratulations! You have successfully set up your Solidity development environment, written a simple smart contract, and interacted with it using Truffle and Ganache.

The basic of Solidity: Write your own Smart Contract

superXdev — Fri, 17 May 2024 05:37:30 +0000

Solidity is a statically-typed programming language specifically designed for writing smart contracts that run on the Ethereum Virtual Machine (EVM). As the backbone of Ethereum, it enables developers to create decentralized applications (dApps) that harness the power of blockchain technology. In this post, we'll delve into the core aspects of Solidity, including its use cases, contract structure, and key programming concepts.

What is Solidity?

Solidity is an object-oriented programming language influenced by C++, Python, and JavaScript, tailored for developing smart contracts on the Ethereum blockchain. Smart contracts are self-executing contracts with the terms directly written into code, facilitating, verifying, or enforcing the performance of a contract.

Use Cases of Solidity

Decentralized Finance (DeFi): Creating protocols for lending, borrowing, and trading without intermediaries.
Non-Fungible Tokens (NFTs): Developing unique digital assets for art, gaming, and collectibles.
Decentralized Autonomous Organizations (DAOs): Automating organizational governance and decision-making.
Supply Chain Management: Enhancing transparency and traceability in logistics.

Contract Structure

A basic Solidity contract consists of the following parts:

pragma solidity ^0.8.0;

contract MyContract {
    // State variables
    uint public myNumber;

    // Constructor
    constructor(uint _initialNumber) {
        myNumber = _initialNumber;
    }

    // Functions
    function setNumber(uint _newNumber) public {
        myNumber = _newNumber;
    }

    function getNumber() public view returns (uint) {
        return myNumber;
    }
}

Key Components:

Pragma: Specifies the version of Solidity.
Contract: Defines the contract name and encapsulates state variables and functions.

Variables and Types

Solidity supports various data types:

Boolean: bool
Integer: int and uint
Address: address
String: string
Bytes: bytes
Fixed-size Arrays: uint[10]
Dynamic Arrays: uint[]

Functions

Functions define the behavior of the contract. They can be public, private, internal, or external, dictating their accessibility.

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

Function Visibility

Public: Accessible by anyone.
Private: Only accessible within the contract.
Internal: Accessible within the contract and derived contracts.
External: Can only be called from outside the contract.

Modifiers

Modifiers alter the behavior of functions. Commonly used for access control.

modifier onlyOwner() {
    require(msg.sender == owner, "Not the contract owner");
    _;
}

function restrictedFunction() public onlyOwner {
    // Function logic
}

Operators

Solidity includes various operators for arithmetic, comparison, and logical operations.

Arithmetic: +, -, *, /, %
Comparison: ==, !=, <, >, <=, >=
Logical: &&, ||, !

Conditionals

Control flow uses if-else statements.

function checkNumber(uint _number) public pure returns (string memory) {
    if (_number > 10) {
        return "Greater than 10";
    } else {
        return "10 or less";
    }
}

Arrays

Arrays can be fixed or dynamic.

uint[] public dynamicArray;
uint[5] public fixedArray;

Structs

Structs allow grouping related data.

struct Person {
    string name;
    uint age;
}

Person public person = Person("Alice", 30);

Events

Events facilitate logging and are useful for off-chain interaction.

event NumberChanged(uint oldNumber, uint newNumber);

function setNumber(uint _newNumber) public {
    emit NumberChanged(myNumber, _newNumber);
    myNumber = _newNumber;
}

Error Handling

Solidity provides require, assert, and revert for error handling.

function withdraw(uint _amount) public {
    require(_amount <= balance, "Insufficient balance");
    balance -= _amount;
}

Inheritance

Solidity supports inheritance, allowing contracts to inherit properties and functions from other contracts.

contract Parent {
    uint public parentNumber;

    function setParentNumber(uint _number) public {
        parentNumber = _number;
    }
}

contract Child is Parent {
    function getParentNumber() public view returns (uint) {
        return parentNumber;
    }
}

Membuat Bot Telegram Sederhana dengan PHP dan Nutgram

superXdev — Sat, 25 Nov 2023 10:05:21 +0000

Halo teman-teman! Jika kamu tertarik membuat bot Telegram dengan PHP, yuk ikuti langkah-langkahnya 😊

Persiapan Awal

Akun Telegram dan BotFather:
- Pastikan kamu punya akun Telegram.
- Cari BotFather di Telegram dan gunakan perintah /newbot untuk membuat bot baru. Ikuti petunjuknya dengan senang hati.
Instalasi Nutgram:
- Gunakan Composer (teman terbaik PHP) untuk menginstal Nutgram. Ketik perintah berikut:
```
 composer require nutgram/nutgram
```

Struktur Dasar Proyek

Buat struktur dasar proyek seperti ini:

project/
|-- vendor/
|-- composer.json
|-- index.php

Kode PHP

1. Install Nutgram

composer require nutgram/nutgram

2. Buat file `index.php`

<?php

require __DIR__ . '/vendor/autoload.php';

use SergiX44\Nutgram\Nutgram;
use SergiX44\Nutgram\Telegram\Properties\MessageType;

// Ganti TOKEN_BOT_ANDA dengan token bot yang kamu dapatkan dari BotFather
$token = 'TOKEN_BOT';

$bot = new Nutgram($token);

$bot->onCommand('start', function(Nutgram $bot) {
    $bot->sendMessage('Halo! Selamat datang 😊');
});

$bot->onText('hello', function(Nutgram $bot) {
    $bot->sendMessage('Hello, how are you? 🌈');
});

$bot->onMessageType(MessageType::PHOTO, function (Nutgram $bot) {
    $photos = $bot->message()->photo;
    $bot->sendMessage('Nice pic!');
});

$bot->run();

3. Jalankan Bot

Jalankan bot dengan perintah:

php index.php

Gunakan Bot Kamu

Buka Telegram dan cari bot kamu.
Mulai percakapan dengan bot dengan perintah /start.
Coba ketikkan pesan hello dan kirim gambar.

Selamat! Kamu baru saja membuat bot Telegram sederhana dengan sangat mudah menggunakan Nutgram dan PHP. Silakan kembangkan lebih lanjut sesuai kreativitasmu! 🚀

Repository: https://github.com/superXdev/telegram-bot-nutgram

Untuk informasi lebih lanjut tentang Nutgram bisa cek web dokumentasinya di https://nutgram.dev

Belajar Django Framework (pengenalan)

superXdev — Tue, 19 Jan 2021 03:03:29 +0000

Belajar Django Framework (pengenalan) – Django adalah sebuah web framework yang di tulis dalam bahasa python yang digunakan untuk membantu pembangunan aplikasi web yang berkualitas. Django menyediakan berbagai kemudahan yang mana mengurangi banyak pekerjaan yang biasa dilakukan dalam pengembangan web.

Tutorial ini dibuat untuk developer maupun pemula yang ingin mempelajari bagaimana cara membangun sebuah website yang berkualitas dengan menggunakan Django dengan berbagai fitur dan kemudahan yang di tawarkannya.

Sebelum melanjutkan, pastikan kamu telah memahami dasar bahasa pemrograman python berbasis objek (OOP): control structures, data structures, variables, classes, objects, dll.

Mengenal django

Django adalah sebuah high-level Python web framework yang membuat pengembangan jadi lebih cepat dan terstruktur.

Sejarah dari django

2003 − Dimulai oleh Adrian Holovaty dan Simon Willison sebagai project internal di Lawrence Journal-World newspaper.
2005 − Dirilis pada Juli 2005 dan dinamakan Django, sama dengan gitaris jazz Django Reinhardt.
2005 − Cukup tangguh untuk menangani website dengan traffic yang tinggi
Saat ini − Sekarang django adalah project open source dengan kontributor dari seluruh dunia.

Filosofi desain

Django hadir dengan filosofi desain berikut:

Loosely Coupled − Django bertujuan membuat setiap elemennya dapat berdiri sendiri
Less Coding − Mengurangi kode sehingga proses pengembangan menjadi cepat
Don’t Repeat Yourself (DRY) − Semuanya dibuat dalam sekali dan tidak mengulanginya secara terus menerus
Fast Development − Filosofi Django adalah melakukan semua yang dapat dilakukan dengan memfasilitasi pengembangan yang sangat cepat.
Clean Design − Secara ketat mempertahankan desain yang clean di seluruh kodenya dan membuatnya mudah untuk mengikuti best practice

Kelebihan

Berikut adalah beberapa keuntungan menggunakan Django

Object-Relational Mapping (ORM) Support − Django menyediakan perantara antara model data dan database engine, serta mendukung banyak sistem database termasuk MySql, Oracle, Postgres, dll.
Django juga mendukung database NoSQL melalui Django-nonrel. Untuk sekarang, satu-satunya database NoSQL yang didukung adalah MogoDB dan google app engine
Multilingual Support − Django mendukung website dengan multibahasa melalui sistem internasionalisasi yang ada. Jadi kamu bisa mengembangkan situs web yang akan mendukung banyak bahasa.
Framework Support − Django memiliki dukungan bawaan untuk Ajax, RSS, Caching dan berbagai framework lainnya.
Administration GUI − Django menyediakan antarmuka pengguna siap pakai yang bagus untuk aktivitas admin.
Development Environment − Django hadir dengan server web yang ringan untuk memfasilitasi development dan pengujian aplikasi.

Metode MVC – MVT

Seperti yang telah diketahui, django adalah web framework Python. Dan seperti kebanyakan framework modern lainnya, django mendukung metode MVC. Pertama mari kita lihat apa itu metode Model-View-Controller (MVC), kemudian kita akan lihat django untuk metode Model-View-Template (MVT).

Ketika berbicara tentang aplikasi yang menyediakan UI (web atau desktop), biasanya kita berbicara tentang arsitektur MVC. Dan seperti namanya, metode MVC didasarkan pada tiga komponen: Model, View, dan Controller

Yang disebut dengan Model bagian yang berurusan dengan database. View adalah bagian antarmuka atau bagian depan aplikasi, segala sesuatu yang diproses dalam sistem akan ditampilkan pada view, sedangkan Controller adalah bagian yang menangani atau mengenengahi antar model dan view, jadi controller lah yang berperan sebagai pengendali dari sebuah sistem.

MVT pada Django

Model-View-Template (MVT) sedikit berbeda dari MVC. Perbedaan utama antara dua metode adalah bahwa Django sendiri menangani bagian Controller (Code yang mengontrol interaksi antara Model dan View) langsung dengan template. Templatenya sendiri adalah file HTML yang digabungkan dengan Django Template Language (DTL).

Diagram berikut mengilustrasikan bagaimana masing-masing komponen metode MVT berinteraksi satu sama lain untuk melayani permintaan user

ilustrasi interaksi komponen
Programmer membuat Model, View dan template kemudian URL akan dipetakkan dan Django melakukan tugasnya untuk menyajikannya kepada user.

Nah itulah pengenalan untuk sekarang, diartikel berikutnya kita akan memasukki bagian coding untuk mempelajari Django lebih dalam lagi. Di akhir pembelajaran kita akan membuat sebuah project sederhana dari nol menggunakan Django. Pastikan kalian tetap mengikuti artikel ini jika kalian tertarik untuk mempelajari Django dalam pengembangan web. Sekian dulu saya ucapkan terima kasih dan sampai jumpa.

Sumber: https://technozee.my.id/belajar-django-framework-pengenalan/

5 Langkah mendeploy laravel ke Heroku

superXdev — Mon, 18 Jan 2021 14:42:14 +0000

5 Langkah mendeploy laravel ke Heroku – Pada saat kamu mengerjakan project Laravel tentunya di tahap akhir kamu ingin membuat project web tersebut dapat diakses dari internet, tapi sebelum itu mungkin kamu ingin memastikan apakah semua fungsi web yang kamu buat tersebut dapat berjalan dengan normal sesuai yang di inginkan.

Oleh karena itu, untuk melakukan pengujian tersebut kamu tidak perlu langsung mengupload project ke server production. Daripada itu, cukup gunakan semacam layanan hosting/cloud yang gratis seperti Heroku

Heroku adalah platform cloud. Artinya, kamu tidak perlu khawatir tentang infrastruktur, kamu hanya fokus pada aplikasi kamu.

beberapa fitur Heroku:

Deployment Instan dengan Git push – build aplikasi kamu dilakukan oleh Heroku menggunakan skrip build
Banyak sumber daya Add-on (aplikasi, database, dll.)
Proses penskalaan – penskalaan independen untuk setiap komponen aplikasi kamu tanpa memengaruhi fungsionalitas dan performa
Isolasi – setiap proses (alias dyno) sepenuhnya terisolasi satu sama lain
Logging dan Visibilitas Penuh – akses mudah ke semua output logging dari setiap komponen aplikasi kamu dan setiap proses (dyno) Heroku menyediakan tutorial yang ditulis dengan sangat baik yang memungkinkan kamu memulai dalam beberapa menit. Juga mereka menyediakan 750 jam komputasi pertama secara gratis yang berarti kamu dapat memiliki satu proses (alias Dyno) tanpa biaya. Juga kinerjanya sangat bagus misalnya aplikasi web sederhana yang ditulis dalam node.js dapat menangani sekitar 60 – 70 permintaan per detik

Berikut 5 Langkah mendeploy laravel ke Heroku

1. Siapkan project laravel atau buat baru

Langkah pertama, kamu perlu menyiapkan project Laravel yang akan di deploy atau kamu bisa buat baru dengan mengetikan perintah berikut di terminal/cmd

composer create-project — prefer-dist laravel/laravel newProject

Setelah siap, masuk ke directory laravel kamu

2. Siapkan Heroku CLI

Pastikan sudah ada Heroku CLI pada komputer kamu, jika berlum terinstall silahkan buka link dibawah

https://devcenter.heroku.com/articles/heroku-cli#download-and-install

Download dan install Heroku Installer berdasarkan OS komputermu

Setelah Heroku berhasil terinstall, kembali ke terminal/cmd dan coba login dengan akun Heroku milikmu

heroku login

Akan muncul tampilan halaman login di browser dan jangan lupa klik tombol loginnya

Jika berhasil akan muncul tulisan seperti ini:

Apabila gagal bisa login dengan perintah berikut, masukkan email & password seperti login pada umumnya

heroku login -i

3. Buat file Procfile dan push project ke Heroku

Pada tahap ini, kamu perlu membuat Procfile (file konfigurasi heroku) di dalam folder utama project Laravel, masukkan kode berikut

web: vendor/bin/heroku-php-apache2 public/

Setelah itu save lalu kembali ke terminal/cmd dan ketikkan

git init

Untuk melakukan git initiation, lalu ketik perintah berikut untuk membuat app pada heroku kamu

heroku create

Kamu akan mendapatkan nama aplikasi dan nama repository seperti berikut

Setelah itu, lakukan commit dan push project ke Heroku dengan perintah

git add .
git commit -m “Initial Commit”
git push heroku master

Sekarang project Laravel kamu telah berhasil di-deploy, kamu bisa melihatnya di dahsboard heroku

Kamu bisa buka web yang telah di deplo tadi, tetapi pasti akan muncul pesan error 500, itu karena kita belum mengatur konfigurasi pada file .env

4. Menambahkan konfigurasi pada file .env

Pada tahap ini kita akan menambahkan beberapa pengaturan web didalam Heroku, klik menu Settings didalam app pada dashboard Heroku

Kemudian klik Reveal Config Vars

Tambahkan beberapa konfigurasi dari file .env pada project Laravel

APP_NAME=Shortlink
APP_ENV=production
APP_KEY=base64:hNKt9MqPA1/C2G1Ar4oCAIqF7y95oWDmJcjmtGQns3k=
APP_URL=http://arcane-thicket-31872.herokuapp.com
CACHE_DRIVER=cookie
SESSION_DRIVER=cookie
DB_DRIVER=pgsql

Maka hasilnya akan seperti ini

Sekarang jika kita membuka aplikasinya dengan mengklik Open app, sudah tidak akan ada error lagi

5. Konfigurasi Database

Langkah terahkhir yang harus dilakukan adalah menyetting database, jadi kita bisa melakukan migrasi pada Heroku. Untuk menggunakan MySql pada Heroku akan dikenakan biaya oleh karena itu, kita akan menggunakan database PostgreSQL karena gratis.

Pertama, klik menu Resources kemudian di bagian Add-ons klik Find more add-ons, kamu akan diarahkan ke halaman Add-ons

Pilih Heroku Postgres

Setelah itu, kita akan diarahkan ke halaman baru dan klik tombol Install Heroku Postgres pada sisi kanan

Setalah menglik tombol install kita akan di suruh memilih plan, tidak perlu di ganti apa2 langsung klik Provision add-on

Setelah selesai, kita bisa melihat Heroku Postgres ada di menu Resources pada dashboard

Kembali ke terminal/cmd dan ketikkan

heroku run php artisan migrate

Untuk menjalankan migrasi database pada aplikasi Laravel seperti biasa melalui Heroku

Selesai! sekarang aplikasi Laravel kamu sudah siap berjalan dan diakses oleh siapa saja 😀

Semoga postingan ini bermanfaat, saya ucapkan terima kasih dan sampai jumpa

Sumber: https://technozee.my.id/5-langkah-mendeploy-laravel-ke-heroku/

7 Daftar layanan hosting gratis terbaik 2021

superXdev — Thu, 14 Jan 2021 04:40:55 +0000

Membuat website saat ini menjadi sesuatu yang dapat menguntungkan jika kita dapat memanfaatkannya dengan baik, ketika pertama kali memulai mungkin kamu tidak ingin menghabiskan uang jika sekedar mencobanya.

Kebanyakan orang tentunya ingin sesuatu yang cepat, mudah dan gratis, ada banyak layanan hosting diluar sana, tapi sebagai pengguna kamu harus tahu bahwa tidak ada yang benar2 gratis pasti ada sesuatu yang dapat menjebakmu.

Menjalankan sebuah layanan hosting membutuhkan biaya yang besar pastinya, perusahaan yang menawarkan hosting gratis butuh uang entah bagaimana pun itu, jika tidak mereka bisa bangkrut.

Entah mereka menampilkan iklan di website kamu, membatasi traffic web, membatasi beberapa fitur dengan pilihan premium dan sebaginya. Beberapa iklan yang ada di web kamu mungkin tidak menampilkan sesuatu yang berhubungan dengan web kamu

Perbedaan hosting dan domain

Sebelum masuk kedaftar hosting, ada baiknya kamu mengetahui dulu apa itu hosting dan domain.

Hosting adalah tempat semua data yang akan di tampilkan di website kamu, informasi tersebut seperti gambar, tulisan, file video audio dan lain-lain.

Sedangkan domain sendiri merupakan alamat yang mengarahkan ke website Anda. Biasanya setiap jaringan komputer yang berhubungan memiliki alamat Internet Protocol (IP Address) yang terdiri dari angka. Kesulitan menghafal susunan angka itulah yang melahirkan domain berupa nama yang mudah diingat.

Daftar Hosting

1. 000webhost

Platform ini menawarkan hosting dan domain gratis selamanya dengan PHP, MySQL, cPanel & tanpa iklan. Fitur yang disediakan tak terbatas seperti Curl, GD2, XML, PHP Sockets, Zend, fopen(), Ioncube Loeder, dan .htaccess. Kapasitas memori yang diberikan sebanyak 300 MB dan bandwith 2GB dengan lebih dari 50 script populer (WordPress, Drupal, Joomla, dll).

Cara mendapatkan layanan gratis ini cukup mudah. Anda hanya perlu membuat akun untuk daftar hosting gratis sampai akun aktif, lalu pilih tool yang cocok dan segera buat website Anda dengan penuh kreatifitas. Jika suatu saat nanti ingin fitur yang lebih canggih, ada pilihan untuk upgrade ke versi premium. Kenapa harus bayar, jika bisa gratis?

2. AwardSpace

Penyedia hosting ini juga memiliki penawaran gratis hosting di antara paket lainnya yang bisa menyesuaikan anggaran. Paket gratis ini meliputi memori sebanyak 1000 MB, 5GB Bandwith sekaligus gratis domain, aktivasi akun secara instan, bahasa pemrograman PHP, CSS, HTML, dan tanpa iklan

3. Infinityfreehost

Salah satu layanan hosting yang menawarkan fitur gratis tanpa batas, di sini kamu akan diberikan penyimpanan, subdomain, bandwith unlimited! dan juga tanpa iklan yang akan ditampilkan di website kamu. Mendukung bahasa pemrograman PHP, MySql

4. 20i

20i adalah penyedia hosting web berbasis di Inggris yang telah ada selama beberapa tahun. Namun para pendiri di belakangnya, memiliki rekam jejak yang panjang dan terkenal. Perusahaan saat ini mempertahankan produk yang layak yang cukup baik, termasuk layanan CDN gratis mereka sendiri.

5. Wix

Wix adalah pembangun situs web (web builder) sederhana yang memungkinkan kamu membuat segala jenis website dengan mudah. Kamu dapat dengan cepat membuat blog dengan mudah, toko online, website bisnis, portofolio, situs fotografi, atau jenis website lainnya menggunakan Wix.

Hadir dengan drag and drop builder yang mudah digunakan yang dengannya kamu dapat menyesuaikan apa pun dan segala sesuatu di situs kamu dan membangun desain yang kamu inginkan. Jika kamu menginginkan pilihan yang lebih mudah, kamu dapat menggunakan Wix Artificial Design Intelligence (ADI) yang membangun situs dipersonalisasi untuk kamu berdasarkan jawaban kamu untuk beberapa pertanyaan sederhana. Untuk pengguna tingkat lanjut, ada juga opsi Kode Wix.

6. Github pages

Halaman Github (Github Pages) merupakan layanan hosting web statis yang diberikan oleh Github. Layanan ini diberikan secara gratis dan kita juga akan mendapatkan subdomain .github.io.

Kamu perlu memliki akun github dan sebuah repositori sebelum bisa di jadikan sebuah webiste, dan ini 100% gratis dan bebas dari iklan

7. Heroku

Heroku adalah sebuah cloud platform atau tempat penyimpanan yang menjalakan bahasa pemrograman tertentu.

Sebenarnya cara menggunakan Heroku hampir sama dengan hosting atau CPanel, yang membedakannya hanyalah cara deploynya saja. Untuk membuat proyek pertama di hosting lain harus melakukan upload file pada file managernya, tetapi berbeda dengan Heroku yang dimana hanya tinggal men-deploy saja menggunakan git.

Sumber: https://technozee.my.id/7-daftar-layanan-hosting-gratis-terbaik-2021/

5 Tips belajar pemrograman untuk pemula

superXdev — Wed, 25 Nov 2020 02:29:05 +0000

Di jaman yang serba digital ini tentu kita sudah tidak asing lagi dengan yang namanya aplikasi, web ataupun program, dan itu semua di buat olah seseorang yang biasa di sebut programmer. Dan seiring berjalannya waktu semakin banyak orang yang tertarik menjadi programmer.

Bisa di bilang menjadi programmer itu gampang-gampang susah loh, ada banyak sekali hal yang harus kita kuasai sampai akhirnya kita benar-benar dapat membuat sebuah aplikasi atau program. Tapi tenang saja, disini saya akan membahas langkah-langkah dan tips apa saja untuk yang baru mau mulai belajar pemrograman

1. Pahami dulu apa itu pemrograman

Sebelum memulai belajar dan melangkah lebih jauh ke dunia programming, alangkah baiknya jika kita pahami dulu apa sih pemrograman atau programming itu. Mungkin kebanyakan orang jika ditanya apa itu pemrograman akan menjawab seperti “pemrograman itu lo akan nulis kode di texteditor dan lo bisa bikin program”. Ga salah sih, tapi kurang tepat. Jadi jika pengertian singkatnya menurut wikipedia Pemrograman adalah proses menulis, menguji dan memperbaiki (debug), dan memelihara kode yang membangun suatu program komputer.[1] Kode ini ditulis dalam berbagai bahasa pemrograman.

2. Pilih bahasa pemrograman yang sesuai

Langkah awal yang perlu kamu lakukan sebelum belajar pemrograman tentu saja haris memilih bahasa pemrograman yang sesuai dengan jenisnya. Maksudnya apa? Programmer komputer juga terdiri dari beberapa jenis. Beberapa di antaranya, yakni web programmer, desktop application programmer, hingga software engineer programmer. Mereka bahkan memiliki istilah tersendiri, seperti full stack developer, backend developer, frontend developer, hingga data scientist. Setiap bagian-bagian tersebut memegang tugas yang berbeda-beda dengan bahasa program yang berbeda pula.

Berikut beberapa bahasa pemrogramana yang paling sering di gunakan:

PHP merupakan sebuah bahasa pemrograman yang biasa digunakan dalam pengembangan sebuah website apa aplikasi web, bahasa ini memakai paradigma OOP (Object Oriented Programming). Walaupun bahasa ini sudah cukup lama, namun kepopulerannya masih tinggi hingga saat ini.
Javascript adalah salah satu bahasa pemrograman paling populer saat ini dan bahkan di situs2 jobseeker banyak dicari developernya. Bahasa ini biasa digunakan pada pembuatan web (front-end bahkan back-end), mobile, desktop, game.
C# (dibaca: c-sharp) merupakan bahasa pemrograman berorientasi objek (OOP) yang diciptakan oleh microsoft untuk windows pada awalnya. Bahasa ini cukup populer digunakan dalam pembuatan game khususnya dengan UNITY
Python merupakan sebuah bahasa pemrograman paling populer saat ini, banyak digunakan dalam berbagai bidang baik itu web, game, mobile, bahkan AI (kecerdasan buatan). Selain itu, bahasa ini cukup mudah dipelajari bagi peluma karena syntaxnya yang simpel dan tidak ribet.

3. Mulai pelajari

Setelah kamu mengetahui bahas program apa saja dan sudah tahu ingin membuat apa, saatnya kamu mempelajari sekarang juga. Kamu bisa mulai dengan belajar tentang algoritma dasar atau membaca tutorial-tutorial tentang bahasa program yang ingin kamu kuasai.

4. Latihan membuat program sederhana dulu

Jika dirasa kamu sudah cukup paham dengan dasar-dasar bahasa program yang kamu pelajari, kamu bisa langsung buat aplikasi/program yang sederhana dulu. Dengan begitu kamu akan semakin memahaminya dalam penerapan sesungguhnya. Selain itu, dengan kita terus melatih membuat program-program yang walaupun sederhana kita akan banyak sekali mempelajari hal-hal yang mungkin tidak kita ketahui ketika mempelajari dasarnya saja.

5. Bergabunglah dalam komunitas atau grup-grup programmer

Di luar sana ada banyak sekali komunitas-komunitas yang terdapat banyak programer di dalamnya, dengan kita bergabung di komunitas atau grup programer tentunya selain kita mendapatkan kenalan-kenalan yang seminat dengan kita, kita pun bisa banyak belajar juga dengan mereka, menanyakan berbagai hal ketika kita dalam kesulitan saat membuat program atau sekedar berdiskusi.

Nah, itulah beberapa tips yang bisa membantu anda untuk belajar pemrograman khususnya untuk pemula. Biarpun kelihatannya ribet tapi sebenarnya mudah kok selama kalian yakin dan sungguh2 dalam mempelajarinya. Disarankan untuk fokus satu bahasa pemrograman dulu sampai kalian benar-benar memahaminya, karena untuk menjadi seorang programmer mengerti syntaxnya saja itu tidak cukup, kamu butuh pengetahuan dasar lainnya terlebih dulu seperti algoritma, struktur data & dll. Oke saya cukupkan sampai disini semoga tulisan ini bermanfaat, terima kasih dan sampai jumpa.

Sumber: https://technozee.my.id/5-tips-belajar-pemrograman-untuk-pemula