Starting using Dart: A Seamless Transition For Developers

The Very Good Ventures team has been busting myths about Flutter and its performance. Today, we’re diving deeper into Dart, Flutter’s programming language. Stick around to see why it’s a piece of cake for devs to pick up! 

‍

While Dart might be new to some developers, it’s intentionally designed to be easy to learn. For those familiar with JavaScript, Kotlin, Java, or Swift, Dart offers a smooth learning curve, enabling developers to get up to speed quickly. Its syntax and structure are accessible, especially for anyone experienced with C-style languages. Let’s explore some code examples to highlight these similarities!

1. Creating Variables

You will see that there is not much difference when creating variables. Let’s see how to create:

Dart

Dart uses var, final, and const to declare variables. The final keyword is for immutable variables, while const is for compile-time constants.

// Type inferred
var name = "Alice"; 
// Explicit type
String city = "Paris"; 
// Immutable
final age = 30; 
// Compile-time constant
const pi = 3.14; 

‍

Kotlin

Kotlin uses val (immutable) and var (mutable).

// Type inferred
var name = "Alice" 
// Immutable, explicit type
val age: Int = 30 
// Immutable constant
val pi = 3.14 

‍

Swift

Swift uses var (mutable) and let (immutable).

// Mutable variable
var name = "Alice" 
// Immutable, explicit type
let age: Int = 30 
// Immutable constant
let pi = 3.14 

2. Creating Classes

When creating classes, there are a few more differences, but you will see that it is very easy to switch from Kotlin or Swift to Dart.

Dart

Classes in Dart are defined using the class keyword.

class Person {
  const Person({
  required this.name, 
  required this.age
  });
  
  final String name;
  final int age;

  void greet() {
    print('Hello, my name is $name.');
  }
}

Kotlin

Allows you to declare and initialize class properties directly in the primary constructor, avoiding boilerplate code.

class Person(val name: String, val age: Int) {
    fun greet() {
        println("Hello, my name is $name.")
    }
}

Swift

Swift classes use the class keyword and require initializers unless default values are provided.

class Person {
    var clothes: String
    var shoes: String

    init(clothes: String, shoes: String) {
        self.clothes = clothes
        self.shoes = shoes
    }
}

‍

3. Defining Functions

The functions are very similar in all three languages. Let's find out the differences.

‍

Dart

Dart functions are defined using void for no return type, or the specific type for return values.

void greet() {
  print('Hello!');
}

int add(int a, int b) {
  return a + b;
}

‍

Kotlin

Functions in Kotlin use the fun keyword. Return types are specified after a colon.

fun greet() {
    println("Hello!")
}

fun add(a: Int, b: Int): Int {
    return a + b
}

‍

Swift

Functions in Swift use the func keyword. Return types are specified with ->.

func greet(person: String) -> String {
    let greeting = "Hello, " + person + "!"
    return greeting
}

func add(a: Int, b: Int) -> Int {
    return a + b
}

‍

4. Control Flow (If-Else)

The if/else in Kotlin is exactly the same way, and in Swift it is by removing the ().

‍

Dart

if (age > 18) {
  print('Adult');
} else {
  print('Minor');
}

‍

Kotlin

if (age > 18) {
    println("Adult")
} else {
    println("Minor")
}

‍

Swift

if age > 18 {
    print("Adult")
} else {
    print("Minor")
}

‍

5. Asynchronous calls

Asynchronous calls are a little different in each language, Dart and Swift are more similar, and Kotlin is a little more complex due to the use of coroutines, but even if your background is Kotlin, you will find that asynchronous calls in Dart are very simple.

‍Dart 

Dart uses Future to handle asynchronous operations.

void main() async {
	var result = await fetchDataFromNetwork();
	print("Result: $result");
}

Future fetchDataFromNetwork() async {
	await Future.delayed(Duration(seconds: 1));  // Simulates a 1-second delay
	return 'Data fetched';
}

‍

Swift

Swift provides the async/await pattern to handle asynchronous operations in a simple and readable way.

func fetchDataFromNetwork() async -> String {
	try? await Task.sleep(nanoseconds: 1_000_000_000)  // Simulates a 1-second delay
	return "Data fetched"
}

@main
struct MyApp {
	static func main() async {
	let result = await fetchDataFromNetwork()
		print("Result: \(result)")
	}
}

‍

‍Kotlin

In Kotlin, coroutines are used to make asynchronous calls.

fun main() = runBlocking {
  val result = async {
     fetchDataFromNetwork()  // Simulated function that represents an async call
  }
  println("Result: ${result.await()}")
}

suspend fun fetchDataFromNetwork(): String {
   delay(1000)  // Simulates a 1-second delay (like a network call)
   return "Data fetched"
}

‍

These examples highlight how straightforward the learning curve is, especially if you’re coming from Kotlin or Swift. The same applies if your background includes languages like Java, C#, or JavaScript. So, dive in with confidence—start your journey with Dart and Flutter today!

‍

Go check out more info about it in the following pages: 

• Dart documentation: https://dart.dev/guides
• Kotlin documentation: https://kotlinlang.org/docs/getting-started.html
• Swift documentation: https://docs.swift.org/swift-book/documentation/the-swift-programming-language