DEV Community: Jay Tillu

What is AWS Identity and Access Management (IAM)?

Jay Tillu — Thu, 30 May 2024 12:31:23 +0000

The vast potential of the cloud comes with a crucial responsibility: security. AWS IAM provides a centralized platform for managing user identities and controlling their access to AWS services and resources. It provides a way to create and manage users, groups, roles, and policies that determine who can do what, where, and when in your AWS account.

Imagine your AWS account as a digital fortress. IAM acts as the gatekeeper, meticulously determining who (users, applications, services) can access what resources (S3 buckets, EC2 instances, etc.), when (temporary or long-term access), and under what conditions (specific actions allowed by permissions).

Key Components of AWS IAM

IAM Users: IAM allows you to create individual users with unique credentials, enabling them to access AWS resources securely. Each user can have specific permissions assigned to them based on their role within the organization.
IAM Groups: Groups in IAM simplify permission management by allowing you to organize users with similar access requirements. Instead of assigning permissions to individual users, you can assign them to groups, streamlining the process of access management.
IAM Roles: IAM roles are entities with permissions that can be assumed by users, applications, or services within your AWS environment. Roles provide temporary access to resources and are commonly used for cross-account access, federated access, and granting permissions to AWS services.
IAM Policies: IAM policies define the permissions that are granted or denied to users, groups, or roles. Policies are JSON documents that specify the actions users can perform and the resources they can access. By adhering to the principle of least privilege, you can ensure that users have only the permissions necessary to perform their tasks.

Benefits of AWS IAM

Granular Access Control: IAM enables you to define fine-grained permissions, allowing you to grant only the necessary level of access to resources.
Security: By following the principle of least privilege, IAM helps reduce the risk of unauthorized access and data breaches.
Flexibility: IAM supports a wide range of use cases, from managing users and groups to granting temporary access through roles.
Compliance: IAM features such as access logging and identity federation help organizations maintain compliance with regulatory requirements.

1. AWS Root User Account

The AWS Root User Account is the initial account created when you sign up for AWS services. It has complete access to all AWS services and resources within the account. The root user has full administrative privileges, including the ability to manage billing, change account settings, and create or delete IAM users and roles. However, it's important to note that using the root user account for everyday tasks is not recommended due to security and management reasons.

Best Practices for AWS Root Account

Secure credentials with strong passwords and Multi-Factor Authentication (MFA).
Limit its use to essential administrative tasks only.
Enable MFA for added security.
Create IAM users with the least privileges for routine tasks.
Use IAM roles for elevated access when necessary.
Monitor root user activity with AWS CloudTrail.
Consider using AWS Organizations for managing multiple accounts centrally.

2. AWS IAM Users

An IAM user is an identity that you create in AWS. It represents the person or application that interacts with AWS services and resources. It consists of a name and credentials. Unlike the root user with full access, IAM user accounts provide a secure way to grant granular permissions based on specific needs.

By default, when you create a new IAM user in AWS, it has no permissions associated with it. To allow the IAM user to perform specific actions in AWS, such as launching an Amazon EC2 instance or creating an Amazon S3 bucket, you must grant the IAM user the necessary permissions.

Best Practices for AWS IAM Users

Individual Accounts: AWS recommend that you create individual IAM users for each person who needs to access AWS. Even if you have multiple employees who require the same level of access, you should create individual IAM users for each of them. This provides additional security by allowing each IAM user to have a unique set of security credentials.
Implement Least Privilege: Assign permissions based on least privilege to limit access to only what's necessary.
Monitor User Activity: Enable CloudTrail logging for IAM events to monitor user actions and detect anomalies.
Enforce Password Policies: Implement strong password policies like minimum length, complexity requirements, and regular rotation.
Disable or Delete Unused Accounts: Regularly review your IAM users and deactivate or delete any unused accounts to minimize the attack surface.
Enable Multi-Factor Authentication (MFA): Enhance security by requiring MFA for IAM user accounts.
Utilize IAM Groups (Optional): For IAM Users with similar permission requirements, create IAM groups and assign user accounts to those groups. This simplifies permission management.

3. AWS IAM Policy

AWS IAM Policy is a JSON document that defines permissions and access controls for AWS Identity and Access Management (IAM) users, groups, or roles. These policies specify what actions are allowed or denied on which AWS resources.

Best Practices for AWS IAM Policies

Use Least Privilege: Grant only necessary permissions.
Leverage Managed Policies: Utilize AWS-managed policies whenever possible, as they are maintained by AWS and automatically updated to reflect best practices and new features. Managed policies help ensure consistency and compliance with security standards.
Avoid Wildcards (*): Refrain from using wildcard (*) actions in IAM policies whenever possible, as they grant overly broad permissions and increase the risk of unauthorized access. Instead, specify only the actions required for the specific task.
Enable Versioning and Logging: Maintain policy history and monitor changes.
Test with IAM Policy Simulator: Before deploying IAM policies in a production environment, use the IAM Policy Simulator to test and validate their effectiveness. The simulator helps identify potential issues and ensure policies behave as intended before implementation.
Utilize Policy Variables: Create dynamic policies for flexible access control.
Regularly Audit Policies: Remove unnecessary permissions and outdated policies.
Enable Access Analyzer: Continuously monitor for unintended access and policy issues.

4. AWS IAM Groups

AWS IAM Groups are a way to organize IAM users and manage their permissions collectively. Instead of attaching permissions directly to individual users, you can assign permissions to groups, making it easier to manage access control in a scalable and efficient manner.

Best Practices for AWS IAM Groups

Organize Users by Access Needs: Group users with similar permissions together.
Apply Least Privilege: Grant only necessary permissions to groups.
Use Managed Policies: Utilize AWS-managed policies for consistent permissions.
Avoid Overlapping Permissions: Ensure users are only in groups that align with their roles.
Regularly Review Group Membership: Periodically review and update group memberships.
Combine with IAM Policies: Use IAM policies for fine-grained access control.
Establish Naming Conventions: Use consistent naming for easy identification and management.
Document Policies and Membership: Document permissions and group memberships for auditing.
Consider Cross-Account Access: Centralize permissions management for multiple accounts.

