# Starting using Dart: A Seamless Transition For Developers

> Relax! Using Dart doesn’t mean learning a whole new programming language

- Source: https://verygood.ventures/blog/starting-using-dart-a-seamless-transition-for-developers/
- Published: 2024-12-10
- Author: Ana Polo
- Tags: Backend

---

**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.](https://en.wikipedia.org/wiki/List_of_C-family_programming_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.

```dart
// 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).

```kotlin
// 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).

```swift
// 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.

```dart
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.

```kotlin
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.

```swift
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.

```dart
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.

```kotlin
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 ->.

```swift
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

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

### Kotlin

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

### Swift

```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.

```dart
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.

```swift
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.

```kotlin
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 here:

-   [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)