DEV Community: Andrea Bizzotto

My 2020 as a Content Creator: Udemy, Teachable, and YouTube Revenue and Income Report

Andrea Bizzotto — Fri, 01 Jan 2021 15:22:24 +0000

2020 marked my third year as a content creator making Flutter tutorials and courses on Udemy, YouTube, and my own website.

In this article, I share a full retrospective about my sales numbers, along with a lot of details about my journey and milestones.
I'll also explain how I used Udemy, YouTube, Teachable, Twitter, my website, and many other channels to grow my audience and business.

In reality, 2020 has been a tragic year for many people who have lost loved ones. I can only be grateful that everything has gone as well as it could have in my own life. Being able to focus on my work from the comfort of my home has kept me sane and safe, and I'm aware that many others don't have this privilege.

I'm about to share my successes and insights from this year, because I feel they are valuable and worth sharing. If you had a tough year and didn't accomplish as much, I want you to know it's ok. You can read this retrospective for what it is, but don't compare yourself to me.

So let me give you a realistic picture of what it's like to run a content creation business, starting from my motivation:

Why did I become a content creator?

Before becoming a content creator I was contract iOS developer for many years, working on many diverse and interesting projects.

I had the flexibility to take time off and work on side projects between contracts, due to strong demand and competitive market rates for iOS developers in London.

So why did I decide to leave that behind and make Flutter tutorials and courses instead?

Ultimately, my decision came down to this:

I want to have full creative control over my work, be my own boss, on my own schedule.

I'm very passionate about coding and helping people learn to code, no matter where they are in the world.

Content creation gives me an avenue to do that and brings a lot of exciting challenges. I started creating Flutter video tutorials on YouTube and courses on Udemy. In 2020 I've launched CodeWithAndrea.com as a platform to share all my content in one place.

In addition to coding, my daily work includes writing articles, making videos, marketing, and growing an audience across multiple platforms.

All the things I do boil down to this: how can I productize my knowledge and make a living from it?

This is not easy and is not for everyone. Daniell Vassallo said it best in this recent tweet:

The problem with scalable work (where income and effort are decoupled) is that your odds of success are very low.
The stars need to align to make it work, and if they don't you'll make nothing. This is not the case with non-scalable work.

With this in mind, I can now share my goals for this year and show you how I've done.

2020 Goals

In closing last year's retrospective, I set myself some goals:

Launch (at least) one more course
$5,000 monthly average revenue (MAR) (from $2,400)
Reach 30K subscribers on YouTube (from 10.5K)

Note: I don't get monthly recurring revenue (MRR) by selling Udemy courses, so I'll use the monthly average revenue (MAR) over the last 4 months as a metric instead.

This year I launched two new courses (more on that later), so I've accomplished my first goal. ✅

Next, I'll show you my full income report. After that, I'll share a lot of insights about my content creation strategy and journey.

2020 Income Report

This year I've been earning income across three platforms: Udemy, Teachable, and YouTube (via AdSense).

Here's a monthly breakdown across all platforms:

2020 income report across Udemy, Teachable, YouTube (AdSense)

My total earnings have reached just under $43,000, at roughly $3580 per month.

Of these, Udemy took the cake, at over %90 of my income. So let's look at that in more detail.

2020 Udemy Income

My Udemy lifetime earnings look like this:

Udemy lifetime earnings since March 2019

I'm happy to have passed the $50K milestone. Though monthly average revenue (MAR) is of course the most interesting metric.

Over the last four months (September to December) my MAR reached $4,250, which is short of my $5K goal. ❌

Note: sales numbers are very seasonal, as Udemy runs many promotions in different countries at different times of the year. While the chart above shows an increasing trend, I expect sales to dip in Q1 2021.

In September alone, I managed to drive nearly $3,700 in sales from my own promotions, thanks to the launch of my new Dart course. And I was quite happy about it:

November has been my best month so far with $5,000 in revenue, due to Udemy's Black Friday promotions.

This year my Udemy income was distributed like this:

45% from my own promotions
55% from Udemy organic, affiliates, and the ads program.

In other words, while Udemy traffic contributes to ~55% of my sales, I still have to consistently promote my courses to break through the $4,000 MAR mark. For comparison, top instructors earn a lot more in volume sales from Udemy organic traffic.

$4,000 MAR makes me financially comfortable (some would say ramen profitable) and I can fully focus on my business without doing extra consulting work to pay the bills. 🙂

Here's how each of my three Udemy courses performed:

Flutter & Firebase Course

This is my oldest and longest course, with 21 hours of content. It received a big spike in sales in April / May, as more people were learning online during the first COVID lockdown. But it has been on a down-trend since then:

2020 monthly income from my Flutter & Firebase course on Udemy

In August, the FlutterFire plugins received a major update that introduced many breaking changes, and course ratings dropped from 4.7 to 4.6 as a result. I managed to update the course in November, but the ratings haven't climbed back up yet.

Flutter REST API Course

I launched this course in March on Teachable, and in late April on Udemy:

Monthly income from my Dart course on Udemy (launched April 2020)

This course is much smaller (2.5 hours of content) and has not been getting a good volume of sales due to its lower ranking on the Udemy charts.

In an attempt to improve this, I did something outlandish and made the course free for 3 days in October. I shared this on Twitter and Reddit, and gathered over 15,000 enrollments 🤯. This is very noticeable in the traffic & conversion report:

The result of making my course free for 3 days: a huge spike in landing page visitors.

The result of this experiment?

the number of reviews doubled to over 200
the average review score dropped from 4.7 to 4.5
over the next two months, the course ranking went from #52 to #7 for "flutter"

The extra reviews helped with sales, most likely due to increased visibility during Black Friday. But this was a gamble. All those "free" students never bought my other paid courses, and I will not try this again.

Lesson learned: Never give away your paid content for free.

This is a hack that can help boost rankings, at the expense of jeopardizing reviews and attracting the wrong students. And I wouldn't risk this on my most valuable courses.

Dart Course

This is my newest course. It took 4 months to produce and ended up being a comprehensive Dart course for beginners with 10 hours of content:

Monthly income from my Dart course on Udemy (launched September 2020)

I launched it and promoted it heavily in September, and it has been performing fairly well since.

This course is now rated 4.8 stars and I often see people recommending it on Twitter and Reddit. It has even been gifted at some Flutter conferences. 🤗

Udemy is a crowded marketplace. So how have I been able to generate these sales numbers?

Udemy is a very crowded platform

Udemy is like a smaller version of Google, for paid online courses.

Courses in the top 10 for a given category have a better chance of getting good search traffic, as well as being featured and advertised by Udemy. While many factors influence the ranking of courses on Udemy, the top two appear to be the number of reviews and the average review score.

So if you're planning to launch a course on Udemy, you need to carefully evaluate how much competition there is for the primary course topic, and how likely you are to break into top #10 for the number of reviews.

According to the Udemy insights page for Flutter, the average monthly revenue of the top 5 courses is $20,000, while the median monthly revenue is under $50:

Udemy insights page for the "Google Flutter" topic

In other words, the winner takes all. As there are now nearly 600 Flutter courses (a 10x increase compared to 15 months ago), my future courses will have a decreasing chance of being discovered.

Still, Udemy offers a promotional email feature that instructors can use to market new courses to their existing students. Here is how my promotions have performed so far:

Open Rate and CTR for my promotional emails on Udemy

I'm no CTR expert but click-through rates of over 10% sound very good to me. For comparison, CTR in my regular email newsletters has been around 4% this year.

With a combination of promotional emails and announcements on YouTube and Twitter, I got enough students and reviews to make all my three courses rank in the top 10 for Flutter / Dart.

But with over 600 Flutter courses on Udemy, I'm not sure that my future courses will do well enough to break even, no matter how good they are.

Because Udemy is all about volume, most courses cater to beginners. Maybe I should publish my future courses somewhere else, for a higher price. After all, there are many ways of making $50,000 with a course:

5000 sales for $10 each
1000 sales for $50 each
500 sales for $100 each

This brings me to Teachable.

Teachable as a course platform

After seeing other creators have success on Teachable, I decided to use it to host my Flutter REST API course.

This course shows how to use REST APIs to build a Coronavirus app in Flutter. I launched this course in March, right when most of Europe and the US were experiencing the first wave of COVID.

To drive students to this course, I shared a couple of chapters for free on YouTube, and these were some of my most-watched videos this year.

I made $1,700 in the first month, but sales dropped sharply after that:

2020 income from sales on Teachable

This highlights one important thing:

Udemy is a marketplace with a lot of traffic and built-in search and discovery features to help students find your courses.
Teachable does not market your courses for you. Instead, you have to drive all the traffic yourself.

Unlike Udemy, Teachable gives you full control over the course price, and after students enroll you have their emails. But when you are starting out and your audience is small, it's hard to get enough people to buy your course.

To be fair, Teachable already has a large pool of students and offers various ways (e.g. webinars) for instructors to promote their courses. I have not tried these marketing channels yet, and I'm keen to do so next year.

But as I continue growing my audience and newsletter (more on this below), it may make sense to sell higher-priced, premium courses exclusively on Teachable or other platforms. Time will tell.

My year on YouTube

YouTube is the second biggest search engine in the world and I really like it as a platform.

My goal was to increase my subscribers from 10K to 30K this year. But I didn't reach this goal and stopped at 23K instead. ❌

This is due to two reasons:

My primary focus has been on creating paid courses
Many of my videos didn't do great (less than 1000 views on week 1) rather than "everyone likes this" (over 10,000 views on week 1)

Here's a chart of my channel watch time this year:

Watch time (hours) on my YouTube channel in 2020

This is mostly flat - even decreasing in the second half of the year.

That's because from July until October I focused 100% on creating my Dart course, and haven't been able to publish a lot of interesting content.

In the first part of the year, I tried to publish YouTube videos consistently, but I didn't have a clear strategy and wasn't getting results.