5. AWS IAM Roles

AWS IAM Roles are entities in AWS Identity and Access Management (IAM) that define a set of permissions and policies. Unlike users or groups, roles are not associated with specific individuals or resources. Instead, they are intended to be assumed by IAM users, AWS services, or external entities, allowing them to temporarily inherit the permissions associated with the role.

Best Practices for AWS IAM Roles

Grant access temporarily: IAM roles are ideal for situations in which access to services or resources needs to be granted temporarily, instead of long-term.
Cross-Account Access: Use roles to grant access between AWS accounts.
Avoid Long-Term Credentials: Utilize roles instead of long-term access keys. Roles provide temporary credentials that automatically rotate, reducing the risk of credential compromise.
IAM Roles for AWS Services: Assign roles to AWS services for dynamic permissions.
Role-Based Access Control (RBAC): Follow the least privilege principles when defining role permissions.
IAM Role Tags: Use tags for efficient role management. Tags can be used for cost allocation, access control, and resource management purposes, providing additional context and organization.
IAM Permission Boundaries: Use IAM permission boundaries to limit the maximum permissions that can be granted by an IAM role. Permission boundaries help enforce security policies and prevent users from escalating privileges beyond their intended scope.
Regular Credential Rotation: Rotate credentials associated with IAM roles, such as temporary security tokens or session tokens, regularly to mitigate the risk of unauthorized access due to compromised credentials.
Enable CloudTrail Logging: Enable AWS CloudTrail logging for IAM role activity to monitor and audit role assumptions and actions performed by users or services. CloudTrail provides detailed logs of API calls made by IAM roles, aiding in security analysis and compliance efforts.

Conclusion

AWS IAM is a critical component of AWS security, providing a robust framework for managing access to resources in the cloud. By following best practices and leveraging the features of IAM, organizations can enhance security, enforce compliance, and maintain control over their AWS environment. Whether you're a small startup or a large enterprise, understanding and effectively implementing AWS IAM is essential for securing your cloud infrastructure.

Follow me for more such content

What is AWS Organization?

Jay Tillu — Thu, 30 May 2024 12:19:35 +0000

In today's digital landscape, where organizations are increasingly relying on cloud infrastructure to power their operations, managing multiple AWS accounts efficiently and securely has become a priority. AWS Organizations is a powerful service designed to streamline the management of multiple AWS accounts within an organization. In this blog, we'll delve into the features, benefits, and best practices of AWS Organizations, exploring how it empowers businesses to achieve greater efficiency and control in their cloud operations.

Why do you need AWS Organizations?

As your organization dives deeper into the cloud with AWS, the number of accounts you manage can quickly multiply. Development teams spin up accounts for projects, different departments require isolated environments, and mergers or acquisitions bring new accounts into the fold. This sprawl can lead to chaos:

Security nightmares: Inconsistent configurations and forgotten accounts create vulnerabilities.
Billing confusion: Sorting through individual account bills becomes a time-consuming headache.
Resource mismanagement: Underutilized accounts waste resources while others struggle with capacity.

Organizational Units

AWS Organizations helps you to consolidate and manage multiple AWS accounts within a central location. When you create an organization, AWS Organizations automatically creates a root, which is the parent container for all the accounts in your organization

In AWS Organizations, you can group accounts into organizational units (OUs) to make it easier to manage accounts with similar business or security requirements. When you apply a policy to an OU, all the accounts in the OU automatically inherit the permissions specified in the policy.

By organizing separate accounts into OUs, you can more easily isolate workloads or applications that have specific security requirements. For instance, if your company has accounts that can access only the AWS services that meet certain regulatory requirements, you can put these accounts into one OU. Then, you can attach a policy to the OU that blocks access to all other AWS services that do not meet the regulatory requirements.

How OUs help you manage your AWS accounts

Grouping by Function: Instead of mirroring your company's structure, OUs allow you to group accounts based on what they do. For instance, you can have separate OUs for Security, Development, Production, or specific applications.
Centralized Policy Application: Once accounts are grouped by function in OUs, you can implement Service Control Policies (SCPs) at the OU level. These SCPs define what services and actions users can perform within the accounts belonging to that OU. This simplifies policy management and ensures consistency across related accounts.
Resource Sharing: OUs enable you to share resources like Amazon S3 buckets or Amazon RDS instances across accounts within the same OU. This fosters collaboration within teams working on the same projects or functionalities.

Planning Your OU Structure

There's no one-size-fits-all approach to structuring your OUs. However, some best practices can guide your planning:

Start with Foundational OUs: Create initial OUs for Security and Infrastructure to centralize controls for these critical areas.
Workloads OU: Establish a separate OU for application workloads, with potential sub-OUs for different applications or environments.
Focus on Function over Hierarchy: Prioritize grouping accounts based on what they do rather than mimicking your company's reporting structure.

By following these practices, you can leverage OUs within AWS Organizations to create a well-organized and manageable multi-account cloud environment.

Benefits of AWS Organizations

AWS Organizations offers a centralized solution to manage your growing herd of AWS accounts.

1. Simplify Account Management

Effortless Onboarding: Invite new accounts or create them within your organization with a few clicks.
Centralized Governance: Define naming conventions and enforce IAM best practices across all accounts.
Consolidated Billing: Pay for your entire organization's cloud usage with a single bill.

2. Enhance Security and Compliance

Standardized Security Policies: Implement organization-wide policies to restrict actions, enforce encryption, and ensure service usage adheres to compliance standards.
Centralized Logging: Gain a bird's-eye view of activity across all accounts with services like AWS CloudTrail Lake for simplified auditing and security investigations.

