So, let’s say you’re writing an app using Flutter and you need to develop a widget that takes up 40% of the total screen width. What solution comes to mind? If you thought immediately about using MediaQuery, bravo; go get yourself a soda!

So now you use the MediaQuery class to fetch the size of the screen.

Size size = MediaQuery.of(context).size;
double screenWidth = size.width;

Now, if you’re a dev who’s been working with Flutter for a while, you’ll know that this is a quite frequent operation. I have seen projects where almost every widget file has these two lines in the build method, in one way or another.

But it gets tedious to copy and paste these lines in every single dart file, right? What if there was a way to do this in a simpler way; a way that’s more readable and easier to use along with that sick autocomplete you got going in your VSCode (Android Studio users don’t hate me).

Turns out, there actually is! After all, you read the title before clicking on this blog, didn’t you? 😉

How To: Use Extensions optimally

Let’s refer to the example snippet we saw earlier above. The same can be achieved using an extension on the class BuildContext like this:

extension ContextExtensions on BuildContext {
  Size get screenSize => MediaQuery.of(this).size;
}

So next time you want to get the screen size using MediaQuery, you can just do this:

@override
Widget build(BuildContext context) {
  Size screenSize = context.screenSize;
  
  return Container(
    height: screenSize.height * 0.9,
    width: screenSize.width,
  );
}

Easy, right? Now, to conclude, I would like to offer a bit of friendly advice. Just because extensions methods exist, doesn’t mean you have to spam and use it every time every where. What do I mean? Let me elaborate.

Here’s another example of when you SHOULD use extensions.

// Without Extension
String capitalize(String input) {
  return input.isEmpty ? '' : input[0].toUpperCase() + input.substring(1);
}

// With Extension
extension StringCapitalization on String {
  String capitalize() {
    return isEmpty ? '' : this[0].toUpperCase() + substring(1);
  }
}

And here’s an example of when you SHOULD NOT be using extensions.

// Without Extension
class Circle {
  double radius;

  Circle(this.radius);

  double calculateArea() {
    return 3.14 * radius * radius;
  }
}

// With Extension (unnecessary in this case)
extension CircleAreaCalculation on Circle {
  double calculateArea() {
    return 3.14 * radius * radius;
  }
}

Dart extensions are a powerful feature, but they are not always necessary, and using them when simpler alternatives are available might lead to code complexity, which will be ironical (LOL) because the very reason you turned to extensions was to save precious time and avoid tedious effort.

And… that’s it. You now bear the power of Dart extensions! Go build great apps!

Until next time.

If you’re someone who’s been developing mobile apps for a while, you’ve probably used REST APIs for fetching/storing data on a remote server somewhere. These APIs use something that we in the tech biz call HTTP protocols, so the calls that we make to these APIs are often called as HTTP requests.

Why are we talking about HTTP requests in an article about Websockets?

“Before one learns something, one must learn WHY it exists in the first place.” — Unknown

Why do we need websockets?

As it turns out, HTTP requests are uni-directional or one-way requests. That means, once an HTTP request is sent, the sender needs to wait for a response from the receiver. This sounds perfectly fine, but now imagine using this in a chat application. Two devices chatting with each other would have to constantly keep making HTTP requests to keep track of each other’s messages. This is not just tedious but also a costly operation to perform.

Does this mean HTTP cannot be used for messaging apps? No. Take Gmail, or any other email service for instance. The sender of the email simply needs to send an email, without the need of an immediate reply from the receiver. HTTP is more than sufficient enough to be applied in this case.

Coming back to the chat application case, it is quite clear that HTTP isn’t the best option to go through. We would need to use a protocol that can pass information both ways, in realtime.

Enter, the websocket. WebSocket is a communications protocol for a persistent, bi-directional, full duplex TCP connection from a client to a server.

How a Websocket works

