Dart is type safe, which means it uses compile time and runtime checks to ensure the type of value always matches the variables static type

int x = 10;

// The value of the variable should be an integer

int x = 'hello';

// A value of type 'String' can't be assigned to a variable of type 'int'.
// Try changing the type of the variable,
//  or casting the right-hand type to 'int'.

Why do I need it?

Dart has a static code analyzer that runs in the background of your favourite editor and helps you find bugs before you run a single line of code.

Give me an example.

4: void main{
5:   if( true);
6:   
7: }

// Avoid empty statements. dart(empty_statements) [Ln 5, Col12]
// See the `;` on Line 5

Pro Tip: Use Error Lens plugin in vs code to get the errors inline.

You can customize the analyzer to be more strict etc but that is out of scope.

What is soundness?

Soundness ensures that your program can't get into invalid states because of type mismatches. For example, if an expressions static type is String, at runtime you are guaranteed to only get a string when you evaluate it.

Benefits of Soundness

• Revealing type-related bugs at compile time.
• Code Readability
• More maintainable code.
• Better ahead of time (AOT) compilation.

Why you should worry about Null Safety ?

Over 1 billion exception events were tracked

So the whole point is to avoid it at compile time so that you can sleep peacefully knowing you are protected from the dreaded null related exceptions.

The Null Keyword

Null safety was a key feature of Dart 2.0. It was released as an opt-in for backward compatibility reasons however is the default now.

// Without null safety:
bool isEmpty(String string) => string.length == 0;

main() {
  isEmpty(null);
}

If you run this Dart program without null safety, it throws a NoSuchMethodError exception on the call to .length. The null value is an instance of the Null class, and Null has no length getter. Runtime failures suck.

In dart especially, where you write most of the code to be executed on a mobile device it can be really painful for the end users.

Let's look at some examples:

// In null-safe Dart, none of these can ever be null.

var i = 42; // Inferred to be an int.
String name = getFileName();
final b = Foo();

**To indicate that a variable might have the value null, just add ? to its type declaration:

int? aNullableInt = null;

The variables in Dart are non-nullable by default. Unless you explicitly tell Dart that a variable can be null, its considered non-nullable.

Next we will look at examples to handle nulls and build a principle around null safety.

The final variables once initialized cannot be mutated as in reassigned. However, the values/objects held by the variable can be modified.

Let's see an example.

class User {
  String name;
  int age;

  User(this.name, this.age);

  @override
  String toString() {
    return "$name: $age";
  }
}

void main() {
  final users = <User>[User("Amit", 32), User("Rahul", 26)];

  users.add(User("Bob", 98));

  print(users[0]); // Bob: 98

  //mutable: final fields objects can be changed
  users[0] = User("Kevin", 18);
  print(users[0]); // Kevin: 18

  //mutable: final fields object's value can be changed
  users[0].name = "What's there in the name? ";
  print(users[0]); // What's there in the name?: 18

  //immutable: a final variable cannot be modified
  users = <User>[
    User("Ronaldo", 33)
  ]; // COMPILE-TIME  Can't assign to the final variable 'users'.
}

What to consider when confused?

• The final variable can only be set once at runtime
• A final object cannot be modified, its object's values can be changed as we saw above.

Now we know when to use const and final keywords with variables in Dart See When to use const keyword in Dart? if you haven't seen it already.

Next, we will look at a special keyword in Dart and the details around it?

Next => Sound Null safety in Dart.

To understand the const keyword lets look at the following code first to see how its declared

void main(){
  const x = [1,2,3];
  print(x);
}
//dart run file.dart =>  [1,2,3]

Now, if we modify the code above to modify const variable x we get:

Error: Can't assign to the const variable 'x'.

void main(){
  const x = [1,2,3];
  x = [4,5,6];
  print(x);
}
//dart run file.dart => Error: Can't assign to const variable 'x'.

Compile time behaviour

What's important to understand is the compile time behaviour here.

• Compile time constant value is a value which will be a constant while compiling and cannot be modified once declared.

• If the value of the variable is to be determined at runtime then the compiler will throw a similar error as above.