For comparison purposes, some of the top programming YouTube channels have been growing 5x to 10x faster than mine. So the bar is getting higher on YouTube, and I need to step up my game in 2021.

As a content creator, what are the right metrics?

To be fair, I see YouTube as a valuable channel to increase my audience, but it is only one piece of the puzzle.

As I have written in my content creation blueprint, I'm active on many channels.

If I want to grow my business sustainably and continue to create valuable content (both free and paid), I need to focus on the right metrics:

more Twitter followers? nice
more YouTube subs? cool
more unique visitors to my site? great
more email subscribers? awesome

But what matters the most is how many students enroll in my paid courses every month. I can only continue making free Flutter tutorials for everyone if my paid courses pay the bills. By the way, you can buy them here to support my work. 🙏

Each platform is unique in its own way. Twitter alone has performed very well for me this year.

But I feel that going forward my website and email list will be a major focus. Speaking of which...

CodeWithAndrea.com

Launching this website in 2020 has been a great move.

My website holds all my content in one place. It's a platform that I own and I can use it as a funnel for my paid courses and newsletter.

Here are my traffic stats from this year:

Page-views and unique visitors trend on CodeWithAndrea.com

After launching the site in January, I set up canonical URLs for all pages in my previous Medium publication, and I reached 40,000 page views in May.

Though I haven't published a lot of content between July-October, and my unique visitors have remained flat during this period.

And just as I started finding time to focus on my site, I discovered...

The Blogging For Devs community

Blogging For Devs Pro is a great community of developers who are growing their audience through blogging. Joining this community has been one of the best investments I've done for my business.

I've learned a ton of stuff about blogging, SEO, email & newsletters, and much more. Even better, I've been able to share my work and get feedback from other creators daily. I think of this community as a form of shared mentorship. Monica Lent (the author) knows "a ridiculous amount about blogging" (in her own words), and has been consistently helping me and others take our blogs to the next level.

Empowered by this discovery, I set off fixing the most outstanding SEO issues on my site and increased traffic by 25% in one month. I updated some of my old articles using better keywords and boosted traffic even more.

And I also launched a brand new newsletter, redesigned parts of my website, and started planning a sound content strategy for 2021.

My new newsletter

My old newsletter was hardly getting any new subscribers for most of 2020. That's because I was just showing a boring sign-up banner on my website.

Having seen what Monica had done with her newsletter, I figured I could do much better.

So I created a 15-day email course offering a curated list of resources to help people learn Flutter at their own pace.

I only launched this newsletter 10 days ago, but I can already report that I got nearly 400 new subscribers on launch day - that's 10% of the total subscribers in the previous three years.

New newsletter subscribers on launch week

I can offer a lot of value with this newsletter. More importantly, I can talk directly to my subscribers, figure out how to best help them, and better plan my strategy going forward.

Twitter and other platforms

Udemy, Teachable, YouTube, and my website have kept me busy in 2020. But I've used other platforms too.

This year I managed to reach 5000 Twitter followers, doubling the number from the previous year. Nearly all my Twitter followers are Flutter enthusiasts and I've been tweeting almost exclusively about Flutter. Having a targeted audience makes Twitter a strategic platform for me.

In July, I started a series of daily "Easy Wins" about the Dart language. These included bite-sized tips and tricks and have been very popular. I didn't quite make it to 100 tips and ran out of ideas at #43 😅, but I gained a lot of followers along the way.

This contributed to the successful launch of my Dart course in September, and for the first time, I exceeded $1,000 in sales on launch day.

Bottom line: it's worthwhile to build a loyal, qualified audience on Twitter.

People often reach out to me with questions, or even looking to hire me. While I'm focusing primarily on my business, it's good to know that I can easily find work if needed.

Breakdown of my activities in 2020

Content creation is not about passive income.

I've been working on my business for almost 3 years and my results have not come overnight.

This year alone I spent a total of 1198 hours growing my business, for an average of 23 hours per week. That may not sound like much, but I've also done some contract work, taken up with some hobbies, and - most importantly - spent some time with my family. So this is the right balance for me.

Here's a breakdown for activity type:

Dart Course: 310h
YouTube Production: 147h
Blogging: 135h
Flutter Rest API Course: 109h
Website: 89h
Community engagement: 86h
Development: 76h
Flutter & Firebase Course: 64h
Newsletter: 38h
Planning: 35h
Other: 107h

Percentage of time spent for all my activities in 2020

Course production and updates have taken 42% of my time. Another 22% went into creating free content (articles and videos) for the Flutter community. And the rest was a mix of answering questions, building features for my website and newsletter, and writing open source Flutter apps and other test projects.

From a purely financial point of view, what is my return on investment?

Total Revenue / Total Time Invested = $36 per hour

This is less than half of what I can earn as a contract developer and I hope to push this above $50 next year.

Ongoing Expenses

All the numbers above don't tell the entire story, as some of my costs have gone up this year.

Between ConvertKit, Ahrefs, Teachable, and other ongoing subscriptions, my expenses are now around $500 per month.

While I should be able to reduce some of my costs next year, I'll also invest in better video production software & hardware.

My ongoing expenses are less than 20% of my revenue. As long as my profits increase, I'm happy to invest in things that make me productive and help me produce better content.

For example, this year I hired a designer to make some professional banners for my videos and courses, and I'm glad I did!

Content Creation - the drawbacks

While launching more courses has boosted my revenue this year, not everything is as rosy as it seems.

Stuff changes all the time

As languages and frameworks evolve at a rapid pace, courses and tutorials age quickly.