A WebSocket connection is initiated by sending a WebSocket handshake request from a browser’s HTTP connection to a server to upgrade the connection. From that point, the connection is binary and does not conform to the HTTP protocol. A server application is aware of all WebSocket connections and can communicate with each one individually.

As WebSocket remains open, either the server or the client can send messages at any time until one of them closes the session. The communication can be initiated at either end, which makes event-driven programming possible.

Common applications of websockets

You’d be surprised to learn how many things we use on a daily basis harness the power of websockets. Some of them are:

• Realtime Chatting apps (duh) eg. WhatsApp, Messenger, Telegram, etc
• Multiplayer games eg. Valorant, CS:GO, Apex Legends, PUBG, etc
• Collaborative apps eg. Figma, Google Docs
• Audio/Video Chats eg. Skype, Google Meet
• Realtime location apps eg. Google Maps, Apple Maps

You get the point. Without websockets, most of us wouldn’t be living the same convenient lives we are living right now.

Fun Fact

If you’re someone who plays online multiplayer games, you must’ve faced Ping issues at least once. This “Ping”, is a term used in the ping-pong method to ensure that the websocket is connected to the server. The approach goes something like this:

1. The client sends a “ping” type of message with some dummy data to the server
2. The server receives this “ping” and simply returns the same dummy data back to the client with a “pong” type of message
3. The client receives this “pong” and thus acknowledges that the connection is active

The total roundabout time taken to receive the response from the server is denoted to us as the “Ping”. Another word used to describe this process is “Latency” and the lesser the number, the better it results in performance.

Implementation in Flutter

Alright. So we have a pretty good idea of what a websocket is used for. Let’s move on to implementing a basic socket in Flutter.

1. Install the package

For implementation of websockets in our Flutter app, we’ll be using the package web_socket_channel.

2. Basic implementation

import 'package:web_socket_channel/io.dart';

class WebsocketService {
  static final WebsocketService _webSocketService =
      WebsocketService._internal();
  factory WebsocketService() {
    return _webSocketService;
  }
  WebsocketService._internal();

  IOWebSocketChannel? channel;
  // DUMMY URL; DO NOT TRY TO IMPLEMENT
  String websocketUrl = 'ws://test.example.com?token=eySjks7sadjklwaskfjtAw8sS';

  void init() {
    // INITIATE A CONNECTION THROUGH AN IOWebsocketChannel channel
    channel = IOWebSocketChannel.connect(websocketUrl);
    if (channel != null) {
      // IF CHANNEL IS INITIALIZED AND WEBSOCKET IS CONNECTED
      // LISTEN TO WEBSOCKET EVENTS
      channel!.stream.listen(_eventListener).onDone(_reconnect);
    }
  }

  void transmit(dynamic data) {
    // THIS METHOD CAN BE CALLED ANYWHERE THROUGHOUT THE APP
    // AND CAN BE USED TO SEND DATA FROM THE CLIENT TO THE SERVER
    // VIA THE WEBSOCKET
    if (channel != null) {
      channel!.sink.add(data);
    }
  }

  void _eventListener(dynamic event) {
    if (event == 'message') {
      // PERFORM OPERATIONS ON THE EVENT PAYLOAD
    }
  }

  void _reconnect() {
    // IF CONTROL HAS TRANSFERRED TO THIS FUNCTION, IT MEANS
    // THAT THE WEBSOCKET HAS DISCONNECTED.
    if (channel != null) {
      // CLOSE THE PREVIOUS WEBSOCKET CHANNEL AND ATTEMPT A RECONNECTION
      channel!.sink.close();
      init();
    }
  }
}

Let’s go through this code step-by-step.

static final WebsocketService _webSocketService = WebsocketService._internal();
factory WebsocketService() {
  return _webSocketService;
}
WebsocketService._internal();

IOWebSocketChannel? channel;
// DUMMY URL; DO NOT TRY TO IMPLEMENT
String websocketUrl = 'ws://test.example.com?token=eySjks7sadjklwaskfjtAw8sS';