3. Optimize Resource Allocation

Organizational Units (OUs): Group accounts based on function or project for targeted policy application and easier resource management.
Resource Sharing: Share services like Amazon S3 buckets or Amazon RDS instances across accounts within an OU for efficient collaboration.

4. Maintain Cost Control

Cost Allocation Tags: Track costs associated with specific departments, projects, or applications using tags for better budgeting and resource allocation decisions.
Consolidated Billing Reports: Analyze spending patterns across your organization and identify cost-saving opportunities.

Best Practices for AWS Organizations

Account Structure

Group by Function, Not Hierarchy: Organize accounts based on what they do (security, infrastructure, workloads) instead of mirroring your company's reporting structure. This allows for more flexibility and future changes.
Start with Foundational OUs: Create initial Organizational Units (OUs) for Security and Infrastructure to centralize controls for these critical areas.
Workloads OU: Establish a separate OU for application workloads (production, development, testing). Further, subdivide this OU for different applications or environments as needed.

Standardization and Governance

Use the Management Account Wisely: Reserve the management account solely for organization-wide tasks and don't store resources there.
Standardize Naming Conventions: Implement consistent naming rules for accounts, OUs, and resources for better organization and identification.
Enforce Security Policies: Utilize Service Control Policies (SCPs) to enforce security best practices and compliance standards across all accounts.

Cost Management and Optimization

Consolidated Billing: Leverage consolidated billing to simplify expense management and identify cost trends across your organization.
Cost Allocation Tags: Implement cost allocation tags to categorize resources and track spending by department, project, or application.
Rightsize Accounts: Regularly review account usage and adjust account types (free tier, paid) to optimize costs.

What is the AWS Service Control Policy?

A Service Control Policy (SCP) is a feature provided by AWS Organizations that allows organizations to establish and enforce central policies across multiple AWS accounts within their organization. SCPs help administrators control which AWS services and features are available to users and resources within each account, regardless of the individual account's IAM (Identity and Access Management) policies.

Here are key aspects of Service Control Policies:

Scope: SCPs apply at the organizational level and affect all member accounts within the AWS Organization. They provide a centralized mechanism for administrators to enforce security, compliance, and governance policies across multiple AWS accounts.
Restrictive Access Controls: SCPs operate by specifying the permissions that are allowed or denied for each AWS service or feature. Administrators can use SCPs to restrict access to certain AWS services, APIs, actions, or resources, helping to enforce security and compliance requirements.
Hierarchy: SCPs can be applied hierarchically within the organizational structure defined by AWS Organizations. This means that SCPs applied at a higher level in the hierarchy affect all accounts below it, unless overridden by more permissive policies applied at lower levels.
Precedence: SCPs have precedence over IAM policies. Even if an IAM policy grants permissions to a user or role within an AWS account, those permissions can be further restricted or denied by the SCP applied to the account or organizational unit.
Enforcement: SCPs are enforced by the AWS Organizations service, which evaluates and enforces the policies across all member accounts. This ensures consistent policy enforcement and helps maintain a secure and compliant environment.
Use Cases: SCPs can be used for various purposes, including enforcing regulatory compliance, preventing unauthorized access to sensitive resources, limiting access to specific AWS services based on business requirements, and maintaining security best practices across the organization.

Overall, Service Control Policies provide administrators with a powerful tool for centrally managing and enforcing access controls across multiple AWS accounts within an organization. By leveraging SCPs, organizations can enhance security, enforce compliance, and maintain governance standards across their AWS environment.

Conclusion

AWS Organizations stands as a cornerstone for organizations seeking to streamline the management of their cloud infrastructure. By leveraging its powerful features, such as OUs, SCPs, and consolidated billing, organizations can achieve greater efficiency, control, and security in their cloud operations. As businesses continue to embrace cloud technologies, AWS Organizations remains an indispensable tool for orchestrating multi-account environments and unlocking the full potential of the AWS cloud.

Follow me for more such content

What is AWS Artifact?

Jay Tillu — Wed, 29 May 2024 17:01:49 +0000

AWS Artifacts is a centralized platform offered by Amazon Web Services that provides customers with on-demand access to many compliance reports and agreements. Whether you're a startup or an enterprise, AWS Artifacts serves as your one-stop shop for all things related to security, compliance, and legal documentation within the AWS ecosystem.

There are two main components to AWS Artifact:

AWS Artifact Reports
AWS Artifact Agreements

1. AWS Artifact Reports

The following are some of the compliance reports and regulations that you can find within AWS Artifact. Each report includes a description of its contents and the reporting period for which the document is valid.
Function: Provide pre-generated reports that demonstrate AWS's compliance with various security and industry standards.
AWS Artifact Reports provide compliance reports from third-party auditors. These auditors have tested and verified that AWS is compliant with a variety of global, regional, and industry-specific security standards and regulations.
AWS Artifact Reports remains up to date with the latest reports released. You can provide the AWS audit artifacts to your auditors or regulators as evidence of AWS security controls.
Content: Focuses on AWS's internal security posture, controls, and procedures. Examples include SOC reports (security), ISO certifications (various areas like quality management), and PCI reports (payment card industry data security).
Use Case: Helpful for organizations using AWS to understand the overall security posture of the underlying cloud infrastructure.

2. AWS Artifact Agreements

Function: Manage agreements between your organization and AWS.
In AWS Artifact Agreements, you can review, accept, and manage agreements for an individual account and for all your accounts in AWS Organizations.
Content: Focuses on defining the legal rights and responsibilities of both parties when handling sensitive data. Common agreements include Business Associate Agreements (BAA) for healthcare data (HIPAA compliance) and Data Processing Agreements (DPA) for general data privacy regulations (like GDPR).
Use Case: Essential for managing your organization's compliance obligations when storing or processing sensitive data in AWS. These agreements outline how both AWS and your organization will handle data security, privacy, and breaches.