APIs change often (I'm looking at you FlutterFire), new packages are added all the time, and it takes a lot of work to keep content up to date.

I have seen this happen with my Flutter & Firebase course. While it's still a very valuable resource and I've managed to keep it updated, much has changed with Flutter state management and other topics. I've considered creating a brand new course to replace it. But that could take easily 6+ months of work and there's no guarantee that it would do well on Udemy.

Content Creation vs Building SaaS products vs Consulting

Creating content about programming is a two-edged sword:

on one hand, new stuff comes out all the time and there are endless opportunities to help people learn
on the other hand, old content needs to be renewed often to remain relevant

Keeping info-products (courses, books) updated takes time and this is a problem as a creator.

Maybe I could get a better return on investment (ROI) building a SaaS product and this is something that I want to explore in 2021.

To this day I still find it easier, more profitable, and reliable, to earn a living doing consulting work than creating content. This is likely the case for most developers out there. So don't jump on the content creation bandwagon just because you see others doing it on YouTube.

Helping People Learn

So far I've shared a complete breakdown of all the $$$ I made. But you know what?

value > money

In 2020 alone, thousands of students have watched 36,000 hours of tutorials from my YouTube channel.

7500 students have watched nearly 50,000 hours of lessons from my Udemy courses:

Minutes taught each month on my Udemy courses

Some of those students have gone on to create their own apps, even got jobs as Flutter developers.

For me it's incredibly rewarding to help others grow and live a better life. I hope I can do so for even more people in the future.

This leads me to my goals for 2021:

2021 Goals

I could set some ambitious goal like reaching $10K per month, or have some explosive growth metrics. But that is unrealistic and would put a lot of pressure on myself.

So I'm going to diversify my income a bit.

In 2021 I'm planning to do some client work - just a few hours per week, to take all the financial pressure off my business.

And I'll focus on creating new, high-value content across all my platforms.

I still want to set some goal-posts for my business. Here they are:

Reach $6,000 MAR
200K pageviews / 50K unique visitors per month on my website
Grow my newsletter to 10K subscribers
Grow to 100K views per month on YouTube, 40K subscribers
Double Twitter followers to 10K

In honesty I don't think I have even a remote chance of meeting all these goals in 2021.

But I'll try and if I only get there the year after, that is cool with me. 🙂

I still need to figure out what I can do to unlock the next level of growth. But this is the nature of running a business, and I want to enjoy the journey. ⛰

Wrap Up

If you're a content creator or want to become one, I hope this article was helpful.

If you are one of my students, thanks ever so much for being part of my journey.

Whether you've been on my website before or this is the first article you read here, I hope you'll come back.

If you have any feedback, you can ping me on Twitter or leave a comment below. 👇

Thanks for reading, and I wish you all the best in 2021!

Top 16 Dart Tips and Tricks Every Flutter Developer Should Know

Andrea Bizzotto — Thu, 19 Nov 2020 22:04:49 +0000

NOTE: This tutorial is also available as a video on YouTube.

In this tutorial, I share my top Dart tips and tricks that will improve your coding style as a Flutter developer.

You can use them to write more concise and effective code, and make the most of the Dart language.

Ready? Let's get started!

1. Did you know? Dart supports string multiplication.

Here is a simple program showing how to print a Christmas tree with string multiplication:

void main() {
  for (var i = 1; i <= 5; i++) {
    print('🎄' * i);
  }
}
// Output:
// 🎄
// 🎄🎄
// 🎄🎄🎄
// 🎄🎄🎄🎄
// 🎄🎄🎄🎄🎄

Cool isn't it? 😉

You can use this to check how a long string fits inside a Text widget:

Text('You have pushed the button this many times:' * 5)

2. Need to execute multiple Futures concurrently? Use Future.wait.

Consider this mock API class that tells us the latest numbers of COVID cases:

// Mock API class
class CovidAPI {
  Future<int> getCases() => Future.value(1000);
  Future<int> getRecovered() => Future.value(100);
  Future<int> getDeaths() => Future.value(10);
}

To execute all these futures concurrently, use Future.wait. This takes a list or futures and returns a future of lists:

final api = CovidAPI();
final values = await Future.wait([
    api.getCases(),
    api.getRecovered(),
    api.getDeaths(),
]);
print(values); // [1000, 100, 10]

This is ideal when the futures are independent, and they don't need to execute sequentially.

3. Implement a "call" method in your Dart classes to make them callable like a function.

Here's an example PasswordValidator class:

class PasswordValidator {
  bool call(String password) {
    return password.length > 10;
  }
}

Because the method is named call, we can declare a class instance and use it as if it was a method:

final validator = PasswordValidator();
// can use it like this:
validator('test');
validator('test1234');
// no need to use it like this:
validator.call('not-so-frozen-arctic');

4. Need to invoke a callback but only if it's not null? Use the "?.call()" syntax.

Suppose we have a custom widget class that should call an onDragCompleted callback when a certain event takes place:

class CustomDraggable extends StatelessWidget {
  const CustomDraggable({Key key, this.onDragCompleted}) : super(key: key);
  final VoidCallback? onDragCompleted;

  void _dragComplete() {
    // TODO: Implement me
  }
  @override
  Widget build(BuildContext context) {/*...*/}
}

To invoke the callback, we could write this code:

  void _dragComplete() {
    if (onDragCompleted != null) {
      onDragCompleted();
    }
  }

But there is a simpler way (note the use of ?.):

  Future<void> _dragComplete() async {
    onDragCompleted?.call();
  }

5. Using anonymous functions and functions as arguments

In Dart, functions are first-class citizens, and can be passed as arguments to other functions.

Here is some code that defines an anonymous function and assigns it to a sayHi variable:

void main() {
  final sayHi = (name) => 'Hi, $name';
  welcome(sayHi, 'Andrea');
}

void welcome(String Function(String) greet,
             String name) {
  print(greet(name));
  print('Welcome to this course');
}

Then sayHi is passed to a welcome function that takes a Function argument and uses it to greet the user.

String Function(String) is a function type that takes a String argument and returns a String. Because the anonymous function above has the same signature, it can be passed directly as an argument, or via the sayHi variable.

This coding style is common when using functional operators such as map, where, and reduce.

For example, here's a simple function to calculate the square of a number:

int square(int value) {
  // just a simple example
  // could be a complex function with a lot of code
  return value * value;
}

Given a list of values, we can map over them to get the squares:

const values = [1, 2, 3];

values.map(square).toList();

Here we pass square as an argument, because its signature is exactly what the map operator expects. This means that we don't need to expand it with an anonymous function:

values.map((value) => square(value)).toList();

6. You can use collection-if and spreads with lists, sets AND maps

Collection-if and spreads are very useful when you write your UI as code.

But did you know that you can use them with maps as well?

Consider this example:

const addRatings = true;
const restaurant = {
  'name' : 'Pizza Mario',
  'cuisine': 'Italian',
  if (addRatings) ...{
    'avgRating': 4.3,
    'numRatings': 5,
  }
};

Here we're declaring a restaurant map, and only adding the avgRating and numRatings key-value pairs if addRatings is true. And because we're adding more than one key-value pair, we need to use the spread operator (...).

7. Need to iterate through a map in a null-safe manner? Use `.entries`:

Suppose you have this map:

const timeSpent = <String, double>{
  'Blogging': 10.5,
  'YouTube': 30.5,
  'Courses': 75.2,
};

Here's how you can write a loop to run some code using all the key-value pairs:

for (var entry in timeSpent.entries) {
  // do something with keys and values
  print('${entry.key}: ${entry.value}');
}

By iterating on the entries variable, you have access to all the key-value pairs in a null-safe way.

This is more concise and less error-prone than this:

for (var key in timeSpent.keys) {
  final value = timeSpent[key]!;
  print('$key: $value');
}

The code above requires to use the assertion operator (!) when reading the values, as Dart can't guarantee that a value exists for a given key.

8. Use named constructors and initializer lists for more ergonomic APIs.

Suppose that you want to declare a class that represents a temperature value.

You can make your class API unambiguous and support both Celsius and Fahrenheit with two named constructors:

class Temperature {
  Temperature.celsius(this.celsius);
  Temperature.fahrenheit(double fahrenheit)
    : celsius = (fahrenheit - 32) / 1.8;
  double celsius;
}

This class only needs one stored variable to represent the temperature and uses an initializer list to convert Fahrenheit to Celsius.

This means that you can declare temperature values like this:

final temp1 = Temperature.celsius(30);
final temp2 = Temperature.fahrenheit(90);

9. Getters and setters

In the Temperature class above, celsius is declared as a stored variable.

But users may prefer to get or set the temperature in Fahrenheit.

This is easily done with getters and setters, that allow you to define computed variables. Here's the updated class:

class Temperature {
  Temperature.celsius(this.celsius);
  Temperature.fahrenheit(double fahrenheit)
    : celsius = (fahrenheit - 32) / 1.8;
  double celsius;
  double get fahrenheit
    => celsius * 1.8 + 32;
  set fahrenheit(double fahrenheit)
    => celsius = (fahrenheit - 32) / 1.8;
}

This makes it easy to get or set the temperature with either Fahrenheit or Celsius:

final temp1 = Temperature.celsius(30);
print(temp1.fahrenheit);
final temp2 = Temperature.fahrenheit(90);
temp2.celsius = 28;

Bottom line: use named constructors, getters and setters to improve the design of your classes.

10. Use underscores for unused function arguments

In Flutter we often use widgets that take function arguments. One common example of this is ListView.builder:

class MyListView extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return ListView.builder(
      itemBuilder: (context, index) => ListTile(
        title: Text('all the same'),
      ),
      itemCount: 10,
    );
  }
}

In this case, we are not using the (context, index) arguments in the itemBuilder. So we can replace them with underscores instead:

ListView.builder(
  itemBuilder: (_, __) => ListTile(
    title: Text('all the same'),
  ),
  itemCount: 10,
)

Note: the two arguments are different (` and _`) as they are separate identifiers.

11. Need a class that can only be instantiated once (aka singleton)? Use a static instance variable with a private constructor.

The most important property of a singleton is that there can only be one instance of it in your entire program. This is useful to model things like a file system.

// file_system.dart
class FileSystem {
  FileSystem._();
  static final instance = FileSystem._();
}

To create a singleton in Dart you can declare a named constructor and make it private using the _ syntax.

Then you can use it to create one static final instance of your class.

And as a result, any code in other files will only be able to access this class via the instance variable:

// some_other_file.dart
final fs = FileSystem.instance;
// do something with fs

Note: Singletons can lead to many problems if you're not careful. Make sure you understand the disadvantages before using them.

12. Need a collection of unique items? Use a Set rather than a List.

The most commonly used collection type in Dart is a List.

But lists can have duplicate items, and sometimes this is not what we want:

const citiesList = [
  'London',
  'Paris',
  'Rome',
  'London',
];

We can use a Set whenever we need a collection of unique values (note the use of final):

// set is final, compiles
final citiesSet = {
  'London',
  'Paris',
  'Rome',
  'London', // Two elements in a set literal shouldn't be equal
};

The code above generates a warning because London is included twice. If we try doing the same with a const set, we get an error and our code doesn't compile:

// set is const, doesn't compile
const citiesSet = {
  'London',
  'Paris',
  'Rome',
  'London', // Two elements in a constant set literal can't be equal
};

When we work with sets, we have access to useful APIs such as union, difference, and intersection:

citiesSet.union({'Delhi', 'Moscow'});
citiesSet.difference({'London', 'Madrid'});
citiesSet.intersection({'London', 'Berlin'});

Bottom line: when you create a collection, ask yourself if you want its items to be unique, and consider using a set.

13. How to use try, on, catch, rethrow, finally

try and catch are ideal when working with Future-based APIs that may throw an exception if something goes wrong.

Here's a full example showing how to make the most of them:

Future<void> printWeather() async {
  try {
    final api = WeatherApiClient();
    final weather = await api.getWeather('London');
    print(weather);
  } on SocketException catch (_) {
    print('Could not fetch data. Check your connection.');
  } on WeatherApiException catch (e) {
    print(e.message);
  } catch (e, st) {
    print('Error: $e\nStack trace: $st');
    rethrow;
  } finally {
    print('Done');
  }
}

A few notes:

you can add multiple on clauses to handle exceptions of different types.
you can have a fallback catch clause to handle all exceptions that do not match any of the types above.
you can use a rethrow statement to throw the current exception up the call stack while preserving the stack trace.
you can use finally to run some code after the Future has completed, regardless of whether it succeeded or failed.

If you are using or designing some Future-based APIs, make sure to handle exceptions as needed.

14. Common Future constructors

The Dart Future class comes with some handy factory constructors: Future.delayed, Future.value and Future.error.

We can use Future.delayed to create a Future that waits for a certain delay. The second argument is an (optional) anonymous function that you can use to complete with a value or throw an error:

await Future.delayed(Duration(seconds: 2), () => 'Latte');

But sometimes we want to create a Future that completes immediately:

await Future.value('Cappuccino');
await Future.error(Exception('Out of milk'));

We can use Future.value to complete successfully with a value, or Future.error to complete with an error.

You can use these constructors to simulate the response from your Future-based APIs. This is useful when writing mock classes in your test code.

15. Common Stream constructors

The Stream class also comes with some handy constructors. Here are the most common ones:

Stream.fromIterable([1, 2, 3]);
Stream.value(10);
Stream.empty();
Stream.error(Exception('something went wrong'));
Stream.fromFuture(Future.delayed(Duration(seconds: 1), () => 42));
Stream.periodic(Duration(seconds: 1), (index) => index);

use Stream.fromIterable to create a Stream from a list of values.
use Stream.value if you have just one value.
use Stream.empty to create an empty stream.
use Stream.error to create a stream that contains an error value.
use Stream.fromFuture to create a stream that will contain only one value, and that value will be available when the future completes.
use Stream.periodic to create a periodic stream of events. You can specify a Duration as the time interval between events, and an anonymous function to generate each value given its index in the stream.

16. Sync and Async Generators

In Dart we can define a synchronous generator as a function that returns an Iterable:

Iterable<int> count(int n) sync* {
  for (var i = 1; i <= n; i++) {
    yield i;
  }
}