First, we create a websocket service using the singleton pattern (i.e. only one instance of the service can be created throughout the app). Read more about Singletons here.

We’ll be using the IOWebsocketChannel class to initialize our websocket channel through which our data will be passed.

The websocketUrl stores the endpoint of our websocket, quite similar to the url endpoint we use in HTTP requests. For this example, I’ve used a dummy url.

TLDR: Don’t use the dummy url, it won’t work

void init() {
    // INITIATE A CONNECTION THROUGH AN IOWebsocketChannel channel
    channel = IOWebSocketChannel.connect(websocketUrl);
    if (channel != null) {
      // IF CHANNEL IS INITIALIZED AND WEBSOCKET IS CONNECTED
      // LISTEN TO WEBSOCKET EVENTS
      channel!.stream.listen(_eventListener).onDone(_reconnect);
    }
  }

Then, inside the init() method, we’ll initialize our websocket channel by passing our websocket url endpoint to the connect() method.

After the websocket is initialized, we can start listening to the events emitted inside the websocket. Since all events coming from the websocket server are emitted inside a stream, we’ll be using channel.stream.listen() method to listen to these events.

void _eventListener(dynamic event) {
  if (event == 'message') {
    // PERFORM OPERATIONS ON THE EVENT PAYLOAD
  }
}

We create a method _eventListener() and pass this to the channel.stream.listen() method. By doing so, all events can be caught inside the _eventListener(). These events are generally received in the form of JSON objects, so it’s quite easy to parse the data and perform operations on it like one would using HTTP GET requests.

void transmit(dynamic data) {
  // THIS METHOD CAN BE CALLED ANYWHERE THROUGHOUT THE APP
  // AND CAN BE USED TO SEND DATA FROM THE CLIENT TO THE SERVER
  // VIA THE WEBSOCKET
  if (channel != null) {
    channel!.sink.add(data);
  }
}

Cool, we’ll be able to receive data from the websocket, but what about sending data to the server via the websocket? For this, we created another method transmit(). Similar to how data is received via a stream, data can be sent via a sink, and so, adding data to the sink is all that this method does. This method is better kept public instead of private, since we might need to send data from anywhere inside the app.

void _reconnect() {
  // IF CONTROL HAS TRANSFERRED TO THIS FUNCTION, IT MEANS
  // THAT THE WEBSOCKET HAS DISCONNECTED.
  if (channel != null) {
    // CLOSE THE PREVIOUS WEBSOCKET CHANNEL AND ATTEMPT A RECONNECTION
    channel!.sink.close();
    init();
  }
}

Now, if the websocket disconnects suddenly due to some network problems, we attempt a reconnection by using the _reconnect() method. We close the previous connection using channel.sink.close() and call the init() method to re-initialize our websocket connection.

Lastly, we need to call the init() method somewhere for the service to be initialized in the first place. Generally speaking, most websockets require a kind of token or a key to be passed inside the url endpoint. In case of your app, you’ll just have to decide which is the best place to initialize your websocket. It has to be some point in the app where you have the token/key that’s required in the url. Once you’re there, just add this one line and you are good to go.

WebsocketService().init();

And, that’s it! This is pretty much all you need to get a websocket connection up and running inside your app.

Kudos! You now possess the knowledge of the websocket. Please comment below your suggestions/feedback and share this article if you found it useful. Claps are always appreciated 🥹

Until next time.

Adios.

When it comes to building apps using Flutter, creating responsive and beautiful User Interfaces is not all there is. Animations, data flow and state management are core parts that cannot be ignored.

In this article, we’ll take a look at the state management approach recommended by Flutter itself — Provider.

State management — What exactly is it?

Everything is a widget in Flutter. So what is a widget? It could be said that a widget is a component. It could be as simple as a Text widget that shows text, or it could be a button that triggers a function when tapped on it. Or it could be an entire screen that holds multiple children widgets under it.