In simpler terms:

Reports: Show how secure AWS is (think of it as a brochure for AWS's security practices).
Agreements: Define how you and AWS will handle your data security together (like a contract outlining responsibilities).

Benefits of AWS Artifact

Saves Time: Provides on-demand access to security and compliance reports in a self-service portal. This eliminates the need to contact AWS support or search for reports manually.
Improved Manageability: Allows you to manage agreements with AWS at scale. You can accept, terminate, and download agreements electronically, streamlining the process.
Increased Confidence: By providing easy access to compliance reports, AWS Artifact helps you understand the security posture of the AWS cloud infrastructure you're using. This can give you greater confidence when deploying your workloads on AWS.
Simplified Compliance: AWS Artifact Agreements can help simplify compliance with regulations that require specific data handling procedures. For example, Business Associate Agreements (BAA) are essential for healthcare organizations that store protected health information (PHI) in AWS.
Transparency: Having easy access to both AWS's security reports and your agreements with AWS fosters a more transparent relationship between you and the cloud provider.

Conclusion

In today's data-driven world, security and compliance are paramount. AWS Artifact offers a valuable tool for organizations using AWS by simplifying access to security reports and managing data handling agreements. By using AWS Artifact, you can save time, streamline compliance efforts, and gain peace of mind knowing your data is secure within the AWS cloud infrastructure.

Follow me for more such content

How AWS Shield Protects You From DDoS?

Jay Tillu — Tue, 28 May 2024 09:33:05 +0000

The threat of cyber attacks is large in today's interconnected digital world, where businesses and individuals rely heavily on online services. One such threat that has gained fame in recent years is the Distributed Denial of Service (DDoS) attack. In this blog post, we'll delve into what DDoS attacks are, how they work, their impact, and measures to mitigate them.

Understanding DDoS Attacks

At its core, a DDoS attack aims to disrupt the normal operation of a targeted server, service, or network by flooding it with an overwhelming volume of traffic. The "distributed" aspect refers to the utilization of multiple compromised devices, forming a botnet, to generate this traffic. These devices can range from computers and smartphones to Internet of Things (IoT) devices, all under the control of the attacker.

How DDoS Attacks Work

DDoS attacks typically unfold in several stages:

Botnet Formation: Attackers infect numerous devices with malware, gaining control over them and forming a botnet.
Command and Control: The attacker issues commands to the botnet, instructing it to send a flood of requests to the target server or network.
Traffic Flood: The botnet obediently follows these instructions, inundating the target with a deluge of traffic, thereby overwhelming its resources.

DDoS attacks are particularly troublesome because they're difficult to stop. Unlike a lone attacker, a botnet spreads the attack across numerous devices, making it hard to identify and block the source.

Impact of DDoS Attacks

The consequences of a successful DDoS attack can be severe:

Service Disruption: The targeted service becomes inaccessible to legitimate users, resulting in downtime and loss of productivity.
Financial Losses: Businesses may suffer financial losses due to interrupted operations, decreased customer trust, and potential regulatory penalties.
Reputation Damage: Organizations targeted by DDoS attacks often experience reputational damage, eroding customer confidence and brand loyalty.

Common Reasons behind DDoS Attack

But why do attackers unleash such chaos? Here are some common reasons:

Extortion Money: Sometimes, attackers use DDoS attacks for financial gain. They threaten to take down a website unless the victim pays a ransom.
Disrupting the System: Hacktivists might use DDoS attacks to disrupt the operations of a company or organization they disagree with.
Taking Down the Competition: Malicious businesses might use DDoS attacks to sabotage their competitor's online presence.

Thankfully, there are ways to defend against DDoS attacks. Security measures like DDoS mitigation services can help filter out suspicious traffic and keep websites and online services up and running.

How AWS Shield Protects You From DDoS

AWS Shield Standard automatically protects all AWS customers at no cost. It protects your AWS resources from the most common, frequently occurring types of DDoS attack. AWS Shield is a crucial component of Amazon Web Services (AWS) defence strategy against Distributed Denial of Service (DDoS) attacks. Here's how AWS Shield protects its customers. AWS Shield offers two tiers of protection: Standard and Advanced.

1. AWS Shield Standard

Automatic Protection: AWS Shield Standard is automatically enabled for all AWS customers at no additional cost. It provides protection against the most common and frequently occurring DDoS attacks.
Always-On Monitoring: AWS Shield Standard continuously monitors AWS global network traffic, looking for signs of malicious activity or DDoS attacks targeting customer resources.
Inline Mitigations: When AWS Shield detects a DDoS attack, it automatically deploys inline mitigations to filter out malicious traffic and allow legitimate traffic to reach customer resources.

2. AWS Shield Advanced

Enhanced Protection: AWS Shield Advanced is a premium offering that provides additional DDoS protection beyond what is offered in AWS Shield Standard.
Customization: With AWS Shield Advanced, customers gain access to enhanced detection and mitigation capabilities, as well as more granular controls and customization options to tailor protection to their specific needs.
24/7 DDoS Response Team (DRT): AWS Shield Advanced subscribers have access to a dedicated DDoS Response Team (DRT) that provides assistance and guidance during DDoS attacks, helping customers mitigate the impact and recover from attacks more effectively.
Automatic WAF Rule Creation: Shield Advanced can automatically create rules within AWS WAF (Web Application Firewall) to block malicious traffic targeting your applications. This eliminates the need for manual intervention during an attack.
DDoS-Cost Protection: Shield Advanced safeguards you from unexpected charges arising from a DDoS attack that inflates your AWS resource usage.

Constant Vigilance: Both Shield Standard and Advanced leverage AWS's massive global infrastructure. This allows them to identify and filter out malicious traffic before it reaches your resources. AWS constantly monitors for new attack patterns and updates its defences accordingly.

Human Expertise (Shield Advanced): With Shield Advanced, you gain access to the AWS Shield Response Team (SRT) – a team of security specialists available 24/7. During a complex DDoS attack, the SRT can assist with advanced mitigation strategies and help ensure your application's continued operation.

Benefits of Using AWS Shield

Peace of Mind: AWS Shield's proactive approach allows you to focus on your core business functions without worrying about DDoS attacks.
Enhanced Security: The multi-layered protection offered by Shield safeguards your applications from various DDoS attack vectors.
Cost Control: Shield Standard's free tier provides a valuable first line of defence, while Shield Advanced's DDoS-cost protection helps manage unexpected expenses.

Conclusion

In summary, AWS Shield provides comprehensive protection against DDoS attacks by offering automatic detection, inline mitigation, customization options, access to a dedicated response team, seamless integration with AWS services, and continuous improvements to stay ahead of evolving threats. By leveraging AWS Shield, customers can ensure the availability, reliability, and security of their applications and services hosted on the AWS cloud platform.

Follow me for more such content

Build Modes in Flutter

Jay Tillu — Sat, 05 Oct 2019 03:54:48 +0000

To master a framework, we need to understand its internal working methods. We have to get the answer of How Things Happening and Why That Happening. Just like a beautiful relationship, The more you know each other, the more you will understand each other. So let’s try to know some inner details about flutter and its build modes.

In this article, we will cover

What are the build modes?
How many build modes are there in the flutter?
Why we use them?

What is Build Modes?

Based on different development phase, framework compiles your code in a different manner or we can say that in different mode, that mode is called Build Mode…

As we all know that after a certain point of time it’s really hard and time-consuming to maintain the code and make changes. If you ask any Mobile App Developer about App compiling time, then they will tell you the pain. If you have a gigantic app like Facebook, Instagram, Uber or WhatsApp, then the time is far bigger, even the smallest color correction takes hours to reflect. And if you are on Android then the situation is far worse.

But here flutter comes into play to get it down. Let me clear up how?

Flutter team redesigns the entire development process, keeping in mind lightning fast compilation speed. When you hit the compile button, while other frameworks recompile your whole code, even if you have the smallest change, which takes a lot of time. But Flutter doesn’t do that.

Instead of compiling the whole code again and again. Flutter team divides the compilation phase into three modes. First mode when you are developing the app, second mode when you are testing the performance of the app and third and the last mode is when you release the app. By dividing the whole compilation process in different modes, flutter ables to reflects lightning-fast changes. Let’s take a look at all of them.

How many build modes are there and when to use which one?

Basically flutter have three build modes:

Debug Mode
Profile Mode
Release Mode

Debug Mode

Debug mode is designed to deliver you fast changes, but the app size is big and performance is minimal. So both app size and performance should not judge.

In the app development, the first phase is your development phase. In this phase, developers make a lot of changes, fixes some bugs and changing some here and there things. So in this phase developers needs to see their changes as soon as possible.
So in debug mode, flutter optimizes the app to reflect changes faster.
Here dart language comes into play to help flutter to reflect changes faster. Dart code can run via multiple methods. In debug mode, flutter runs your code in a virtual machine. And when you change anything and push hot reload, flutter just injects your changes to the app, without recompiling it.
Just like in web-development when you change anything you just hit refresh and your browser reflects that change instantly, the same concept goes here. Your app is running and as you change anything flutter will push that change into your app.
As flutter is not recompiling whole code, it just injects the changes, you see your changes instantly. Which helps in faster development and increases your productivity as well.
But as your app runs in a virtual machine, the performance is minimal. So when your app is in debug mode you should feel like its slow. But as it's optimized for faster changes reflection, you should not judge the performance of your app in debug mode.
Also while in debug mode the size of the app can seem pretty big. But don’t judge it as well. As its in debug mode…

Also, when you are in debug mode consider some important things.

Assertions are enabled.
Service extensions are enabled.
Debugging is enabled. (Here you can use DevTools).
You can debug your app on a physical device, Emulator or Simulator.

Profile Mode

Profile Mode is designed to analyze the performance of your app while testing.

While compiling your app in Profile Mode, flutter assumes that you want to examine your app’s performance. So its completely optimizes it to provide performance as fast as it can.
Here your app is ready and you can analyze the real performance of your app.

Also, when you are in Profile mode consider some important things.

In profile mode, you cannot run your app on Emulator or Simulator. As they are not optimized to do that. So profile mode is disabled for Emulator and Simulator.
Tracing is enabled.
Some service extensions to analyze performance are enabled.
Tooling support for DevTools is also enabled.

Flutter recommends using DevTools to analyze your app’s performance.

Release Mode

Released Mode designed to get your app ready for the Play Store and App Store. It designed to provide faster startups, fast execution, and minimal in size.

Now as development and testing are done. It’s time to compile your app for release mode. Here flutter compiles your code to native machine code, via the AOT compilation process, so now your app will pretty fast. for more information on the compilation process click here.
While compiling the app in release mode flutter assumes that your app is ready for release so optimization is maximum.
In release mode, the compilation is optimized for fast startups, fast execution, and minimum app size.

Also, when you are in Released mode consider some important things.

Assertions are disabled.
Debugging information is stripped out.
Debugging is disabled.
Service extensions are also disabled.
Release mode builds don’t support Emulator and Simulator.

So that’s it for build modes guys. I hope it helped you. Feel free to let me know If I miss something. Till then Keep Loving, Keep Coding.

Follow me for more such content

Inheritance in Dart

Jay Tillu — Mon, 16 Sep 2019 05:38:56 +0000

The capability of a class to derive properties and characteristics from another class is called Inheritance. It is ability of a program to create new class from an existing class.

Parent Class - The class whose properties are inherited by child class is called Parent Class. Parent class is also known as base class or super class.
Child Class - The class that inherits properties from another class is called child class. Child class is also known as derived class or base class.
Consider a group of vehicles. You need to create classes for Bus, Car and Truck. The methods fuelAmount(), capacity(), applyBrakes() will be same for all of the three classes. If we create these classes avoiding inheritance then we have to write all of these functions in each of the three classes as shown in below figure:

You can clearly see that above process results in duplication of same code 3 times. This increases the chances of error and data redundancy. To avoid this type of situation, inheritance is used.
If we create a class Vehicle and write these three functions in it and inherit the rest of the classes from the vehicle class, then we can simply avoid the duplication of data and increase re-usability. Look at the below diagram in which the three classes are inherited from vehicle class:

Using inheritance, we have to write the functions only one time instead of three times as we have inherited rest of the three classes from base class(Vehicle).

Syntax

class child_class extends parent_class {
  //body of child class
}

Child class inherits all the properties and methods except constructor from parent class.

Types of Inheritance

Mainly there are three types of inheritance:

Single
Multiple - Dart doesn’t support Multiple Inheritance.
Multi-level

Single Level Inheritance

In single inheritance, a class is allowed to inherit from only one class. i.e. one sub class is inherited by one base class only.

class Person{
  void showName(String name){
    print(name);
  }

  void showAge(int age){
    print(age);
  }
}

class Jay extends Person {}

main(){
  var jay = new Jay();

  jay.showName("JD");
  jay.showAge(20);
}

Output
JD
20

Here also remember that child class can have its own unique properties and methods too.

Multi-Level Inheritance

In this type of inheritance, a derived class is created from another derived class.

class Person {
  void showName(String name) {
    print(name);
  }

  void showAge(int age) {
    print(age);
  }
}

class Jay extends Person {
  void showProfession(String profession) {
    print(profession);
  }

  void showNationality(String nationality) {
    print(nationality);
  }
}
//Derived class created from another derived class.
class Sanket extends Jay {} 

main() {
  var sanket = new Sanket();

  sanket.showName("Sanket");
  sanket.showAge(20);
  sanket.showNationality("Indian");
  sanket.showProfession("Engineer");
}

Output

Sanket
20
Indian
Engineer

Guys credit for this article goes to Harsh Agrawal from geeksforgeeks.com. He wrote an amazing article on Inheritance in C++. Here I just try to explain same thing in dart way. 😉

That’s it for Inheritance guys. It’s one of the most important concept of Object Oriented Programming. Please Practice it, and have clear understanding on it. Also Feel free to let me know if I misses something, I’ll love to learn it from you. Till then Keep Loving, Keep Coding. And I’ll surely catch you up in next article.

Remember no teacher, no book, no video tutorial, or no blog can teach you everything. As one said Learning is Journey and Journey never ends. Just collect some data from here and there, read it, learn it, practice it, and try to apply it. Don’t feel hesitate that you can’t do that or you don’t know this concept or that concept. Remember every programmer was passed from the path on which you are walking right now. Remember Every Master was Once a Beginner. Work hard and Give your best.

Follow me for more such content

Interface in Dart

Jay Tillu — Mon, 16 Sep 2019 05:20:58 +0000

The interface defines the syntax that any class must follow. Interface mostly used to apply compulsion on class.
When any class implements an Interface then it must override every method and instance variable of an interface.
However, Dart does not have a syntax for declaring interfaces. The class declaration is themselves interface in a dart.
Any class can be act as an interface. Classes can use implements keyword to use any class as an interface.
Once any class is used as interface then it is mandatory to override each and every method and instance variable of that class. In simple words, a class must redefine every method and instance variable of the interface.

Syntax of declaring Interface

class class_name implements interface_name

Sample Code

class Person {

  void walk() {
    print("Person can walk");
  }

  void talk() {
    print("Person can talk");
  }
}
class Jay implements Person {

  @override
  void walk() {
    print("Jay can walk");
  }

  @override
  void talk() {
    print("Jay can talk");
  }
}

main() {
  Person person = new Person();
  Jay jay = new Jay();

  person.walk();
  person.talk();

  jay.walk();
  jay.talk();
}

Output
Person can walk
Person can talk
Jay can walk
Jay can talk

Implementing Multiple Interface

Dart does not support multiple inheritance but dart can implement multiple interfaces. To provide similar power and functionality.

The syntax for declaring multiple interfaces

class class_name implements interface1, interface2, interface3

Sample Code

class Person {
  String name;

  void ShowName() {
    print("My name is $name");
  }

  void walk() {
    print("Person can walk");
  }

  void talk() {
    print("Person can talk");
  }
}

class Akshay {
  String profession;

  void ShowProfession() {
    print("from class Akshay my profession is $profession");
  }
}

class Jay implements Person, Akshay {
  @override
  String profession;

  @override
  void ShowProfession() {
    print("from class Jay my Profession is $profession");
  }
@override 
  String name; 

  @override 
  void ShowName() { 
    print("From class Jay my name is $name"); 
  } 

  @override 
  void walk() { 
    print("Jay can walk"); 
  } 

  @override 
  void talk() { 
    print("Jay can talk"); 
  } 
} 

main() { 
  Person person = new Person(); 
  Jay jay = new Jay(); 
  Viraj viraj = new Viraj(); 

  person.walk(); 
  person.talk(); 
  person.name = "Person"; 
  person.ShowName(); 

  print(""); 

  jay.walk(); 
  jay.talk(); 
  jay.name = "JAY"; 
  jay.profession = "Software Development"; 
  jay.ShowProfession(); 
  jay.ShowName(); 

  print(""); 

  akshay.profession = "Chemical Engineer"; 
  akshay.ShowProfession(); 
}

Output

Person can walk
Person can talk
My name is Person

Jay can walk
Jay can talk
from class Jay my Profession is Software Development
From class Jay my name is JAY

from class Akshay my profession is Chemical Engineer

So that’s it for interface guys. Please read this article twice if you don’t understand the concept in the first move. And do a little bit of research on an interface. Don’t worry if you didn’t get the concept in the first attempt. Even I get it in a 3rd try. So don’t worry, just practice it.

Also, feel free to let me know if I miss something. Till then keep Loving, keep Coding. And I’ll surely catch you up in next article.

Follow me for more such content

Constructors in Dart

Jay Tillu — Mon, 16 Sep 2019 05:10:51 +0000

A constructor is a special method (function) of a class that helps to create an object. As its name indicates its constructs the new object.
It helps to create the object by initializing values to instance variables. So we can say that its main goal is to provide values to instance variables.

How constructor is different from other methods of Class

There are some major differences between the normal method and constructor.

The constructor has the same name as the class.
The constructor doesn’t have a return type.
A constructor is automatically called when the object is created.
If we don’t specify a constructor, the default no-argument constructor will be created.

Syntax of declaring constructor

class_name (arguments) {  //If there is a block of code.
  // Constructor body
}

or

class_name (arguments); // If there is no block of code.

Sample Code

class Student{
  Student(int enNum){
    print(enNum);
  }
}

main(){
  var myStudent = new Student(15);
}

Output
15

Named Constructor

After seeing the advantages of the constructor you might want to create multiple constructors. But as we know constructor holds the name of the class. So, in that case, you might ask then how can we create multiple constructors and treat them differently. Then here comes a Named Constructor in the picture.
By using named constructor you can create multiple constructors in the same class. Each constructor will have a unique name. So that you can identify each of them.

Syntax of defining a named constructor

class_name.constructor_name (arguments){ 
   // If there is block of code use this syntax
   // Statements
}

or

class_name.constructor_name (arguments); 
   // If there is not block of code use this syntax

Sample Code

class Employee {
  int empID;
  String empName;
  String empDept;

  Employee.ID(this.empID); // Named Constructor Creation

  Employee.name(this.empName);

  Employee.department(this.empDept);
}

main() {
  var myEmployee01 = new Employee.ID(15);
  var myEmployee02 = new Employee.department("Testing");
  var myEmployee03 = new Employee.name("Ashu");

  print(myEmployee01.empID);
  print(myEmployee02.empDept);
  print(myEmployee03.empName);
}

Output
15
Testing
Ashu

So, guys, that’s it for constructors in a dart. Again this is also the core concept of Object Oriented Programming. So practice it a little bit. Please feel free to share with me if I miss something. Till Then Keep Loving, Keep Coding. And I surely catch you up in the next article.

Follow me for more such content

Classes and Objects in Dart

Jay Tillu — Mon, 16 Sep 2019 05:02:50 +0000

No matter which framework you want to learn or use

No matter which language you want to learn and use

No matter which kind of software you want to create

All of them today is based on OOPs concept and Classes and objects are base of OOP concepts.

Here I will try to explain to you what is class and objects in Object Oriented Programming via a small example given to me by my udemy instructor Paulo Dichone.

What will we do if we want to create a Microphone?

The first step to create the microphone or any real-world thing is to create the blueprint of it.

In the blueprint, we define its properties and its functionality like

its color is its property
its mic type is its property
its model number is its property etc.
we can set the volume of the mic which is its functionality
we can mute the mic which is its functionality
we can turn it on or off which is its functionality etc.
After creating one blueprint, Then by using that blueprint we can create a number of microphones. All microphones will have the same properties and functionality.

From a programming point of view

Same concept here goes with Classes and Object’s terminology.
The blueprint is called Class and the microphones or any other devices is called object here.
Class is a blueprint from which we can create a number of objects. All objects will have access to all properties and methods. You can also modify access according to your need.

In Object Oriented Programming class is made up of four main things

Properties (Instance Variables)
Methods (Functions)
Getters and Setters
Constructors

These all components are also called data members of the class.
Remember here Properties can be also called Instance Variable and Methods are also called Functions.

Syntax of Declaring Class

class class_name {
   // Properties (Instance Variables)
   // Constructor
   // Methods (Functions)
   // Getters and Setters
}

The class keyword is used to declare a class.

Sample Code

class Mobile {
  String color;
  String brandName;

  String calling() {
    return "Mobile can do calling";
  }

  String musicPlay() {
    return "Mobile can play Music";
  }
}

Syntax of Creating Object

var object_name = new class_name (arguments);

Sample Code

var myMobile = Mobile();

Accessing Properties and Methods Of Class

As I mentioned earlier all the properties and methods of a class can be accessed via the class’s object.
For accessing the class’s properties and methods, we use ‘.’ (dot notation) also called a period.

Syntax of accessing properties and methods

// Accessing Properties
   object_name.property_name;
// Accessing Methods
   object_name.method_name;

Sample Code

// Accessing properties
    myMobile.color;
    myMobile.brandName;

// Accessing methods
    myMobile.calling();
    myMobile.musicPlay();

Let’s understand all concepts by one complete program

class Mobile {
  String color; // Property
  String brandName;
  String modelName;

  String calling() { // Method Creation
    return "Mobile can do calling";
  }

  String musicPlay() {
    return "Mobile can play Music";
  }

  String videoPlay() {
    return "Mobile can play video";
  }
}

main() {
  var myMobile = new Mobile(); // Creating Object

  myMobile.color = "White"; // Accessing Class's Property
  myMobile.brandName = "Apple Inc.";
  myMobile.modelName = "iPhone 14";

  print(myMobile.color);
  print(myMobile.modelName);
  print(myMobile.brandName);
  print(myMobile.calling());
  print(myMobile.musicPlay());
  print(myMobile.videoPlay());
}

Output
White
iPhone 14
Apple Inc.
Mobile can do calling
Mobile can play Music
Mobile can play video

Remember guys, classes and objects are basic building blocks of Object-Oriented Programming.
All big frameworks like Flutter, React, Django, Angular and big software like IDEs, Web Apps, Mobile Apps, Server side apps and also programming language itself are based on OOPs concepts.
So please have a clear clarity and strong understanding of these concepts.

Follow me for more such content

Abstract Classes and Abstract Methods in Dart

Jay Tillu — Mon, 16 Sep 2019 04:48:35 +0000

An abstract class is a type of class that cannot be instantiated directly which means an object cannot be created from it.
An abstract class cannot be instantiated but they can be sub-classed.
To define an abstract class we use abstract keyword.

The syntax for defining Abstract Class

abstract class class_name {
  // Body of abstract class
}

Abstract Methods

Abstract methods can only exist within an abstract class.
To make a method abstract, use a semicolon (;) instead of the method body.

void talk (); // Abstract method
void walk (); // Abstract method

Normal classes can extend the abstract class, but they have to override every abstract method.
You can also create normal methods in the abstract class. And to override normal method is not mandatory.
The abstract class will only complain when you don’t override the abstract method.

Sample Code

abstract class Person{
void walk();  //Abstract Method
  void talk();  //Abstract Method
}
class Jay extends Person{
  @override
  void walk() {
    print("Jay can walk");
  }
@override
  void talk() {
    print("Jay can talk");
  }
}
main(){
  Jay jay = new Jay();
jay.talk();
  jay.walk();
}

Output
Jay can talk
Jay can walk

Difference between Abstract class and Interface

So now after seeing both abstract class and interface. You might ask that technically they look the same. Ya, that’s true that they are closely related. But guys they are not exactly the same. Let’s understand the basic difference between them.

So, guys, that’s it for abstract classes. Feel free to tell me if I miss something, I’ll love to learn it from you. Till then Keep Loving, Keep Coding. And Just like always I’ll catch you up in the next article.

Follow me for more such content

List in Dart

Jay Tillu — Mon, 16 Sep 2019 04:02:56 +0000

Consider a situation where we need to store five String values. If we use programming's simple variable and data type concepts, then we need five variables of String data type.
It seems simple because we had to store just five String values. Now let's assume we have to store 10000 String values. Now its too much time consuming to create 10000 variables.
To overcome this kind of situations we have a concept called Collections.
Collections are used to store data.

In dart, collections can be classified into four basic categories:

List
Map
Set
Queue

But the list and map are mostly used. Set and queue are used in some special cases.

List

The list is a collection of data having the same data type. In other languages List is called Array.
In list, data is stored in an ordered way.
Every individual element of the list can be accessed by its index number. The index number always starts from 0.

There are two types of list:

Fixed length list
Growable list

Fixed Length List

In the fixed length list once the length of the list is defined it cannot be changed during run time.

Syntax

List <data type> list_name = List (length of list);

Sample Code

main() {
  List<int> marks = List(5);
  marks[0] = 25;    // Inserting values to list
  marks[1] = 35;
  marks[2] = 65;
  marks[3] = 75;
  marks[4] = 63;

  for (int elements in marks) {
    print(elements);
  }
}

Output
25
35
65
75
63

Growable List

The length of Growable list is dynamic. It can be changed during run time.

Syntax

List <data type> list_name = List (); // Way 1
List <data type> list_name = [element1, element2]; // Way 2

Sample Code

main() {

  List<String> countries = ["India", "Nepal"];
  for (String elements in countries) {
    print(elements);
  }
}

Output
India
Nepal

So, guys, That’s it for a list. As I always say practice it, understand it conceptually. Till then Keep Loving, Keep Coding. And just like always I’ll surely catch you up in the next article. 😊

Follow me for more such content

Maps in Dart

Jay Tillu — Mon, 16 Sep 2019 03:03:39 +0000

Just like List, Map is also a type of collection. In Maps data is stored in key: value pairs. Keys and values can be of any type.
The map is a growable collection that means it can shrink and grow at runtime.
Map can contain NULL value as well.
There are two ways to to declare maps:

Using Map Literal
Using Map constructor

Using Map Literal

Just like we declare list using var keyword, we can also use var for declaring Maps.
The main difference between declaration is, for declaring list we use , but to declare maps we have to use {}(curly braces).
for declaring list use [ ]
for declaring map use {}

Syntax for declaring map through variable

var VariableName = {
  key : value, 
  key : value,
  key : value,
  key : value,
};

Sample code for declaring Map through variable

void main() {
  var myMap = {
    "id": "jay",
    "password": "1234",
    "name": "Jay Tillu",
  };
  print(myMap);
}

output
{id: jay, password: 1234, name: Jay Tillu}

Syntax for Adding value to Map at Runtime

mapName[key] = value;

Sample code for adding value to Map

void main() {
  var myMap = {
    "id": "jay",
    "password": "1234",
    "name": "Jay Tillu",
  };
  print("************ Before adding data in Map ************");
  print(myMap);

  // Adding value to Map

  myMap["country"] = "india";
  print("************ After adding data in Map ************");
  print(myMap);
}

Output
************ Before adding data in Map ************
{id: jay, password: 1234, name: Jay Tillu}
************ After adding data in Map ************
{id: jay, password: 1234, name: Jay Tillu, country: india}

Map Constructor

For declaring Map we can also use Map() constructor. It’s just which way you like. There nothing wrong if you declare map using standard method.

Syntax for declaring map through Map constructor

var mapName = Map();
mapName[key] = value;   // For adding value to your Map

Sample Code for declaring map through Map constructor

void main() {
  var myMap = Map();
  print("************ Before adding data in Map ************");
  print(myMap);

//  Adding value to Map
  myMap["id"] = "jay";
  myMap["password"] = "1234";
  myMap["country"] = "India";
  print("************ After adding data in Map ************");
  print(myMap);
}

Output
************ Before adding data in Map ************
{}
************ After adding data in Map ************
{id: jay, password: 1234, country: India}

So, guys, That’s it for maps. Feel free to let me know if I miss something. Till then Keep Loving, Keep Coding. And Just like always I’ll catch you up in the next article. 😊