This uses the sync* syntax. Inside the function we can "generate" or yield multiple values. These will be returned as an Iterable when the function completes.

On the other hand, an asynchronous generator is a function that returns a Stream:

Stream<int> countStream(int n) async* {
  for (var i = 1; i <= n; i++) {
    yield i;
  }
}

This uses this async* syntax. Inside the function we can yield values just like in the synchronous case.

But if we want we can await on Future-based APIs, because this is an asynchronous generator:

Stream<int> countStream(int n) async* {
  for (var i = 1; i <= n; i++) {
    // dummy delay - this could be a network request
    await Future.delayed(Duration(seconds: 1));
    yield i;
  }
}

Conclusion

I hope you have enjoyed my top Dart tips and tricks for Flutter developers.

My challenge for you?

Use them to improve the code in your Flutter apps. And let me know which was your favourite on Twitter. 😉

By the way, I shared many more Dart tips on Twitter, and also republished them on this website:

Complete Dart Course

If you're new to Dart & Flutter or you want to improve your knowledge of the Dart language, you can buy my complete Dart course on Udemy.

With 10 hours of content, it covers the most important features of the Dart language. It includes exercises, solutions, and practical projects that will help you build your confidence with Dart.

You can buy the course for a discounted price with this link.

Happy coding!

Dart & Flutter Easy Wins 36-42

Andrea Bizzotto — Sun, 13 Sep 2020 08:12:03 +0000

I recently started a series of daily tweets about easy ways to improve your Dart & Flutter code. I called this Easy Wins.

To make these easier to find, I'm sharing 7 tips every week here.

36. Use `Timer.periodic` to create a timer that repeats with a given period

37. Need to convert an enum to an int or viceversa? Use `.index` and `values[i]`

38. Use asserts to disrupt program execution if a boolean condition is false

39. Need a better logger for your apps? Use the logger package

Link: Logger package

40. Use the Flutter DevTools to inspect and profile your Flutter apps

More info & installation instructions here: Flutter DevTools

41. Anonymous functions can be assigned to variables, or passed as arguments to other functions

42. Want a function that can only throw? Use Never

More info here: Never for unreachable code

More tips coming next week. Subscribe via RSS for updates!

Happy coding!

Dart & Flutter Easy Wins 29-35

Andrea Bizzotto — Sun, 13 Sep 2020 08:06:03 +0000

I recently started a series of daily tweets about easy ways to improve your Dart & Flutter code. I called this Easy Wins.

To make these easier to find, I'm sharing 7 tips every week here.

29. When EXTENDING classes, all ABSTRACT methods MUST be overridden & other methods CAN be overridden. When IMPLEMENTING classes, ALL methods MUST be overridden.

30. Need to iterate through a map in a null-safe manner? Use `.entries`:

31. Need different implementations for web and native platforms? Use conditional imports.

More info here: Conditionally importing and exporting library files

32. Need to declare a function type with generics? Use a typedef:

33. Need to work with computed variables? Use getters and setters.

34. Need to return a Future that returns immediately? Use `Future.value`.

35. Want to force a delay before executing some code? Use `Future.delayed`.

More tips coming next week. Subscribe via RSS for updates!

Happy coding!

Dart & Flutter Easy Wins 22-28

Andrea Bizzotto — Sun, 23 Aug 2020 14:39:49 +0000

I recently started a series of daily tweets about easy ways to improve your Dart & Flutter code. I called this Easy Wins.

To make these easier to find, I'm sharing 7 tips every week here.

22. Use `toStringAsFixed(n)` to format a number with n decimal places.

23. Did you know? Dart supports string multiplication.

24. One constructor is not enough? Use named constructors and initializer lists for more ergonomic APIs.

25. Prefer factory constructors to static methods for deserialization.

More info here: The difference between a "factory constructor" and a "static method"

26. Need a class that can only be instantiated once (aka singleton)? Use static instance variable with a private constructor.

27. Need a collection of unique items? Use a set rather than a list.

28. Use inheritance to model ISA relationships.

More tips coming next week. Subscribe via RSS for updates!

Happy coding!

Dart & Flutter Easy Wins 15-21

Andrea Bizzotto — Sun, 16 Aug 2020 16:32:04 +0000

I recently started a series of daily tweets about easy ways to improve your Dart & Flutter code. I called this Easy Wins.

To make these easier to find, I'm sharing 7 tips every week here.

15. Need to shallow copy a list or collection? Use the spread operator.

More info here: Clone a List, Map or Set in Dart | StackOverflow

16. Need to invoke a callback but only if it's not null? Use the "?.call()" syntax.

17. Implement a "call" method in your Dart classes to make them callable like a function.

18. Want a more ergonomic API for working with dates and times? Use extensions.

This API and many more are available in the dartx package.

19. Need to execute multiple Futures concurrently? Use Future.wait.

20. Want to selectively import some APIs in a package? Use show & hide.

21. Use "import as" to avoid name collisions with other packages.

More tips coming next week. Subscribe via RSS for updates!

Happy coding!

Dart & Flutter Easy Wins 8-14

Andrea Bizzotto — Thu, 13 Aug 2020 07:42:11 +0000

I recently started a series of daily tweets about easy ways to improve your Dart & Flutter code. I called this Easy Wins.

To make these easier to find, I'm sharing 7 tips every week here.

8. Use a `finally` block for code that should be executed both on success and failure.

9. Implement `toString()` in your classes to improve the debugging experience.

10. Use the if-null operator to provide a fallback for null values.

11. Use multi-line strings to represent large blocks of text.

12. String literals can use 'single' or "double" quotes as delimiters. Escape special characters with a backslash (), or use raw strings.

13. Use triple slashes to generate documentation comments.

14. Want to auto-generate hashCode, == and toString() implementations for your classes? Use the Equatable package:

Equatable package

More tips coming next week. Subscribe via RSS for updates!

Happy coding!

Dart & Flutter Easy Wins 1-7

Andrea Bizzotto — Sun, 09 Aug 2020 11:50:26 +0000

I recently started a series of daily tweets about easy ways to improve your Dart & Flutter code. I called this Easy Wins.

To make these easier to find, I'll be sharing 7 tips every week here.

Without further ado, here are the first 7 tips.

1. Prefer const over final over var

2. Use type annotations for safer code

3. Use underscores for unused function arguments

4. Functions are first class citizens in Dart, and they can be passed directly as arguments

5. You can use collection-if and spreads with lists, sets AND maps

6. Use the cascade operator to modify mutable variables

7. You can catch and handle exceptions by type with multiple `on` clauses

More tips coming next week. Subscribe via RSS for updates!

Happy coding!

Dart Null Safety: The Ultimate Guide to Non-Nullable Types

Andrea Bizzotto — Mon, 29 Jun 2020 10:21:06 +0000

The introduction of Null Safety in Dart 2.9 marks a major milestone for the language. Null Safety helps you avoid an entire class of problems, and enables some performance improvements.

This article outlines what's changed, and shows how to use the new Null Safety features by example.

As of June 2020, Null Safety is available in Tech Preview on the Dart dev channel. It's not yet available in the Flutter SDK, but you can try it at nullsafety.dartpad.dev:

This contains a "Learn from Snippets!" dropdown with mini-exercises to get familiar with the new syntax.

Some context
Dart Type System
Dart Null Safety: Benefits
Declaring Non-Nullable Variables
Declaring Nullable Variables
The assertion operator
Flow Analysis: Promotion
Flow Analysis: Definite Assignment
Using non-nullable variables with classes
Non-nullable named and positional arguments
Null-aware cascade operator
Null-aware subscript operator
The late keyword
Static and global variables
Conclusion
References

Some context

Null References were first introduced in 1965 in the ALGOL programming language, and since then they have been adopted by most mainstream programming languages.

However, null errors are so common that null references have been called the The Billion Dollar Mistake.

So let's see what's changed in Dart to address this.

Dart Type System

Before addressing Null Safety, let's talk about the Dart type system.

Dart is said to have a sound type system. When we write Dart code, the type checker makes sure that we can't write something like this:

int age = "hello world"; // A value of type `String` can't be assigned to a variable of type `int`

This code produces an error telling us that "a String value can't be assigned to a variable of type int".

Similarly, when we write a function in Dart, we can specify a return type:

int square(int value) {
  return value * value;
}

Because of type safety, Dart can guarantee with 100% confidence that this function always returns an int.

Type safety help us write safer programs, and more easily reason about the code.

But type safety alone can't guarantee that a variable (or return value) is not null.

As a result this code compiles, but generates an exception at runtime:

square(null);
// Unhandled Exception: NoSuchMethodError: The method '*' was called on null.

In this example it's easy enough to spot the problem. But in large codebases it's hard to keep track of what can and cannot be null.

Runtime null checks can mitigate the problem, but they add more noise:

int square(int value) {
  assert(value != null); // for debugging
  if (value == null) throw Exception();
  return value * value;
}

What we really want here is to tell Dart that the value argument should never be null.

A better solution is needed - and now we have it. 😎

Dart Null Safety: Benefits

Dart 2.9 introduces Sound Null Safety as a language feature, and brings three main benefits:

We can write null-safe code with strong compile-time guarantees. This makes us productive because Dart can tell us when we're doing something wrong.
We can more easily declare our intent. This leads to APIs that are self-documenting and easier to use.
The Dart compiler can optimise our code, resulting in smaller and faster programs.

So let's see how Null Safety works in practice.

Declaring Non-Nullable Variables

The main language change is that all types are now non-nullable by default.

This means that this code doesn't compile:

void main() {
  int age; // non-nullable
  age = null; // A value of type `Null` can't be assigned to a variable of type 'int'
}

When using non-nullable variables, we must follow one important rule:

Non-nullable variables must always be initialized with non-null values.

If you reason along these lines, it will be easier to understand all the new syntax changes.

Let's revisit this example:

