Global Leader in Blockchain Education
Blockchain Training Alliance courses and
certifications are built strategically for corporations
Ethereum On Demand Training

Ethereum Developer Training On Demand

Price
Regular price $499.00 Sale

Snapshot

Duration:
Time:
Delivery:
20 Hours
60 Days of Access
On Demand
100% Lecture
Ways to Train: Public Classroom
Instructor-led Virtual
Onsite at Your Location

Course Details

About On Demand Learning

This On Demand video training class on Ethereum developers is designed for programmers and developers who want to take a comprehensive deep dive in writing smart contracts and building applications that interact with them. This course provides detailed overviews of Ethereum, smart contracts, and the development language, Solidity. The student will be exposed to Ethereum’s adaptable feature set which allows the developer to design decentralized applications for countless applications.

This class is designed for those who prefer to develop the skills they need on their time and at their own pace. You will be provided 60 days of access to the class and all supporting course material.

This training will give you the the ability to start, stop and rewind the chapters. This class will not support questions or have a live instructor-interaction; if you would like live training please view our Instructor-led Ethereum Class.

This course also prepares you for the Certified Blockchain Developer Ethereum exam. The exam voucher is included with class (a $300 value); exams are delivered globally at Pearson VUE.

What's Included

With class you will receive:

  • 60 Days of unlimited access to course content
  • Certified Blockchain Ethereum Developer exam voucher
  • Ability to stop, pause rewind and move through all chapters
  • Sample quiz questions in Course Content
  • Exam Prep Digital Course Material: View from anywhere and any device

Release Date

October 1, 2018

    Class Objectives

    • Understand the tools needed to create smart contracts
    • Write and read secure Solidity code
    • Avoiding and Understanding of Costly Bugs and Blockchain Programming Errors
    • Understanding of the development and deployment workflow
    • Better Understand of the Benefits and Disadvantages of Blockchain Technologies
    • Use and create private networks, test networks and the public main network
    • Understand how transactions are structured
    • How Gas and gas costs can be calculated correctly
    • Write a Smart Contract on the Ethereum Blockchain and be able to publish and interact with it
    • Understand the difference between Web3.js and truffle-contract
    • Install, configure and use the Truffle Framework
    • Write tests with the Truffle Framework that contribute to the stability of smart contracts
    • Deploy to IPFS and understand how to access files

    Target Audience

    • People who have heard of Ethereum, but do not know how to start
    • People who already have some experience with programming in general, but no solidity experience
    • People who want to know how this technology works
    • People who wrote simple solidity code but want to dive deeper into the subject

     Prerequisites

    • Absolutely necessary: ​​Basic knowledge in JavaScript / HTML
    • Absolutely necessary: ​​A computer (Windows / Linux / Mac)
    • Advantageous: basic knowledge in C ++ / Java, data types
    • Advantageous: basic knowledge with git repositories
    • Advantageous: basic knowledge of solidity

    Course Outline

    Section 1: Introduction

    1. Who I am and what we will create during this course
    2. Course materials and how this course is structured

    Section 2: Remix and Solidity Basics

    1. What is Remix and what can we do with it?
    2. We delete and create a new file
    3. We look at Remix: Starting, Stopping and Interacting with Smart Contracts
    4. We read and write in our Smart Contract
    5. These are functions and the constructor
    6. These are modifiers and this is how you use them
    7. These are variables, addresses and the msg. object
    8. Here's everything you need to know about mappings
    9. This is how you use structs in solidity
    10. Summary

    Section 3: Our Notary Functionality in Solidity

    1. We define what our Blockchain Notary needs to know
    2. That's the basic construct of our Smart Contract
    3. Together we implement and test the build functions
    4. Now we read the values ​​again
    5. Let's expand our features by events
    6. Summary

    Section 4: Understanding Tools and Ethereum

    1. Understanding the debugger in remix
    2. This is how the gas costs for the execution of smart contracts are calculated
    3. This is an ABI array and that's what it is used for
    4. Understanding Ethereum Networks (Main, Ropsten, Rinkeby, Kovan, Developer) and Clients (Geth, Parity, Ganache)
    5. How do Accounts, Private and Public Keys work?
    6. Summary

    Section 5: Understand the Different Blockchain Nodes

    1. The Remix JavaScript Virtual Machine
    2. We install and use Ganache and that's a mnemonic
    3. We connect Ganache with Remix
    4. The difference between Ganache and Ganche-CLI
    5. This is MetaMask and that's how you install it
    6. We look into MetaMask
    7. How to use MetaMask with Smart Contracts
    8. This is Go-Ethereum, how you install it and that's how you use it
    9. How to create a private network with the genesis.json file
    10. Private networks: Go-Ethereum, Mining and MetaMask
    11. Private Networks: Go-Ethereum, CORS, Keystore, and Remix
    12. Summary

    Section 6: Local Development with Truffle

    1. How to install Truffle
    2. Setup for Smart Contract Programming with Atom
    3. Let's take a look at a standard Truffle project
    4. Let's adapt Truffle to our notary Smart Contract
    5. We write unit tests for our Blockchain notary
    6. We test exceptions with truffle and ganache
    7. Testing transactions and calls in truffle and ganache
    8. Our first solidity test with Truffle and Ganache
    9. The difference between tx.origin and msg.sender
    10. Testing exceptions in solidity - the low-level function address.call ()
    11. Summary

    Section 7: How to Develop Distributed Applications in HTML and JavaScript

    1. This is Web3.js
    2. Start a transaction with Web3.js
    3. HTML pages and Web3.js
    4. The difference between Web3.js and Truffle Contract
    5. Make working with truffle boxes easier
    6. Adapt Truffle Webpack with our project
    7. Our notary in HTML and JavaScript
    8. Manage uploads with files - Hashing on the fly
    9. Read out entries with a truffle contract again: our finished notary

    Section 8: Publication of our project

    1. Different access methods to different networks
    2. We get some test ethers for Ropsten
    3. Release with Infura and Truffle
    4. The finished HTML and JavaScript
    5. This is how IPFS works

    Section 9: Final Section

    1. Thanks for taking part
    2. Bonus Lecture

          Who We Have Trained