Starting with a new platform or language can feel overwhelming, right? That's where the Internet Computer Protocol (ICP) comes in. It's built to make creating and deploying entire web applications smooth, secure, and scalable.

If you're a new developer, grasping the Internet Computer's architecture, features, tools, and workflows is key. It can be tough to know where to begin on your own, so we've created a clear, step-by-step tutorial series.

Introducing the Developer Journey

This article introduces the "Internet Computer Developer Journey," a written content and video for learning IC development. It covers everything from basic architecture to deploying an SNS, emphasizing hands-on practice (canister coding/deployment) after the initial level.

Let’s take a deeper dive into each level and the components of each level.

Level 0: Pre-Flight Operations

At the introductory level, the Developer Journey starts with taking a look at the Internet Computer’s architecture and how it works, including the essential terms and tools that are the foundation of developing on the ICP. Specifically, this level consists of an overview of the IC and relevant terms, setting up a development environment, and an introduction to programming languages, tools, and canisters.

0.1 Overview of the Internet Computer: In the very first level of the Developer Journey, readers will get acquainted with the IC through an overview of the essential components, such as:

• An overview of the Internet Computer Protocol’s stack, including the peer-to-peer layer, consensus layer, message routing layer, and execution layer.
• An overview of chain-key cryptography.
• An overview of canisters and smart contracts.
• An overview of tokens and cycles.
• An overview of governance through the NNS and an SNS.
• An overview of the IC’s Internet Identity authentication service.

0.2 Internet Computer terminology: In this module, developers are introduced to some of the most commonly used terms on the IC, such as:

• Terms referring to different concepts, such as actor, agent, certified variables, principal, proposal, and replica.
• Terms relating specifically to canisters, such as canister development kit, canister state, controller, query, state change, and wallet.
• Terms describing different tools and products, such as dfx, ledger, and Motoko.

0.3 Developer environment setup: In the next module, developers are walked through setting up their local developer environment. For developing on the IC, the developer environment includes tools such as the IC SDK, a code editor, git, Node.js, and a command line interface.

0.4 Introduction to canisters: Canisters are at the very core of developing applications on the IC. This module introduces what a canister is, its architecture, and discusses the different types of canisters that can be developed.

0.5 Introduction to languages: In this page, we discuss the different languages that can be used to develop dapps, and provide a base-level introduction to the two primarily supported languages: Motoko and Rust.

0.6 Introduction to dfx: dfx is the DFINITY command-line execution environment for the IC SDK. It is the primary tool used for creating, managing, and deploying dapps onto the Internet Computer. This module covers dfx’s basic usage and syntax, upgrading to the latest version, and explores the default project template that new projects created with dfx use.

Level 1: Space Cadet

In the space cadet level, developers get started creating dapps hands-on by first looking at a live demo dapp deployed to the Motoko playground. Then, a comprehensive introduction to Motoko prepares developers for the remainder of the level that covers writing, deploying and managing their canisters.

1.1 Exploring a live demo: Before beginning to develop dapps, this module explores a live, deployed canister that utilizes the Motoko playground through the `dfx deploy — playground` command.

1.2 Motoko level 1: This module provides an introduction to Motoko by covering the Motoko syntax, basic concepts and terms, and simple functions such as declaring an actor, printing values, and passing text arguments.

1.3 Developing your first dapp: In this tutorial, developers create their very first dapp on the Internet Computer that provides a simple poll dapp with a frontend canister and a backend canister.

1.4 Acquiring and using cycles: To deploy dapps on the IC mainnet, we’ll need to acquire cycles. Cycles are used to pay for a canister’s resources on the IC. This module covers how to acquire and use cycles.

1.5 Deploying canisters: This module details how to deploy dapps to the IC mainnet.

1.6 Managing canisters: In this module, various canister management functions are covered such as how to obtain information on the canister, managing the canister’s controller identities, topping the canister up with cycles, and deleting a canister.

Level 2: Space Explorer

At this point in the Developer Journey, it’s important to cover more advanced canister concepts and workflows, such as canister upgrades, advanced canister calls, and third-party canisters. This level also introduces Candid, an interface description language, and unit testing.

2.1 Canister upgrades, storage, and persistence: When a canister’s code needs to have changes made, the canister must be upgraded. In this tutorial, in addition to canister upgrades, memory types such as stable storage and stable variables are covered.

2.2 Advanced canister calls: This module takes a look at advanced canister calls, such as query and update calls, composite queries, and inter-canister calls.

2.3 Using third-party canisters: For certain workflows, using third-party canisters and integrating them with a dapp is important to provide functionalities such as authentication. This module covers using the command `dfx pull` to utilize third-party canisters.

2.4 Introduction to Candid: Candid is an interface description language that has unique support for IC features. In this tutorial, Candid types, values, and service descriptions are discussed.

2.5 Unit, integration, and end-to-end testing: Testing code prior to setting it live in production is an important step in the development process. In this tutorial, unit testing, end-to-end testing, and integration testing are covered.

Level 3: Continuing Your IC Journey

Building your first dApp is just the beginning. The ICP offers a rich ecosystem for developing a wide range of decentralized applications. Continue learning, exploring new features, and experimenting with different technologies to expand your skills and build more complex dApps. The ICP community is a great place to find inspiration, collaborate with other developers, and contribute to the growth of the decentralized web.

Start coding today!

Follow the ICP Hub Sahara community for more information, meet other Devs and explore the ecosystem.