int square(int value) {
  return value * value;
}

Here both the value argument and the return value are now guaranteed to be not null.

As a result runtime null checks are no longer necessary, and this code now produces a compile-time error:

square(null);
// The argument type 'Null' can't be assigned to the parameter type 'int'

But if all types are now non-nullable by default, how can we declare nullable variables?

Declaring Nullable Variables

The ? symbol is what we need:

String? name;  // initialized to null by default
int? age = 36;  // initialized to non-null
age = null; // can be re-assigned to null

Note: You don't need to initialize a nullable variable before using it. It is initialized to null by default.

Here are some other ways of declaring nullable variables:

// nullable function argument
void openSocket(int? port) {
  // port can be null
}

// nullable return type
String? lastName(String fullName) {
  final components = fullName.split(' ');
  return components.length > 1 ? components.last : null;
}

// using generics
T? firstNonNull<T>(List<T?> items) {
  // returns first non null element in list if any
  return items.firstWhere((item) => item != null);
}

Take away: you can declare nullable variables anywhere in your code with the ? syntax.

Nullable variables are a good way of expressing the absence of a value, and this is useful in many APIs.

When you design an API, ask yourself if a variable should be nullable or not, and declare it accordingly.

But there are cases where we know that something can't be null, but we can't prove it to the compiler. In these cases, the assertion operator can help.

The assertion operator

We can use the assertion operator ! to assign a nullable expression to a non-nullable variable:

int? maybeValue = 42;
int value = maybeValue!; // valid, value is non-nullable

By doing this, we're telling Dart that maybeValue is not null, and it's safe to assign it to a non-nullable variable.

Note that applying the assertion operator to a null value will throw a runtime exception:

String? name;
print(name!); // NoSuchMethodError: '<Unexpected Null Value>'
print(null!); // NoSuchMethodError: '<Unexpected Null Value>'

When your assumptions are wrong, the ! operator leads to runtime exceptions.

Sometimes we need to work with APIs that return nullable values. Let's revisit the lastName function:

String? lastName(String fullName) {
  final components = fullName.split(' ');
  return components.length > 1 ? components.last : null;
}

Here the type system can't help. If we know that the function will return a non-null value for a given argument, we should assign it to a non-nullable variable as soon as possible.

This is done with the ! operator:

// prefer this:
String last = lastName('Andrea Bizzotto')!;
// to this:
String? last = lastName('Andrea Bizzotto');

In summary:

Try to create non-nullable variables when possible, as these will be guaranteed to be not null at compile time.
If you know that a nullable expression won't be null, you can assign it to a non-nullable variable with the ! operator.

Flow Analysis: Promotion

Dart can make your life easier by taking into account null checks on nullable variables:

int absoluteValue(int? value) {
  if (value == null) {
    return 0;
  }
  // if we reach this point, value is non-null
  return value.abs();
}

Here we use an if statement to return early if the value argument is null.

Beyond that point, value cannot be null and is treated (or promoted) to a non-nullable value. Hence we can safely use value.abs() rather than value?.abs() (with the null-aware operator).

Similarly, we could throw an exception if the value is null:

int absoluteValue(int? value) {
  if (value == null) {
    throw Exception();
  }
  // if we reach this point, value is non-null
  return value.abs();
}

Once again, value is promoted to a non-nullable value, and the null-aware operator ?. is not needed.

In summary:

Use upfront null checks to return early or throw exceptions
After null checks, nullable variables are promoted to be non-nullable

And after a nullable variable has been null checked, Dart lets you use it as a non-nullable variable, which is quite nice.

Flow Analysis: Definite Assignment

Dart knows where variables are assigned and where they're read.

This example shows how to initialize a non-nullable variable after checking for a condition:

int sign(int x) {
  int result; // non-nullable
  print(result.abs()); // invalid: 'result' must be assigned before it can be used
  if (x >= 0) {
    result = 1;
  } else {
    result = -1;
  }
  print(result.abs()); // ok now
  return result;
}

As long as a non-nullable variable is given a value before it's used, Dart is happy.

Using non-nullable variables with classes

Instance variables in classes must be initialized if they are non-nullable:

class BaseUrl {
  String hostName; // Non-nullable instance field 'hostName' must be initialized

  int port = 80; // ok
}

If a non-nullable instance variable can't be initialized with a default value, set it with a constructor:

class BaseUrl {
  BaseUrl(this.hostName);
  String hostName; // now valid

  int port = 80; // ok
}

Non-nullable named and positional arguments

With Null Safety, non-nullable named arguments must always be required or have a default value.

This applies to regular methods as well as class constructors:

void printAbs({int value}) {  // 'value' can't have a value of null because of its type, and no non-null default value is provided
  print(value.abs());
}

class Host {
  Host({this.hostName}); // 'hostName' can't have a value of null because of its type, and no non-null default value is provided
  final String hostName;
}

We can fix the code above with the new required modifier, which replaces the old @required annotation:

void printAbs({required int value}) {
  print(value.abs());
}

class Host {
  Host({required this.hostName});
  final String hostName;
}

And when we use the above APIs, Dart can tell us if we're doing something wrong:

printAbs(); // The named parameter 'value' is required, but there's no corresponding argument
printAbs(value: null); // The argument type 'Null' can't be assigned to the parameter type 'int'
printAbs(value: -5); // ok

final host1 = Host(); // The named parameter 'hostName' is required, but there's no corresponding argument
final host2 = Host(hostName: null); // The argument type 'Null' can't be assigned to the parameter type 'String'
final host3 = Host(hostName: "example.com"); // ok

On the flip side, if we use nullable instance variables we can omit the required modifier (or the default value):

class Host {
  Host({this.hostName});
  final String? hostName; // nullable, initialized to `null` by default
}
// all valid cases
final host1 = Host(); // hostName is null
final host2 = Host(hostName: null); // hostName is null
final host3 = Host(hostName: "example.com"); // hostName is non-null

Positional parameters are subject to the same rules:

class Host {
  Host(this.hostName); // ok
  final String hostName;
}

class Host {
  Host([this.hostName]); // The parameter 'hostName' can't have a value of 'null' because of its type, and no non-null default value is provided
  final String hostName;
}

class Host {
  Host([this.hostName = "www.codewithandrea.com"]); // ok
  final String hostName;
}

class Host {
  Host([this.hostName]); // ok
  final String? hostName;
}

Between nullable and non-nullable variables, named and positional arguments, required and default values, there's a lot to take in. If you're confused, remember the golden rule:

Non-nullable variables must always be initialized with non-null values.

To fully understand all the Null Safety features, practice using them with Dartpad. Dart will tell if you're doing something wrong - so read the error messages carefully. 🔍

Null-aware cascade operator

To deal with Null Safety, the cascade operator now gains a new null-aware variant: ?... Example:

Path? path;
// will not do anything if path is null
path
  ?..moveTo(0, 0)
  ..lineTo(0, 2)
  ..lineTo(2, 2)
  ..lineTo(2, 0)
  ..lineTo(0, 0);

The cascade operations above will only be executed if path is not null.

The null-aware cascade operator can short-circuit, so only one ?.. operator is needed at the beginning of the sequence.

Null-aware subscript operator

Up until now, checking if a collection was null before using the subscript operator was verbose:

int? first(List<int>? items) {
  return items != null ? items[0] : null; // null check to prevent runtime null errors
}

Dart 2.9 introduces the null aware operator ?[], which makes this a lot easier:

int? first(List<int>? items) {
  return items?[0]; 
}

The late keyword

Use the late keyword to initialize a variable when it is first read, rather than when it's created.

A good example is when initializing variables in initState():

class ExampleState extends State {
  late final TextEditingController textEditingController;

  @override
  void initState() {
    super.initState();
    textEditingController = TextEditingController();
  }
}

Even better, initState() can be removed altogether:

class ExampleState extends State {
  // late - will be initialized when first used (in the build method)
  late final textEditingController = TextEditingController();
}

It's common to use late in combination with final, to defer the creation of read-only variables to when they are first read.

This is ideal when creating variables whose initializer does some heavy work:

late final taskResult = doHeavyComputation();

When used within a function body, late and final can be used like this:

void foo() {
  late final int x;

  x = 5; // ok
  x = 6; // The late final local variable is already definitely initialized
}

Though I don't recomment using late variables this way. Because this style can result in non-obvious runtime errors. Example:

class X {
  late final int x;

  void set1() => x = 1;

  void set2() => x = 2;
}

void main() {
  X x = X();
  x.set1();
  print(x.x);
  x.set2(); // LateInitializationError: Field 'x' has already been initialized.
  print(x.x);
}

By declaring a non-nullable late variable, we promise that it will be non-null at runtime, and Dart helps us with some compile-time guarantees.

But I recommend to only use late sparingly, and to always initialize late variables when they are declared.

Static and global variables

All global variables must now be initialized when they are declared unless they are late:

int global1 = 42; // ok

int global2; // The non-nullable variable 'global2' must be initialized

late int global3; // ok

The same applies to static class variables:

class Constants {
  static int x = 10; // ok
  static int y; // The non-nullable variable 'y' must be initialized
  static late int z; // ok
}

But as I said before, I do not recommend using late this way as it can lead to runtime errors.

Conclusion

Null Safety is a major change for the Dart language, and it has been introduced to help you write better and safer code.

But at the end of the day, Null Safety is just a tool, and it is your job to use it correctly.

Every time you declare a variable in Dart, think about whether it should be nullable or not. This may seem like extra work, but it will lead to better code and Dart can help you along the way.

As of June 2020, Null Safety is in Tech Preview, and is not intended to be used in production code. Full Null Safety as a stable feature is planned before the end of the year (for the latest updates see dart.dev/null-safety).

If you can't wait, you can port existing projects to Null Safety and automate the process with this migration tool.

References

This article was mainly inspired by these sources:

Migration resources:

Happy coding!

23 Top Tips to Become a Better Software Engineer