• The const list should have constants else it'll error out.

• Essentially, the value of a const variable is to be known at compile time and once assigned cannot be changed.

So why use const?

For any given const value, a single const object will be created and re-used no matter how many times the const expression(s) are evaluated. They make your software efficient.

How to declare const variables, some examples?

Below are the valid definitions of constants

const a = "blah";

const int b = 2;

const var c = [1,2];

Interestingly,

const c = 5+2; // 5 + 2 is a valid const expression that can be evaluated at compile time

However,

const x = DateTime.now();

//=> Error: Cannot invoke a non-'const' constructor where a const expression is expected.
// Try using a constructor or factory that is 'const'.
// const x = DateTime.now();

So when you declare variable or objects use const as much as possible.

Next, we will look at the final keyword and see when to use the final keyword and when to use const

Simple Variable

var name = 'Foo';

Variables store references. The variable called name contains a reference to a String object with a value of Bob.

Explicitly want to set the type? No problem

String Variable

String name = 'Foo';

Want to declare integers?

Integer variable

int count = 4;

Want to declare Floating point numbers?

Float/Double variable

double f = 1.0;

double is a language keyword

A simple program that uses variables

void main() { 
   int num=10; 
   double x = 10.0;
   String y = 'Hello World!';
   print(num); 
   print(x);
   print(y);
}

That's all!

Next we will look into the dart language keywords set and explore a few keywords that change the way variables behave.

See Const keyword in dart

Say you have written a code that throws a custom exception and you created it.

Let's call it

 NotInitializedException

Now how do you test for this exception while writing unit tests in dart?

No sweat!

You can use TypeMatcher<T> class

TypeMatcher is a Matcher subclass that supports validating the Type of the target object.

Let's see an example:-

class MockUser {
  var _isInitialized = false;
  bool get isInitialized => _isInitialized;

void testInitialize() {
    if (!isInitialized) throw NotInitializedException();
  }
}

Here's how you would write a test for this

void main() {
  group('Mock User', () {
      final user = MockUser();
      test('Test that initialization throws the right exception', () {
          final result = user.testInitialized()
          expect(result, throwsA(const TypeMatcher<NotInitializedException>()));
    });
}

throwsA

The throwsA matcher can be used to test 3 kinds of objects:

1. A function that throws an exception when called, like in our case.
2. A future that completes with an exception
3. A function that returns a future that completes with an exception.

That's all.

Dart is an Object Oriented programming language backed by Google.

Here are the features of the language in short

• Dart is Type safe
• Dart has sound null safety
• Dart also forms the foundation of Flutter. Dart provides the language and runtimes that power Flutter apps, but Dart also supports many core developer tasks like formatting, analyzing, and testing code.
• Has language features that you'll find in most of the object oriented programming languages.
• Concurrent programming using isolatesindependent workers that are similar to threads but dont share memory
• For more Dart Language Overview

How to run dart programs?

You can either run Dart on Dart Playground or install the dart plugin on Visual studio code(vscode). You can follow the instructions here to set it up.

To kick off the mini series we will see the mandatory Hello World! program using the Dart language.

void main() {
  print('Hello, World!');
}

• Save the above code in a file hello_world.dart and run using the following command dart hello_world.dart
• It should output Hello, World!
• The main function is the entry point where the dart runtime starts the code execution and returns void.
• print function prints the string to the console.
• Notice the ; at the end of the print statement

That's all for now!

I recommend finishing the setup for VsCode as we won't be using the console to run when the dart plugin tremendously helps us develop software.

We will look at the variables and dart types next

See Variables in Dart

class MockClass {
Future<void> initialize() async {
    await Future.delayed(const Duration(seconds: 1));
    _isInitialized = true;
  }
}

Here's how you can do it

MockClass object = MockClass();
test('should be able to initialize in under 2 seconds', () async {
      await object.initialize(); // This is the function that should 
      expect(object.isInitialized, true);
    },
        timeout: const Timeout(
          Duration(seconds: 2),
        ));
  });

The output: Mock Authentication should be able to initialize in under 2 seconds

Note the Timeout class where you can set the duration.