For the sake of answering the question at hand, we’ll consider the last example. Let’s say we have a screen like this:

In the above image, the entire screen can be a parent widget that contains multiple child widgets like the Text widget to display the total balance, the Switch widget to toggle between Send and Receive modes, etc.

The “Total Balance” value might change in the Future, so if it does change its value, how will it reflect and update in the screen? The parent widget cannot magically know that the Text value has changed unless it is informed that such a change has happened. This is precisely where “State” comes in. If we can provide a state to this widget, it can then maintain the current value and track any changes made to it.

Flutter provides a way to do exactly this — using a Stateful Widget. When we use a Stateful Widget, all the variables we declare inside its “State” can be updated and reflected on the UI by calling the setState() method. When the setState() method is called, the widget is rebuilt with the values of the state variables.

Perfect! Sounds like a charm! So what’s the issue with this? Why do we need something like provider at all?

The thing is, when setState() is called, the entire widget and all the corresponding children widgets are rebuilt. Apart from the very fact that this is a heavy operation, it’s also unnecessary. If only the value of the Text widget has changed, it makes no sense to be rebuilding the entire Widget Tree again. It would instead be much better if there was a way to just update the state of the Text widget, no?

Well, one way to tackle this is to extract the Text widget into a separate widget all by itself and then set its independent state whenever we need to. But how do we do this? Even if we extract the Text widget out into a reusable Stateful widget, how do we manipulate its state from outside the widget itself? We would have to use an InheritedWidget implementation to lift the state outside the widget and make it accessible outside. Turns out, this implementation is actually quite tedious to implement.

Why Provider?

Enter, provider. The provider approach does exactly this. As per its official documentation, it is a wrapper around an InheritedWidget implementation. Using provider, we can modify the values of a widget without having to rebuild the entire Widget Tree.

Implementing the Provider approach:

Great! So now we know that the Provider approach can solve the issue at hand. Let’s get to know more about what goes in implementing the provider.

First off, we need to decide what exactly the provider is going to provide and to what widget(s). For simplicity, we’ll keep the value for the text widget in our provider, i.e. the value for total balance.

Now that we’ve decided what value is to be stored, we need to create a class that extends ChangeNotifier. This is absolutely essential for implementing provider since this ChangeNotifier will broadcast the values wherever we need them. Here’s what an implementation of the provider class will look like:

bank_screen_provider.dart

import 'package:flutter/material.dart';

class BankScreenProvider extends ChangeNotifier {
  String _balance = '';
  String get totalBalance => _balance;

  void setBalance(String balance) {
    _balance = balance;
    notifyListeners();
  }
}

In the above code, BankScreenProvider which extends the ChangeNotifier is our provider class which will act as a central repository for storing data and performing operations on it. The method setBalance() is used to assign value to the variable we’ve created to map the total balance.

You must have noticed that the function is not returning a value. How then, you might ask, will the value be read outside the class? For exactly that purpose, we’ve created the getter totalBalance. Using this getter, we can keep our actual variable (_balance) private and safe and still expose its value wherever needed. This is mostly done to prevent modification of these values from outside the class.

Finally, the last major thing to notice is that the function is calling the notifyListeners() method. Calling this method broadcasts a notification that the values inside the BankScreenProvider has changed.

Now, how do we consume this value from the BankScreenProvider? For that, we need to wrap the relevant widget(s) with a Consumer widget. The Consumer comes along with the provider package and it listens for notifications from the type of Provider we pass to it.

bank_screen.dart

Consumer<BankScreenProvider>(
  builder: (context, provider, child) {
    String balance = provider.totalBalance;
    return Text(balance);
  },
);

As can be seen in above code, we need to give our Consumer a type of our provider (BankScreenProvider in this case). If we do not do this, we won’t be able to access the data inside our provider. Then, the builder parameter of the Consumer widget requires three parameters:

context: An instance of BuildContext which is accessible in every build method

provider: An instance of the provider we’re using (BankScreenProvider in this case)

child: A widget instance that we don’t really need for our use case

Now that we have our Consumer in place, you might ask how do we update the widget inside it whenever we want to? Remember earlier in our provider, we called a function notifyListeners() whenever we make changes to our data? This is precisely what it’s for. Whenever notifyListeners() is called, it sends a notification to all Consumers listening to that provider, telling them to rebuild the widget(s) inside them.

The Final Step

Great! So now we got a Consumer to consume our provider values and a Provider class to supply these values. All that’s left is one last step — Setting the provider scope. Whenever we write a provider, we also need to tell flutter the scope of this provider for it to understand how far up the widget tree the states need to be lifted. This is a crucial step and if missed, will result in an Exception. Go to your main.dart file and wrap your root app widget with a ChangeNotifierProvider widget like this:

main.dart

import 'package:provider/provider.dart';

void main(){
  runApp(
    ChangeNotifierProvider(
      create: (context) => BankScreenProvider(),
      child: MyApp(),
    ),
  );
}

In the future, you might need to add multiple provider scopes for different screens. In that case, you’ll just need to convert this ChangeNotifierProvider widget to a MultiProvider widget and pass it a list of all providers you want to be scoped, like this:

import 'package:provider/provider.dart';

void main(){
  runApp(
    MultiProvider(
      providers: [
        ChangeNotifierProvider(
          create: (context) => BankScreenProvider(),
          child: MyApp(),
        ),
        ChangeNotifierProvider(
          create: (context) => HomeScreenProvider(),
          child: MyApp(),
        ),
      ],
      child: MyApp(),
    ),
  );
}

You might ask — “By placing the ChangeNotifierProvider on top of the root widget, aren’t we polluting the scope of the provider?” Yes we are. What we are doing right now will allow the entire app to access values from BankScreenProvider and listen to its events. But, it’s not necessary that the provider data will be required in every single screen. So it is usually better to wrap a widget (with ChangeNotifierProvider) two steps above the subject widget in the widget tree.

Alright, with that, you’ve officially learnt how to use the provider state management approach in Flutter! Adios till the next time! If you feel this article was helpful, please share it. Claps are always appreciated as well :)

Adios!

Credits (UI Screen Ref): https://dribbble.com/shots/21343217-Mobile-Banking-App

Microsoft is a huge name. If you’re reading this, you already know why. Getting Microsoft Certified is a huge thing and it shows that you are of an exploratory nature and venture into extra-curricular stuff. It might not necessarily guarantee a job, but it certainly shows you’re curious.

What is this Certification?

Microsoft provides certifications on a wide range of topics. Some of these topics are Python, Java, JavaScript and also Microsoft technologies like Azure, PowerApps, Dynamics 365, etc.

You can choose whichever topic/technology you feel appearing for and prepare for it accordingly. When you’re ready, you give the exam for that specific topic and if you pass, voila; you get the certificate.

How do I get this free offer!?

Every year, Microsoft conducts two major events — Microsoft Build and Microsoft Ignite. Microsoft Ignite is currently active (as of 23rd September 2020). You can participate in the Cloud Skills Challenge here and complete the challenge before October 7th 2020. If you do, you get a free Microsoft certification voucher.

Important: You get the voucher through which you can appear for an exam. You don’t get the certificate directly.

What do I have to do?

You just have to complete all Microsoft Learn modules listed under the challenge before the deadline. That’s it. A really cool reward for learning right!? Win — Win!

Stepwise Guide:

1. Head over to myignite.microsoft.com and in the top navigation, click on Connection Zone and choose Learning Zone.

You should be able to see the Cloud Skills Challenge card over there. Hit Sign Up.