Andrea Bizzotto — Thu, 25 Jun 2020 20:46:20 +0000

This article was originally published on my website.

Also available on YouTube.

One question people often ask me is:

How can I become a Pro / Senior software engineer, and how long will it take?

And if I have to be honest, I don't think this is the right question to ask.

I've been coding for over 15 years, and to this day there is just so much stuff that I still don't know.

There isn't really a magical moment when you become a Pro.

Rather, you should have the right mindset, and realize that programming is a long and winding journey. It can have ups and downs, but also be very rewarding and enjoyable.

So in this article I'm sharing 23 top tips that can help you become a better software developer.

1. Always be learning

The Tech industry is very volatile and things change all the time. There are so many technologies to learn and so many languages to choose from.

This can be quite intimidating. But if you have the right mindset, and you like learning new things, you can enjoy the journey without feeling overwhelmed.

And of course, everyone learns differently. So find the method that works best for you, and get good at it.

2. Pick one language and stick to it

If you try to learn too many things at once, you're more likely to lose your motivation and give up.

Forget about the endless stream of articles and people telling you that you need to learn this new language or that new library.

Instead pick just one that you're excited about, start with the basics and stick with it until you're comfortable with it.

As you get started, it may be a good idea to read the documentation and follow some tutorials, to get a basic grasp of the language.

But after that, there's no better way to learn a language than to build something with it.

Only after you have a good understanding of the fundamentals, consider learning a new language to broaden your skills.

3. Build something

Maybe there's an app or a website that you wanted to build for a long time.

Make this a side project.

If you can, set aside some time to work on it every day.

Maybe you'll feel that you're not accomplishing much on any given day, but Rome wasn't built in a day.

After a few weeks or months you'll see your product coming to life, and this is extremely satisfying.

Choose a project that challenges you, but is not too far above your skill level. As you build your confidence, you can go bigger and tackle more complex projects.

In fact, you only improve when you keep challenging yourself. Keep building new and different things.

4. Break out of tutorial hell

If you are just starting to learn, it's very easy to fall in a trap where you do tutorial after tutorial after tutorial.

Guess what? Once you get a job no-one is going to hold your hand, and there won't be a tutorial for every single task you need to get done.

Try to break out of this cycle, and figure things out on your own.

By solving problems yourself, your learning will improve considerably and you'll have a more concrete understanding of how things work.

5. Read the documentation

This is the single best way of breaking out of tutorial hell.

And the good news is that, documentation is just one click away. You can easily see the documentation for your SDK or libraries you use right from your editor.

To be fair, not all documentation is created equal and some languages have it better than others.

But knowing how to read it and use it, means that you no longer have to rely on tutorials.

6. Learn how to debug

Coding is great but it can also be a frustrating experience.

It's hard to know upfront every state that your code can be in (though writing tests helps with that).

Sometimes things won't work, and you'll find yourself stuck for hours without making progress.

So what can you do when that happens?

If you're getting some errors in your console, read them carefully as they may contain the information you need in order to solve your problem.

Try to become familiar with the debugging tools in your code editor.

Use print statements and breakpoints to step through your code and verify your assumptions, and learn more advanced debugging techniques too. These can save you a lot of time.

7. Get good at Googling

This is an essential skill that programmers use all the time, even senior ones.

So knowing how to find answers effectively can save you a lot of time.

If you encounter an error, you can copy paste it into your favourite search engine, and carefully review all the relevant answers.

It may take you a bit of time to figure out how to do this effectively, but you'll get better at it over time.

8. Understand how the code ACTUALLY works

We've all been there. We found some code on Stack Overflow, and added it to our project, hoping it might work.

Don't just stop there. Take the time to understand how the code actually works. Make sure that it works under all possible cases, and adjust it to fit your project style and conventions.

As a word of caution, code that you find on StackOverflow or other forums gets quickly out of date. See tip #5 about reading the documentation.

9. Reach out if you need help

If you can't find the answer you need, don't let that discourage you.

You can always post your question on StackOverflow. When you do this, choose a good title, and try to give enough context so that others can help you.

Also, find out if your specific language or framework has a Slack or Discord channel, and join it.

You may just find that there is an entire community of developers that are willing to help, as long as you're polite and ask nicely.

10. Learn how to write tests

This will make you a better developer, and force you to think about all possible edge cases in your code - not just the happy path.

It will also teach you how to write testable code, and learn about important concepts like dependency injection.

When you choose which tests to write, ask yourself:

What would be the impact if this feature didn't work?

Then prioritize writing tests by impact:

a broken link for showing the terms & conditions in the setting page may not be a big deal.
a purchase flow that fails and doesn't unlock core features in your app is a big deal.

Try to have good test coverage for business-critical code, and automate as many tests as possible.

11. Learn Git and how to use the Terminal

No matter what area of programming you're in, you need at least some basic knowledge of Git and the command line - you'll be using these tools day in, day out.

Try to learn about the more advanced features of Git as well. These will be very helpful when you work on projects with multiple collaborators.

Also, become familiar with continuous integration systems and how to set them up.

12. Create value for your users and the business

The reason you're coding is that you're trying to solve a real, tangible problem that your users or customers have.

So always try to focus on the users and business needs, and have the big picture in mind.

That way you're more likely to add value to the product.

One mistake that I often see other developers make, is to get stuck on one problem and go deeper and deeper into the rabbit hole.

That's not a very effective use of time.

So the next time this happens to you, set a time limit. Once the time is up, stop and take a break. Maybe the solution will come to you later in the shower. 🚿

13. Problem solving

Customers/companies will pay you to solve their problems, not to know the syntax of language X.

Learn how to break problems into smaller ones that are easier to solve.

To solve big problems, you need to think about the big picture, all the way from UX to system design.

To design and build an entire product, and you'll need (at least some) knowledge of:

UI/UX design
data structures and algorithms
design patterns and system architecture
networking and databases

Of course, if your role is more specialized you can focus on one specific area.

But in any case, you'll need to choose the right tools for the job.

Problem solving is an abstract, broad skill that takes time to develop.

My best advice here is to work on many different projects. As you do this, you'll start seeing what works and what doesn't, and draw on your previous experience.

Quoting Dan Abramov on Twitter:

The reason an experienced engineer moves so much faster than a beginner is because they opened most of the “doors” they encounter in code thousands of times before. They stop to think, but so much is done purely by recall. This is why you need to practice, practice, practice - Dan Abramov

14. Focus

To be good at coding you need to focus and work without interruptions for a long enough amount of time.

When you're coding, try to avoid all distractions. That includes social media, emails, your cat, as well as Slack and other ways that your co-workers may reach you.

If needed, set specific times for this. Make it clear when you're in the coding zone, and others will respect that.

15. Be Organized & Plan Ahead

If you fail to plan, you are planning to fail - Benjamin Franklin

Whether you're working on just one project, or have many things at hand and you need to keep on top of them, try to be organized.

One of my habits is to keep a daily TODO list of all the things that I plan to do.

And I find it very satisfying to tick off all the tasks at the end of the day (though sometimes I move them to the next day 😅).

Beyond that I also have longer term goals and plans, so that I can keep track of my progress and focus on what matters.

