Learn Dart - Pre-Requisite Skills & Environment Setup

#Introduction

Welcome to the Learn Dart series! This series takes you from conceptual foundations all the way to production readiness with Dart — a modern programming language created by Google for building mobile, web, command-line, and server applications. In total there are 23 episodes organized into six learning phases.

Before writing Dart code, there are a number of basic skills and software you must have. Why are these pre-requisites important? Because Dart has a distinctive way of thinking: a sound type system, strict null safety, an asynchronous model based on Future and Stream, and a package ecosystem from pub.dev. If this foundation is not solid, the coming episodes will feel heavy.

Episode 0 is your roadmap. We'll make sure your basic skills are in place, set up the environment, install the Dart SDK, choose an IDE, and run the first verification. Once this episode is done, the remaining 22 episodes can be followed comfortably.

#Basic Skills You Must Master

#Basic Programming

Make sure you're comfortable with variables, conditions, loops, and functions in any language. Dart uses syntax similar to C and JavaScript, so experience in both languages will help a lot. Get into the habit of writing small programs regularly until patterns like if, for, while, and function definitions feel automatic.

#Object-Oriented Programming

Dart is a thoroughly object-oriented language — even functions and primitive types are objects. Concepts like class, inheritance, encapsulation, and interface are not just theory; they're everyday tools. Understand how objects store state and expose behavior through methods before moving into episode 5.

#Asynchronous Programming

Dart handles I/O and concurrency with an asynchronous model based on Future and Stream. You need to understand the difference between synchronous and async operations, as well as the concept of callbacks and promises from other languages. Episode 7 covers this topic in depth, but a basic understanding is required from now on.

#Command Line and Version Control

This entire series is done from the terminal: dart run, dart pub get, and dart test will be your daily companions. Master directory navigation, running commands with arguments, and reading error output. In addition, get in the habit of using Git to track every project change.

#Software You Need to Prepare

#Latest Dart SDK

First, install the Dart SDK latest version. At least version 2.12 so sound null safety is active, and version 3.x is highly recommended at the time this series was written. Linux users can use the apt repository, macOS users can use Homebrew, and Windows users can use Chocolatey or the official installer from dart.dev. Verify the installation with:

dart --version

The output will show a version like Dart SDK version: 3.5.4 along with the target architecture. If the command is not found, make sure the SDK's bin directory is on your system PATH.

#IDE and Extensions

Choose one primary editor and install its Dart extension:

• VS Code: the official extension called Dart from the Dart team, complete with debugging and hot reload.
• IntelliJ IDEA: the Dart and Flutter plugins from JetBrains, suitable if you like feature-rich refactoring.
• Android Studio: the built-in Dart plugin, ideal if your main target is Flutter development.

Verify that the IDE recognizes the SDK by checking the list of extensions:

code --list-extensions | grep dart

In VS Code, the Dart-Code.dart-code extension should appear. The command code --list-extensions | grep dart helps you confirm the extension is installed correctly.

#Flutter SDK and Git

If you want to develop mobile and web applications (episodes 11-12), also install the Flutter SDK, which bundles the Dart SDK into one toolchain. For version control, make sure Git is available:

flutter --version
git --version

Flutter ships its own Dart SDK. Git is needed to track your code and, later, for the CI/CD pipeline we'll build in episodes 14 and 19.

#Minimum Hardware Requirements

Dart and Flutter don't need a super powerful machine, but there's a recommended minimum standard so the learning experience stays comfortable:

• At least 8 GB of RAM — the IDE, analyzer, and compiler are fairly memory-hungry.
• Dual-core CPU or better — builds and hot reload run much faster with extra cores.
• 10 GB+ of free storage — the SDK, pub cache, and build artifacts take up space.

#Environment Verification

Finally, make sure everything works. Create a file named hello.dart and run it:

void main() {
  print('Halo dari Dart!');
}

dart run hello.dart

The output Halo dari Dart! means your SDK, IDE, and environment are ready to use. The command dart run hello.dart compiles the script with JIT and then runs it — we'll break down this process in detail in episode 3.

#Conclusion

Key takeaways:

• Master basic programming, OOP, and asynchronous concepts before diving deep into Dart.
• Install the latest Dart SDK and verify it with dart --version.
• Install the Dart extension in VS Code, IntelliJ, or Android Studio.
• Prepare the Flutter SDK and Git for the mobile, web, and CI/CD episodes.
• Make sure your hardware meets the minimum of 8 GB RAM, dual-core CPU, and 10 GB storage.
• Verify your environment by running your first hello.dart program.

In the next episode 1, we'll discuss the history, background, and why to choose Dart — Dart's birth at Google, its comparison with JavaScript, Kotlin, and Swift, and the reasons this language is worth mastering in 2026. Make sure your environment is ready, because the Learn Dart journey is just beginning!