This will redirect you to the Ignite Cloud Skills Challenge Page. Scroll down to see available challenges and select whichever challenge you feel most interested about (or challenged about ;P) and click on Go to Challenge.

You’ll see a countdown timer now. Click on Join the challenge to start learning. Just make sure to complete the modules before the countdown ends and hopefully you should receive your voucher!

Thanks for reading this article! Give a clap if it helped you!

If that confused you, don’t worry. Just hang on till we get to the interesting stuff.

Note:- I am going to use the terms “Golang” and “Go” alternatively further down this article. They both essentially mean the same.

What is Golang

Golang is a programming language that is (like most languages) statically typed and compiled language. What does this mean? This means that unlike interpreted languages like Python (which uses line by line execution via the interpreter), Golang programs are written and compiled as a whole to be able to run them.

If you have prior experience with programming in Python or Java, you’ll know that both Python and Java are not compiled and executed as whole. Java generates a byte-code and in order to run this bytecode, you need something called as the Java Virtual Machine (included in the Java Development Kit). On the other hand, Python isn’t compiled in the classical sense, it is interpreted (by the Python interpreter). This means that Python code is executed line by line, and even though this proves to be fast most of the times, compiled code is faster, because it is basically binary (which is the easiest for computers to understand).

Why Golang

For one, it is easy to learn as compared to Java. Jetbrains conducted a survey among 7000 developers recently which led to the following result:

As you can see above, Go has been called “The most promising programming language”. This is because it has a small set of features which can be used in a lot of ways.

If this doesn’t make sense to you, let’s consider a realistic analogy — The USB. The USB is an interface that is extremely simple, yet its applications are limitless. It is literally EVERYWHERE!

There is also a lot of talk being going on about how Go will be the “future language for the Web”. The statistics project the same.

Golang Installation

Alright. Enough chit-chat, now let’s get to work.

Installing Golang to your machine is relatively easy, but it depends on the Operating System you’re using. Don’t worry if you’re a beginner. This is a step-by-step installation guide, so I’ll be covering all aspects of the installation (including install verification).

Regardless of the OS you are using, you’ll need to go the official Golang download page to download your OS compatible Golang package.

Download Here

You’ll face a screen like this:

Under the section “Featured Downloads”, select the package compatible to your Operating System.

For Windows

Step 1: Run the downloaded package.

Step 2: Keep clicking Next till you see a screen specifying the “Destination Folder”.

Here, you can choose the directory/folder in your computer where you want Go to be installed.

Step 3: Once this is done, click Next till the installation starts. After Go has been installed, click on the Finish button.

To check if Go has been installed successfully, just pull up your command line or cmd and type in the command go version

For Linux

I do not own a Linux machine myself, so I will link some good installation guides (ones with screenshots/commands attached) so you don’t have to stress on the OS availability.

Golang Official Documentation

Techmint

For MacOS

Again, I do not own a MacOS/Apple machine myself, so I will link some good installation guides.

Golang Official Documentation

Medium

Baby Steps

That’s it! Go is now successfully installed on your computer! Here are some resources to learn Go:

Traversy Media

Telusko

You can refer any other tutorial you feel comfortable with, but I posted these two because I personally found them comfortable for beginners.

To get started on with Go, open any text/code editor you feel comfortable with, I recommend Sublime Text if you’re a beginner.

Open Sublime Text and type the code as shown in the image:

Note: “fmt” stands for “format”

Save the file on your Desktop with the filename helloWorld.go or any other filename you like. Just make sure to save it with the extension “.go”.

Open your command line or cmd and navigate to your Desktop

Enter the command: go run helloWorld.go

The output should appear on your screen as shown in the image below.

Do not panic if it takes a while for the output to be displayed. It’s completely normal.

Hooray! You’ve written your first few lines of Golang code! Take up the tutorials mentioned above to advance through the basics of Golang.

Hope this article helped somewhat informing you about the revolutionary Golang! Happy Coding!