To organize all my work I use Notion, which has become my favourite productivity tool (disclosure: I'm not sponsoring Notion - I just really like it).

16. Learn to read other people's code

Chances are that throughout your career you'll spend more time reading code, than writing it.

Getting good at reading code will help you to understand many different codebases.

Where can you do this?

Read the documentation and source code for libraries or frameworks you already use.
Find some popular open source projects on GitHub. Once you find a good project, check out the code, and open it in your editor. Then try to run it and understand how it works.
If you work in a team, do code reviews.

As you do this, try to think about how the code could be improved.

Doing this will make you more aware about style and conventions, so that you can improve the way you write your code.

Your future self will thank you for this. 😉

17. Get involved in Open Source

By contributing to existing open-source projects, you can improve your code-reading skills, and get valuable feedback on your own code.

To get started, you can join the GitHub open source community, which contains many useful resources.

By writing open source code, you can stop re-inventing the wheel and carry over your best code across projects. And if your project is useful enough, it can have a big impact.

Doing this is also great for your CV. A good GitHub profile shows tangible proof of your skills and coding style, and increases your chances of getting a job.

On a personal note, my GitHub profile alone allowed me to stand out in job interviews and negotiate great offers time and again, before I even became an instructor and a Flutter GDE.

18. Stay up to date

You don't need to read every single article and watch every YouTube video out there.

And you shouldn't be following tutorials only. Trying things out on your own is more important.

But you should try to find the right resources to fast-track your learning, so that you don't have to figure out everything by yourself.

Try to find a list of experts who regularly share quality content, and subscribe to their feeds (if you're into Flutter, here's a good list).

I find this is a great way to stay up to date and learn about new things.

19. Learn basic design

You don't need to become a professional designer.

But you should understand the basic principles of design, and become familiar with at least one design tool (here's a few: Sketch, Figma, Adobe XD).

This way you can make your own work look good, especially if potential employers or clients will see this.

But it also expands your sphere of knowledge, and helps you think about problems in terms of UX and not just code.

20. Learn to communicate

This one is super important. I don't think you can be a great developer if you can't communicate well.

You should be able to explain things in plain English (even if it's not your first language), so that non-technical people in your team can understand you.

Beyond that, always communicate clearly what you're working on, what problems you're facing, and make sure you do what you say you'll do.

If you work remotely, take 5 minutes every day to share your updates. I always do this, and my clients really appreciate it.

All this builds trust. Being reliable and trustworthy can be your single best asset, and is absolutely critical if you are a freelancer.

21. Do your best work

Your work is your brand. Your brand is what sets you apart. So always aim to deliver the best work you can.

If you can impress the people you work with, they're more likely to recommend you when you're looking for a new job.

And when you publish your own work, whether it's a GitHub project, your portfolio, an article or YouTube video, that is for everyone to see. So make it look great.

22. Share your knowledge

When you learn something useful, blog about it. Explaining things in writing can improve your knowledge on a certain topic.

Practice making your writing more clear and concise. This is a valuable skill in itself - especially if you work remotely.

Keep writing, and you'll build a trove of knowledge that you can share with others, and come back to when you need.

This will also boost your profile and CV, and help you engage with your community.

23. Take care of yourself

Life is short and things can go wrong faster than you may think.

So drink plenty of water. Do exercise. Eat & sleep well. Don't work too much.

Look after yourself and others close to you.

Feeling overwhelmed?

We've covered a lot of stuff. If all this feels a bit overwhelming, don't worry.

Take things step by step. As long as you're learning and continuing to grow, then you're on the right track.

Still not sure where to start (or where to go next)?

Check out this Developer Roadmaps website. It includes learning roadmaps for frontend, backend developers and more.

UPDATE 2020-06-18: A new Flutter Developer Roadmap 2020 was published on GitHub. Check it out here!

Conclusion

When I started writing this article, I had four items on my list. I ended up with 23, and there are still many more that I have left out.

What are your top tips? Let me know in the comments.

Thanks for reading!

How to Create Dart Packages for Your Flutter Apps

Andrea Bizzotto — Mon, 01 Jun 2020 06:52:16 +0000

This article was originally published on my website.

Watch the Video Tutorial on YouTube.

In this tutorial I'll show you how to create Dart packages for your Flutter apps, so that you can improve and reuse your code.

Why is this important?

With large applications, it is challenging to keep folders organized, and minimise inter-dependencies between files and different parts of the app.

Dart packages solve this problem by making apps more modular and dependencies more explicit.

So if you have a single large application, or multiple apps that need to share some functionality, extracting reusable code into packages is the way forward.

How this tutorial is organized

We will start with a step-by-step guide and convert a sample BMI calculator application to use internal packages within the same project.

Then, we will talk about:

Dealing with existing, large apps
Reusing packages across multiple apps
Local vs remove (git) packages
Versioning packages and the humble changelog

Let's get started!

Example: BMI calculator

To follow along each step, you can download the starter project here.

Suppose we have a single page BMI calculator app, composed of these four files:

lib/
    bmi_calculation_page.dart
    bmi_calculator.dart
    bmi_formatter.dart
    main.dart

The most interesting functionality is in bmi_calculator.dart and bmi_formatter.dart:

// bmi_calculator.dart
double calculateBMI(double weight, double height) {
  return weight / (height * height);
}

// bmi_formatter.dart
import 'package:intl/intl.dart';

String formattedBMI(double bmi) {
  final formatter = NumberFormat('###.#');
  return formatter.format(bmi);
}

The UI is built with a single BMICalculationPage widget class. This shows two input text fields for the weight and height, and one output text field for the BMI (full source here):

This app is simple enough that we can keep all files inside lib. But how can we reuse the BMI calculation and formatting logic across other projects?

We could copy-paste bmi_calculator.dart and bmi_formatter.dart on each new project.

But copy pasting is rarely a good thing. If we want to change the number of decimal places in the formatter code, we have to do it in each project. Not very DRY. 🌵

Creating a new package

A better approach is to create a new package for all the shared code.

In doing this, we should consider the following:

By convention, all packages should go inside a packages folder.
When starting from a single application, it's simpler to add the new package(s) inside the same git repo.
If we need to share packages across multiple projects, we can move them to a new git repo (more on this below).
We can keep multiple packages inside a single repository. The FlutterFire monorepo is a good example of this, and I recommend we do the same for simplicity.

For this example, we'll add a new package and keep it inside the same git repo.

From the root of your project, we can run this:

mkdir packages
cd packages
flutter create --template=package bmi

This will create a new Flutter package in packages/bmi, but the main.dart file with the usual runApp(MyApp()) code is missing. Instead, we have a bmi.dart file with some default boilerplate:

library bmi;

/// A Calculator.
class Calculator {
  /// Returns [value] plus 1.
  int addOne(int value) => value + 1;
}

As we don't need the Calculator class, we can replace it with the BMI calculation and formatting code from the main app.

The simplest way to do this is to add all the code from lib/bmi_calculator.dart and lib/bmi_formatter.dart to packages/bmi/lib/bmi.dart (we will see later on how to have multiple files inside a package):

// bmi.dart
library bmi;

import 'package:intl/intl.dart';

double calculateBMI(double weight, double height) {
  return weight / (height * height);
}

String formattedBMI(double bmi) {
  final formatter = NumberFormat('###.#');
  return formatter.format(bmi);
}

Note that this code depends on intl, so we need to add this to the pubspec.yaml file of our package:

dependencies:
  flutter:
    sdk: flutter
  intl: ^0.16.1

Using the new package

Now that we have a bmi package, we need to add it as a dependency to our app's pubspec.yaml file:

dependencies:
  flutter:
    sdk: flutter
  # Used by bmi_calculation_page.dart
  flutter_hooks: ^0.9.0
  # we no longer need to import intl explicitly, as bmi already depends on it
  bmi:
    path: packages/bmi

Here we use a path argument to tell Flutter where to find our new package. This works as long as the package lives in the same repo.

After running flutter pub get (from the root of the project), the package will be installed and we can use it, just like we would do with any other Dart package.

So we can update the imports in our bmi_calculator_page.dart from this:

import 'package:bmi_calculator_app_flutter/bmi_calculator.dart';
import 'package:bmi_calculator_app_flutter/bmi_formatter.dart';

to this:

import 'package:bmi/bmi.dart';

And viola! Our code works and we can now remove bmi_calculator.dart and bmi_formatter.dart from the main app project. 🏁

In summary, to extract existing code to a separate package we have to:

create a new package and move our code inside it.
add any dependencies to the pubspec.yaml file for the package.
add the new package as a dependency to pubspec.yaml for our application.
replace the old imports with the new package where needed.
delete all the old files.

Bonus: Adding multiple files to a package with `part` and `part of`

This example is simple enough that we can keep the BMI calculation and formatting code in bmi.dart.

But as our package grows, we should split the code into multiple files.

So rather than keeping everything in one file like this:

// bmi.dart
library bmi;

import 'package:intl/intl.dart';

double calculateBMI(double weight, double height) {
  return weight / (height * height);
}

String formattedBMI(double bmi) {
  final formatter = NumberFormat('###.#');
  return formatter.format(bmi);
}

We can move the calculateBMI and formattedBMI methods in separate files, just like we had them at the beginning:

// bmi_calculator.dart
part of bmi;

double calculateBMI(double weight, double height) {
  return weight / (height * height);
}

// bmi_formatter.dart
part of bmi;

String formattedBMI(double bmi) {
  final formatter = NumberFormat('###.#');
  return formatter.format(bmi);
}

Then, we can update bmi.dart to specify its parts:

// bmi.dart
library bmi;

import 'package:intl/intl.dart';

part 'bmi_calculator.dart';
part 'bmi_formatter.dart';

A few notes:

Files declared with part of should not contain any imports, or we'll get compile errors.
Instead, all imports should remain in the main file that specifies all the parts.

In essence, we're saying that bmi_calculator.dart and bmi_formatter.dart are part of bmi.dart.

When we import bmi.dart in the main app, all public symbols defined in all its parts will be visible.

In other words, our main app just needs to import 'package:bmi/bmi.dart';, and have access to all the methods declared in all its parts.

Job done! You can find the finished project for this tutorial here.

Note: Using part and part of works well if you have just a few files in the same folder. One library that uses this extensively is flutter_bloc, where it's common to define state, event and bloc classes together.

For more complex apps it's advisable (and recommended by the Dart team) to export library files instead. See this official guide on creating packages for more details.

Top tip: moving code into packages is a great opportunity to move existing tests, or write new ones.

Creating a package for a simple app is easy enough, but how do we do this when we have complex apps?

Dealing with existing, large apps

For more complex apps, we can incrementally move code into self-contained packages.

This forces us to think harder about the dependencies between packages.

But if there are already a lot of inter-dependencies, how do we get started?

A bottom-up approach is most effective. Consider this example:

// lib/a.dart
import 'b.dart';
import 'c.dart';

// lib/b.dart
import 'c.dart';

// lib/d.dart
import 'a.dart';
import 'c.dart';

// lib/c.dart
// no imports

As we can see, c.dart doesn't depend on any files.

So moving c.dart into a c package would be a good first step.

Then, we could move b.dart into a separate b package, making sure to add c as a dependency:

# packages/b/pubspec.yaml
dependencies:
  flutter:
    sdk: flutter
  c:
    path: packages/c

And we can repeat this process until all dependencies are taken care of.

It's still our job to decide how many packages to create, and what goes in each one.

Reusing packages across multiple apps

Up until now we've seen how to create new packages within the same project.

If we want to reuse packages across multiple projects, we can move them to a common shared repository.

Using the BMI calculator example, we could update the pubspec.yaml file to point to the new repository:

dependencies:
  ...
  bmi:
    git:
      url: https://github.com/your-username/bmi
      path: packages/bmi

I followed this approach when refactoring my starter architecture project, and ended up with 6 new packages that I now reuse in other projects.

To learn more about to the package dependencies syntax, read this page on the Dart documentation.

Local vs remove (git) packages

Dart packages make our code cleaner and increase code reuse, but do they slow us down?

As long as we specify dependencies with path in our pubspec.yaml file, we can edit, commit and push all our code (main app and packages) just as we did before.

But if we move our packages to a separate repo, getting the latest code for our packages becomes more difficult:

dependencies:
  ...
  bmi:
    git:
      url: https://github.com/your-username/bmi
      path: packages/bmi

That's because pub will cache packages when we use git as a source. Running flutter pub get will keep the old cached version, even if we have pushed changes to the package.

As a workaround we can:

comment out our package
run flutter pub get (to delete it from cache)
uncomment the package
run flutter pub get again (to get the latest changes)

Repeating these steps every time we make a change is not fun. 🤔

Bottom line: we get the fastest turnaround time by keeping all our code (apps and packages) in the same git repo. That way we can specify package dependencies with path and always use the latest code.

Versioning packages

When we import packages from pub.dev, we normally specify which version we want to use.

Each version corresponds to a release, and we can preview the changelog to see what changes across releases (example changelog from Provider).

This makes it a lot easier to see what changed and when, and can help pinpoint bugs/regressions to a specific release.

As you develop your own packages, I encourage you to also have a changelog. And don't forget to update the package version, which lives at the top of the pubspec.yaml file:

name: bmi
description: Utility functions to calculate the BMI.
version: 0.0.1
author:
homepage:

This is a good and useful habit if other devs will use your code, or you plan to publish your package on pub.dev.

Challenge: Refactor your apps

Time to put things in practice with a challenge.

Try extracting some code from one of your Flutter projects, and move it to one of more packages.

And use this as an opportunity to think about dependencies in your own projects.

Conclusion

Dart packages are a good way to scale up projects, whether you work for yourself or as part of a big organization.

They make code more modular and reusable, and with clearly defined dependencies.

They also make it easier to split code ownership with other collaborators.

You should consider using them, whether you're working on a single large app, or many separate apps.

After all, there's a reason we have an entire package ecosystem on pub.dev. 😎

Happy coding!

Flutter REST API Crash Course Launch: Build a Coronavirus Tracking App

Andrea Bizzotto — Mon, 02 Mar 2020 09:03:55 +0000

This article was originally published on my website.

Watch Video Tutorial on YouTube.

Today I'm launching a new crash course, where you will learn how to use REST APIs with Dart and Flutter.

I created this course because REST APIs are used everywhere in today's web.

And if you master the basics of the Dart http library, you can write Flutter apps that can tap into thousands of web APIs.

So in this crash course we will build a simple but completely functional Coronavirus Tracker Application in Flutter.

This application is just a simple dashboard that shows all the cases of Coronavirus worldwide.

We will use the nCoV 2019 REST API to fetch the data. This is a free API that is relatively simple to use. But from a technical point of view, it will give us plenty of things to learn about.

What's in this course

Here's a list of topics that are covered in this crash course:

Short introduction to REST: what it is and how it works
Overview of the nCoV 2019 health API. This is used to fetch statistics about the Coronavirus outbreak around the world.
Api keys & access tokens: what they are and how to use them
REST Client: a VSCode extension that you can use to send HTTP requests and view the response directly in VS Code
Design a REST API service in Dart: we will use the http package and learn how to make requests
Parsing JSON, as needed when handling responses from the REST API
Build a single-page UI, using the API service that we created
Combine multiple API requests into a single response by using futures
How to use a RefreshIndicator to get updated data from the API
Error handling: a very important topic when designing robust applications
Shared preferences: we will use this to cache API responses, so that the data is saved on device for offline use

This course is all about mastering the basics. While we will only build a single page application, you will get all the knowledge you need to work with REST APIs in Dart, and use them to build slick-looking UIs in Flutter.

Not only that, but we will talk about app architecture as well. Architecture is a very important topic, so we will build this app following best practices.

And I'm confident that by the end of this course, you will be able to build Flutter apps that connect with any other REST API that you want to use.

Course organization

This course will be divided into separate videos, and follow the topics in the order that I have described.
You will have access to the full source code for each lesson, right here on GitHub.

Prerequisites

Familiarity with the Dart Language. If you're new to Dart, check out my Dart Introduction on YouTube.
Have Flutter installed on your system.
Visual Studio Code or Android Studio, configured for Flutter development.
Some prior knowledge of the most common Flutter widgets, and the difference between stateful and stateless widgets.

Basics aside, this course is for you if you want to learn how to use REST APIs and build maintainable Flutter apps.

Where to find this crash course

Part of this course will be available for free on YouTube.
To get the full content, you have to buy the course on Teachable.

Included for free

Short introduction to REST
Overview of the nCoV 2019 health API
Api keys & access tokens
REST Client
Design a REST API service in Dart
Parsing JSON

Included in the paid course

All of the above, plus:

Build a single-page UI
Combine multiple API requests with Futures
How to use a RefreshIndicator
Error handling
Shared preferences and caching

The paid course comes with premium support. I will aim to answer all questions within 24 hours.

I will also keep it up to date with the latest Flutter and Dart packages.

So to recap, you'll get a few lessons for free here on YouTube. But the full course will be available on Teachable.

What about Udemy?

This is not planned for now. I think I will be able to offer a better teaching experience on Teachable.

I will offer this and future courses on Teachable. And you'll be able to purchase multiple courses for a discounted price in a single bundle. This is not something that is possible with Udemy.

Course length

The final course will likely have between 2 and 3 hours of content.

As a crash course, it aims to get you up to speed with REST APIs in a short amount of time.

Pricing

The course is already on sale with an introductory price of $12.

This includes the first chapter of the course, with an introduction to REST APIs.

I'll try to add new content on a weekly basis. The course should be complete within the next couple of months.

Enroll today to get the course and all future updates for $12.

The price will go up as I add more content.

Now is the best time to purchase my course. You can enroll at this link:

courses.codewithandrea.com

Happy coding!

DEV Community: Andrea Bizzotto

My 2020 as a Content Creator: Udemy, Teachable, and YouTube Revenue and Income Report

Why did I become a content creator?

2020 Goals

2020 Income Report

2020 Udemy Income

Flutter & Firebase Course

Flutter REST API Course

Dart Course

Udemy is a very crowded platform

Teachable as a course platform

My year on YouTube

As a content creator, what are the right metrics?

CodeWithAndrea.com

The Blogging For Devs community

My new newsletter

Twitter and other platforms

Breakdown of my activities in 2020

Ongoing Expenses

Content Creation - the drawbacks

Stuff changes all the time

Content Creation vs Building SaaS products vs Consulting

Other content creation drawbacks

Helping People Learn

value > money

2021 Goals

Wrap Up

Top 16 Dart Tips and Tricks Every Flutter Developer Should Know

1. Did you know? Dart supports string multiplication.

2. Need to execute multiple Futures concurrently? Use Future.wait.

3. Implement a "call" method in your Dart classes to make them callable like a function.

4. Need to invoke a callback but only if it's not null? Use the "?.call()" syntax.

5. Using anonymous functions and functions as arguments

6. You can use collection-if and spreads with lists, sets AND maps

7. Need to iterate through a map in a null-safe manner? Use .entries:

8. Use named constructors and initializer lists for more ergonomic APIs.

9. Getters and setters

10. Use underscores for unused function arguments

11. Need a class that can only be instantiated once (aka singleton)? Use a static instance variable with a private constructor.

12. Need a collection of unique items? Use a Set rather than a List.

13. How to use try, on, catch, rethrow, finally

14. Common Future constructors

15. Common Stream constructors

16. Sync and Async Generators

Conclusion

Complete Dart Course

Dart & Flutter Easy Wins 36-42

36. Use Timer.periodic to create a timer that repeats with a given period

37. Need to convert an enum to an int or viceversa? Use .index and values[i]

38. Use asserts to disrupt program execution if a boolean condition is false

39. Need a better logger for your apps? Use the logger package

40. Use the Flutter DevTools to inspect and profile your Flutter apps

41. Anonymous functions can be assigned to variables, or passed as arguments to other functions

42. Want a function that can only throw? Use Never

Dart & Flutter Easy Wins 29-35

29. When EXTENDING classes, all ABSTRACT methods MUST be overridden & other methods CAN be overridden. When IMPLEMENTING classes, ALL methods MUST be overridden.

30. Need to iterate through a map in a null-safe manner? Use .entries:

31. Need different implementations for web and native platforms? Use conditional imports.

32. Need to declare a function type with generics? Use a typedef:

33. Need to work with computed variables? Use getters and setters.

34. Need to return a Future that returns immediately? Use Future.value.

35. Want to force a delay before executing some code? Use Future.delayed.

Dart & Flutter Easy Wins 22-28

22. Use toStringAsFixed(n) to format a number with n decimal places.

23. Did you know? Dart supports string multiplication.

24. One constructor is not enough? Use named constructors and initializer lists for more ergonomic APIs.

25. Prefer factory constructors to static methods for deserialization.

26. Need a class that can only be instantiated once (aka singleton)? Use static instance variable with a private constructor.

27. Need a collection of unique items? Use a set rather than a list.

28. Use inheritance to model ISA relationships.

Dart & Flutter Easy Wins 15-21

15. Need to shallow copy a list or collection? Use the spread operator.

16. Need to invoke a callback but only if it's not null? Use the "?.call()" syntax.

17. Implement a "call" method in your Dart classes to make them callable like a function.

18. Want a more ergonomic API for working with dates and times? Use extensions.

19. Need to execute multiple Futures concurrently? Use Future.wait.

20. Want to selectively import some APIs in a package? Use show & hide.

21. Use "import as" to avoid name collisions with other packages.

Dart & Flutter Easy Wins 8-14

8. Use a finally block for code that should be executed both on success and failure.

7. Need to iterate through a map in a null-safe manner? Use `.entries`:

36. Use `Timer.periodic` to create a timer that repeats with a given period

37. Need to convert an enum to an int or viceversa? Use `.index` and `values[i]`

30. Need to iterate through a map in a null-safe manner? Use `.entries`:

34. Need to return a Future that returns immediately? Use `Future.value`.

35. Want to force a delay before executing some code? Use `Future.delayed`.

22. Use `toStringAsFixed(n)` to format a number with n decimal places.

8. Use a `finally` block for code that should be executed both on success and failure.

9. Implement `toString()` in your classes to improve the debugging experience.

7. You can catch and handle exceptions by type with multiple `on` clauses

Bonus: Adding multiple files to a package with `part` and `part of`