1. Problem Identification (Cost Benefit Analysis)

2. Requirement Analysis (Interactive / Unobtrusive method to analyze the project)

3. System Analysis (CASE Tools, Activity and Framework selection, Process Modeling - Prototyping, Agile, RAD, XP, Scrum, V-type, Waterfall, Concurrent)

4. System Designing (App Architecture, Usecase, UML, Sequence, State chart Diagram etc.)

5. Development and Documentation (Pair programming, Code reviewing, Code refactoring, SOLID principle)

6. Testing and Maintenance (Unit testing, Integration testing, System testing, Acceptance Testing)

7. Implementation And Evaluation (Deployment strategy, Security enhancement, Bug reporting, Feedback analysis)

Interesting fact 😮😮😮
Time spent on maintenance typically ranges from 48-60 percent of total time

Problem Identification

For selecting a project in an organization, it must meet five criteria:

1. Backed by management

2. Having timed appropriate resources

3. It must move the business toward the attainment of its goal

4. Cost-effective

5. Important enough to select over other projects

Cost Benefit Analysis

We want to gain more benefits from the project than from its development and running costs over time. In this scenario, we may be concerned about how long it will take to return the investment or the profit percentage compared with the initial investment.

1. Payback Analysis: Analysis that finds the unit of time when investors will get their money back.

   $$payback \space period = total \space investment \div Annual \space cash \space flow$$

2. Net Present Value (NPV): This analysis calculates the difference between cash inflows and outflows over time. It’s unique because it uses the time-value perspective of the invested money and considers discounted cash flow reflecting risk, inflation, or opportunity cost.

   $$npv = \sum^t_0 {cashflow \space X \space discounted factor}$$

3. Return on Investment: This analysis shows how much return you will get compared to the initial investment.

   $$ROI = average\space net\space profit \space\div total \space investment$$

We should check the project’s feasibility before requirement analysis: a. Technical b. Economical c. Operational.

We must plan its high-level activities and estimated time in this planning phase. We can use the GANTT chart or PERT to get a rough idea of the estimated time for the whole project. Here is an example of a GANTT chart:

Requirement Analysis

To analyze the project's requirements, we must gather information from its stakeholders, documents, files, or the current system.

An analyst can gather information regarding the project based on two approaches: Interactive (Involvement of individuals) and Unobtrusive ( Sampling, Observing, Analyzing From files, documents, or current system behaviors / applying STROBE)

Question Types

Before collecting data, we must know that Information can be derived from two types of questions: Open-ended and closed-ended questions. Here are the significant differences between open-end and close-end questions:

Question Arrangement

We can arrange questions in three exciting formats:

1. Pyramid (Close-end → Open-end): It’s a helpful technique when the responder needs to be warmed up about the topic.

2. Funnel (Open-end → Close-end): It’s useful when we want to connect emotionally with the responder by asking broad questions.

3. Diamond (Close-end → Open-end → Close-end): This is an excellent way to conduct an interview, but it takes more time than the Pyramid or Funnel structure.

An interactive way to collect information

Here are the ways to collect data from stakeholders of the project:

1. Interviewing:

   To initiate an interview, we must study specific background material regarding the project. Then, we will establish the interview’s objectives. Next, we should decide whom to call for an interview. After that, we will prepare the interviewee. Now, we will set up a structure of questions (Pyramid, Funnel, or Diamond). Finally, we must close the interview by asking if the interviewee has something to talk about, summarizing and providing feedback, asking whom we should talk with next if required, asking for the following schedule if needed, and appreciating for joining the interview.

2. User stories:

   Stories are a remarkable way to understand the underlying problems of the current system. But they take more time than interviews, and sometimes, listening to stories is not efficient enough.

3. JAD:

   Joint Application Design is a process for collecting information regarding a project in a group-based session. It usually happens where we need to sit within a group to discuss and talk in an offsite location. If the Pre-planning and follow-up report are incomplete, such a meeting would not be fruitful.

4. Questionnaires:

   We can collect data by filling out a questionnaire form. Electrical forms are cheaper and easy to store for future use.

After gathering all the information about the project, we must write an SRS (Software Requirement Specification) so that we can validate upon testing that this software meets all the requirements.

System Analysis

First, we should introduce ourselves with what is software actually.

Actually, software is a set of instructions (computer program) that, when executed, provides desired features, functions, and performance where the user can modify the data according to data structures and has its own documentation that describes its operation. And the software doesn’t wear out as much hardware because it doesn’t affect outer environment conditions.

For analyzing a system, we may need to know whether the estimated size of the project is large or small. Larger projects need three things - Efficiency of work, Reliability, Ease of Maintenance, and Guaranteed Performance. That’s why we use one kind of activity framework called Umbrella Activities.

Umbrella Activity

The core activities of this policy are shown below:

1. Formal Technical Interview

2. Software Project Management

3. Software Configuration Management

4. Software Quality Assurance

5. Work product preparation and production

6. Risk Management

7. Reusability

8. Measurements

Framework Activity

This activity is a good solution for small to mid projects because it only focuses on the below activities -

1. Communication

2. Planning

3. Modeling

4. Construction

5. Deployment

Now, let’s learn about process modeling, a structured way to develop software that aligns with a sequence of tasks and activities and sets up milestones and deliverables.

Interesting Fact 😮 😮 😮
Do you know the difference between Milestones and deliverables? Ans: Milestones are short-rewarding activities that are submitted to project manager and deliverables are required functionalities that are submitted to the client. All the deliverables are milestones but not all the milestones are deliverables.

Process Model

There are many software development models available. I have always preferred Scrum for long-term projects and Extreme Programming (XP) for complex projects.

Baseline Models Comparison

Here is a comparison table showing key aspects of the Waterfall, Incremental, and Concurrent process models:

Efficient Models Comparison

Here’s a comparison table highlighting the differences between Agile Scrum, Agile Extreme Programming (XP), and the V-Model:

Picture time for process modeling

Basic Estimation using LOC

Proper cost estimation is a multi-variant strategy for running a sustainable business. Without proper software design analysis, we cannot arrive at a logical costing of developing the software as we need people, a set of skills, identification of OTS and non-OTF components, tools, hardware, and network resources.

LOC means Line of code. Based on LOC and the cost of the person-month strategy, we can estimate a cost for a specific software. To do this→

1. Functional decomposition of the requirements

Estimate the size of each function LOC

Example Table:

$$Total \space LOC = (\frac{{\text{LOC_Optimistic} + 4 \times \text{LOC_Most_Likely} + \text{LOC_Pessimistic}}}{6})$$

1. Calculate the price

   1. $$[ \text{Effort} = \frac{\text{Total LOC}}{\text{Productivity Rate}} ]$$

   2. $$[ \text{Estimated Cost} = \text{Effort} \times \text{Labour Rate} ]$$

Wow Fact 😮 😮 😮

The Lines of Code (LOC) range can vary based on the industry, but general estimates for project sizes are often categorized as follows:

• Small Project: Up to 10,000 LOC

• Medium Project: 10,000 to 100,000 LOC

• Large Project: 100,000 LOC and above

System Designing

When it comes to designing a system, a minimum set of skills is required to proceed with the development of software. This is why I will overview the concept and an example of each diagram used for designing software. They are:

Use Case Diagram components and example

The components of this diagram are:

1. Primary Actor

2. Secondary Actors

3. Relations

   1. Association

   2. Generalization

   3. Dependency (Include (mandatory), Exclude (not mandatory))

Examples:

UML Class Diagram

Here are the components:

Examples:

Sequence Diagram

Activity Diagram

State Machine Diagram

App Architecture Diagram (I love this diagram)

Relationship Schema ( I prefer this over ERD )

Development and Documentation

I would not like to add details on this topic as it requires a set of programming skills and concepts of the technical stack and how it works. So here are the basics you must know about it.

Pair Programming

When two developers at a time write higher-level programming instructions for developing software, one can observe the code structure and errors while the other one can write the actual code. It’s used in extreme programming.

Code Refactoring

It’s a way of organizing code where both input and output remain the same but are optimized based on performance, code readability, and reusability. We use SOLID principles for refactoring the code.

Testing and Maintenance

White Box vs Black Box Testing

Here’s a comparison table highlighting the differences between White Box Testing and Black Box Testing:

Unit, Integration, Penetration, System Testing

Here’s a comparison table that highlights the differences between Unit Testing, Integration Testing, Penetration Testing, and System Testing:

Maintenance

The maintenance strategy was discussed shortly in the system analysis process modeling section.

This image provides a visual overview of the four main types of software maintenance. They are:

1. Corrective Software Maintenance: This involves fixing bugs or errors that emerge during the software's lifecycle to ensure its correct function.

2. Preventative Software Maintenance: This type aims to prevent future problems by anticipating potential issues and improving the software's stability and performance.

3. Perfective Software Maintenance: Enhancements are made to improve the software's functionality and usability based on user feedback or new requirements.

4. Adaptive Software Maintenance: This involves updating the software to remain compatible with changing environments, such as new operating systems or hardware.

Implementation and Evaluation

Have you heard the name of CI/CD Pipeline?

A continuous integration and continuous deployment (CI/CD) pipeline is a series of steps that must be performed to deliver a new version of software. CI/CD pipelines are a practice focused on improving software delivery via automation throughout the software development life cycle. Here is an overall picture of how we can implement CI/CD through Jenkins:

Here are the components of the CI/CD pipelines:

GitHub

The code will be stored in a GitHub repository. This repository will act as the source of truth for the codebase.

Jenkins

Jenkins will be set up on an EC2 instance for Continuous Integration/Continuous Deployment. Jenkins will handle tasks like testing the code and deploying it to production.

Code Deployment Strategy

When changes are pushed to the GitHub repository, Jenkins will automatically trigger a build and test sequence. If successful, Jenkins will deploy the new version to the EC2 instances.

AWS CodeDeploy (Optional)

AWS CodeDeploy could be used for deployment automation to EC2 instances, which allows handling complex deployment scenarios and performing blue/green deployments.

Deployment

As an AWS lover, I would love to discuss a summary of how we can deploy software using AWS servers.

AWS Setup Components Description

Here are the components of AWS setup that is required for deployments:

EC2 Instances

Use EC2 instances to host your Node.js backend. You can set up an Auto Scaling group to handle load changes.

Elasticache

Elasticache (Redis or Memcached) will be implemented for caching. This will help reduce the load on the database and improve response times.

CloudWatch

CloudWatch will be used for monitoring the application's performance and logging. Alarms will be set to get alerts on specific metrics like CPU usage or error rates.

Route 53

AWS Route 53 will manage DNS for the domain, providing reliable and scalable domain name services.

RDS for MySQL

Amazon RDS will manage the MySQL database. It provides automated backups, patch management, and scaling capabilities.

Elasticache

Elasticache (Redis or Memcached) will be implemented for caching. This will help reduce the load on the database and improve response times.

CloudWatch

CloudWatch will be used for monitoring the application's performance and logging. Alarms will be set to get alerts on specific metrics like CPU usage or error rates.

Route 53

AWS Route 53 will manage DNS for the domain, providing reliable and scalable domain name services.

DynamoDB

Amazon DynamoDB is a serverless, NoSQL database service that allows you to develop modern applications at any scale. As a serverless database, you only pay for what you use and DynamoDB scales to zero, has no cold starts, no version upgrades, no maintenance windows, no patching, and no downtime maintenance.

AWS Secrets Manager
It will be used to handle secrets of the Node.js application. It aids in securely storing, managing, and retrieving secrets such as database credentials and API keys.

AWS step-by-step points

Below are detailed step-by-step instructions for each component of your deployment strategy:

1. VPC Initialization

1. Create a VPC

2. Create Subnets

3. Set Up Internet Gateway

4. Configure Route Tables

2. Connecting Route53 Nameserver

1. Create a Hosted Zone

2. Update Domain Registrar

3. Pushing dotenv to AWS Secrets Manager

1. Create a New Secret

2. Set Permissions

4. Setting up EC2 and RDS in the same VPC (different subnets)

5. Creating Elasticache Cluster for Memcached within the same VPC

6. Adding DB Connection String to AWS SM

7. Installing Amazon-CloudWatch-Agent

sudo yum install -y amazon-cloudwatch-agent

Configure the Agent: Use amazon-cloudwatch-agent-config-wizard to configure metrics and logs to collect and save the configuration file under /opt/aws/amazon-cloudwatch-agent/bin/config.json.

8. Enabling Detailed Monitoring for EC2

9. Setting up CloudWatch Alarms

TO BE CONTINUED…..

Numerical integration methods provide approximate solutions to definite integrals by breaking down the area under the curve into smaller, more manageable shapes like rectangles, trapezoids, or parabolas. By summing up the areas of these shapes, we can get an approximation of the total area under the curve.

Step Size (h):

$$h = \frac{b-a}{n}$$

$$ n = number \space of \space intervals$$

Try it out:

$$\int_{0}^{1} x^2 \, dx = \left[ \frac{x^3}{3} \right]_0^1 = \frac{1^3}{3} - \frac{0^3}{3} = \frac{1}{3}$$

Trapezoidal Rule

This method approximates the area under the curve using trapezoids. The area of each trapezoid is computed and then summed up to get the total area.

Main Idea: Divide the interval into smaller subintervals and approximate the area under the curve using trapezoids over each subinterval.

Visualization:

Equation:

$$I(h) = h \times (\frac {y_0 + y_n}{2} + y_1 + y_2 +...)$$

Code:

#include <bits/stdc++.h>
using namespace std;
double f(double x) {
// Example function, you can replace this with any function
return x*x; 
}
double trapezoidalRule(double a, double b, int n) {
    double h = (b - a) / n;
    double result = 0.5 * (f(a) + f(b));

    for (int i = 1; i < n; i++) {
        result += f(a + i*h);
    }
    return h * result;
}
int main() {
    double a = 0.0, b = 1.0; // Integration limits
    int n = 100; // Number of subintervals
    cout << "Approximate value of integral: " << trapezoidalRule(a, b, n) << std::endl;
    return 0;
}

Simpsons 1/3 Rule

This method uses parabolas to approximate the area under the curve.

Main Idea: Use quadratic polynomials to approximate the function over pairs of subintervals.

Visualization:

Equations:

$$I(h) = \frac{h}{3} \times ((y_0 + y_n) + 4(y_1 + y_3 + ..) + 2(y_2 + y_4 + ...))$$

Code:

double simpsonsOneThirdRule(double a, double b, int n) {
    double h = (b - a) / n;
    double result = f(a) + f(b);

    for (int i = 1; i < n; i++) {
        if (i % 2 == 0) {
            result += 2 * f(a + i*h);
        } else {
            result += 4 * f(a + i*h);
        }
    }
    return (h / 3) * result;
}

Simpsons 3/8 Rule

This method is an extension of Simpson's 1/3 rule and uses cubic polynomials for approximation.

Main Idea: Use cubic polynomials to approximate the function over sets of three subintervals.

Visualization:

Equation:

$$I(h) = \frac{3h}{8} \times ((y_0 + y_n) + 3 (y_1 + y_2 + y_4 + ..) + 2(y_3 + y_6 + ..) )$$

Code:

double simpsonsThreeEighthRule(double a, double b, int n) {
    double h = (b - a) / n;
    double result = f(a) + f(b);

    for (int i = 1; i < n; i++) {
        if (i % 3 == 0) {
            result += 2 * f(a + i*h);
        } else {
            result += 3 * f(a + i*h);
        }
    }

    return (3 * h / 8) * result;
}

Difference between Trapezoidal and Simpson's method

Romberg Integration

Romberg Integration is a powerful numerical integration method that combines the trapezoidal rule with Richardson extrapolation to achieve faster convergence and higher accuracy.

Main Idea: Romberg Integration starts with the trapezoidal rule and then refines the approximation using Richardson extrapolation. The method takes advantage of the fact that the error in the trapezoidal rule can be expressed as a power series in the step size. By computing the trapezoidal rule for different step sizes and combining the results, the leading error terms can be eliminated, leading to a more accurate approximation.

Details:

1. Initialization: Start with the coarsest approximation using the trapezoidal rule over the entire interval [a,b].

2. Refinement: Halve the step size and compute the trapezoidal rule again. This gives a finer approximation.

3. Richardson Extrapolation: Use the coarse and fine approximations to compute a new, even more accurate approximation. This is done by eliminating the leading error term.

$$f'(x) = \frac{D(rh)-D(h)r^2}{1-r^2}$$

$$D(h) = \frac{f(x+h) - f(x-h)}{2h}$$

1. Iteration: Repeat the refinement and extrapolation steps until the desired level of accuracy is achieved or a maximum number of iterations is reached.

Visualization:

The tabular method for calculating Romberg's approximation using h, h/2, h/4, h/8:

Code:

double rombergIntegration(double a, double b, int n, int m) {
    double h = (b - a) / n;
    double R[n+1][m+1];

    for (int i = 0; i <= n; i++) {
        R[i][0] = 0.5 * h * (f(a + i*h) + f(b + i*h));
    }

    for (int j = 1; j <= m; j++) {
        h /= 2;
        for (int i = 0; i <= n - pow(2, j-1); i++) {
            R[i][j] = 0.5 * R[i][j-1] + h * f(a + i*h + h/2);
        }
        for (int k = 1; k <= j; k++) {
            R[0][k] = R[0][k-1] + (R[0][k-1] - R[0][k-2]) / (pow(4, k) - 1);
        }
    }

    return R[0][m];
}

Thank you for reading the article!

Data communication means the exchange of information between two or more devices using some transmission medium.

• Effectiveness of Data Communication Layer: (DATJ)

  1. Delivery, 2. Accuracy, 3. Timeliness, 4. Jitter

• Components of Data Communication

  1. Message, 2. Sender, 3. Receiver, 4. Transmission Medium, 5. Protocol

• Data Representation

  1. Text, 2. Number, 3. Images, 4. Audios, 5. Videos

• Data Flow

  1. Simplex, 2. Half Duplex, 3. Full Duplex

• Network Criteria (PRS)

  1. Performance →

     a. Throughput

     The throughput is a measure of how fast we can actually send data through a network

     Unit: bps

     b. Latency

     The latency or delay defines how long it takes for an entire message to completely arrive at the destination from the time the first bit is sent out from the source.

     Latency = propagation time + transmission time + queuing time + processing delay

     Unit: second

  2. Reliability,

  3. Security

What is a network? Interconnection between devices

Network components → 1. Host, 2. Connecting Devices ( Router, Switch, Modem)

Router → Network to Network Connection

Switch → Device to Device Connection

Modem → Data form exchange

Types of Connections → 1. Wired, 2. Wireless

Wired Connection → 1. Point to Point, 2. Multi-point

Topologies → 1. Bus, 2. Ring, 3. Mesh, 4. Star

• Accessing the Internet

  1. Using Telephone → Dial-up and DSL

  2. Using Wireless Network → point-to-point WAN

  3. Using Cable Network → Through Cable

  4. Direct Connect to the Internet → ISP

Switches →

1. Circuit Switched Network

2. Packed Switched Network

Two popular Data Communication Models:

1. OSI → 1. Application, 2. Presentation, 3. Session, 4. Transport, 5. Network, 6. Data-link, 7. Physical

2. TCP/IP → 1. Application, 2. Transport, 3. Network, 4. Data-link, 5. Physical

Two principles for all protocols:

1. First principle: Each layer needs to work on two opposite tasks.

2. Second principle: Each layer must be identical between the source and destination

Addressing each layer of TCP/IP:

Lacks of OSI Model Success:

1. To replace the infrastructure from TCP/IP to OSI model, it needs a lot of time and money,

2. Services are not fully described in the presentation and session layer of the OSI model and

3. Performances are not high enough to attract ISOC to switch TCP/IP to the OSI model.

There are 4 signals:

1. Periodic Analog Signal,

2. Non-periodic Analog Signal,

3. Periodic Digital Signal

4. Non-periodic Digital Signal

Signal Basics:

Bandwidth: The bandwidth of a composite signal is the difference between the highest and the lowest frequencies contained in that signal. Unit: Hz.

$$B = F_h - F_l$$

Bit Rate: The number of bits transferred per second is called bitrate. Unit: bps

$$number \space of \space bits = log_2 (bit \space level)$$

Bit length = propagation speed * bit duration

The non-periodic digital signal can be converted to as non-periodic analog signal.

Transmission of Digital Signal

1. Baseband:

   Baseband transmission means transferring digital signal to digital signal using a low-pass channel.

   

   Case 1. Low Pass Channel with Wide Bandwidth

   Case 2. Low Pass Channel with Limited Bandwidth,

2. Broadband:

   Broadband transmission means converting digital signal to analog signal in the sending end using modulation, and in the receiving end, it converts analog signal to digital signal through the band-pass channel.

   

Transmission Impairment:

1. Attenuation (loss of energy),

   loss of power (unit: dB)

$$10log_{10}\frac{p_2}{p_1}$$

1. Distortion (Changes in shape)

2. Noise

   Type of Noises:

   1. thermal: the random motion of electrons in a wire, which creates an extra signal.

   2. Induced: comes from sources such as motors and appliances.

   3. Crosstalk: the effect of one wire on the other

   4. Impulse: a spike (a signal with high energy in a very short time) that comes from power lines or lightning.

Signal-to-Noise Ratio (SNR):

to find the theoretical bit rate limit, we need to know the ratio of the signal power to the noise power. The signal-to-noise ratio is defined as,

$$SNR = \frac{average\space signal \space power}{average \space noise \space power}$$

A high SNR means the signal is less corrupted by noise; a low SNR means the signal is more corrupted by noise. Because SNR is the ratio of two powers, it is often described in decibel units,

$$SNR_{dB} = 10 log_{10}\frac{average\space signal \space power}{average \space noise \space power} = 10 log_{10}(SNR)$$

Data Rate Limits:

A very important consideration in data communications is how fast we can send data, in bits per second, over a channel. The data rate depends on three factors:

1. The bandwidth available

2. The level of the signals we use

3. The quality of the channel (the level of noise)

Two theoretical formulas were developed to calculate the data rate: one by Nyquist for a noiseless channel, and another by Shannon for a noisy channel.

Noiseless Channel: Nyquist Bit Rate

$$bitrate = 2 \times bandwidth \times bit \space length = 2 \times bandwidth \times log_2(Level)$$

Noisy Channel: Shannon Capacity

$$Capacity = bandwidth \times log_2(1 + SNR)$$

capacity is the capacity of the channel in bits per second

Note: The Shannon capacity gives us the upper limit; the Nyquist formula tells us how many signal levels we need.

Equations:

1. Transmission time = (Message size) / Bandwidth

2. The bandwidth-delay product defines the number of bits that can fill the link

Digital Signal Conversion

Characteristics of Digital Signal Conversion:

1. Baseline wandering refers to the slow, low-frequency variations or shifts in the baseline or the zero-level reference of a signal.

2. When the voltage level in a digital signal is constant for a while, the spectrum creates very low frequencies which creates DC Components problem.

3. Self-synchronization refers to the sync between the receiver’s bits interval and the sender’s bits interval.

4. Built-in error-detecting capability in the generated code to detect some or all of the errors that occurred during transmission.

5. Immunity to Noise and Interference

6. Complexity: A more complex Scheme is costly.

Digital to Digital Data Encoding:

$$r = \frac {data\space element}{signal \space element} = \frac{data \space rate}{ signal \space rate} = \frac{N}{S}$$

Three types of encoding schemes:

1. Line encoding:

   1. Unipolar: (0, + v / - v)

      1. NRZ:

         bit 1 = + v bit 0 = 0

   2. Polar: (+ v, - v )

      1. NRZ-L:

         bit 1 = - v

         bit 0 = + v

      2. NRZ-I:

         bit 1 = change

         bit 0 = no change

      3. Biphase:

         1. Manchester:

            bit 1 = - v to + v

            bit 0 = + v to - v

         2. Differential Manchester:

            bit 1 = no transition = no inversion

            bit 0 = transition = inversion

   3. Bipolar:

      1. AMI:

         bit 1 = transition

         bit 0 = 0

      2. Pseudo-ternary:

         bit 1 = 0

         bit 0 = transition

   4. Multilevel:

      1. 2B1Q:

         

   5. Multitransition:

      1. MLT-3

         bit 1 = opposite of last non-zero if the current level is zero 0 if the current level is non-zero

         bit 0 = no transition

Bandwidth Table:

1. Block encoding: mBnB

   1. 4B/5B, b. 8B/10B

2. Scrambling:

   1. B8ZS: (Bipolar with 8 zeros Substuition)

      0000 0000 = 000VB0VB V = last non-zero level

      B = opposite of the last non-zero level

   2. HDB3: (High Density Bi-polar 3 Zeros)

      0000 = 000V (odd numbers of last non-zeros)

      0000 = B00V (even numbers of last non-zeros)

Analog to Digital Conversion:

1. PCM: (Pulse Code Modulation)

   1. Sampling by Nyquist theorem

   2. Quantizing : Delta = (V_max - V_min) / L

   3. Encoding

2. DM: (Delta Modulation)

   1. Modulator,

   2. Demodulator,

   3. Adaptive DM

   4. Quantizing Error

Digital Transmission Mode:

1. Serial:

   1. Asynchronous, (stop bit, start bit)

   2. Synchronous (sender and receiver’s clock time = same)

   3. Isochronous (video and audio real-time data)

2. Parallel

Analog Signal Transmission

Digital to Analog: (Digital Signal + Carrier Signal = Modulated Signal)

1. ASK

   0 = 0 amplitude

   level = 2 (BASK)

   r = Log( Level)

   B = (1 + d) S = (1 +d ) N/ r

2. PSK

   0 = 180 phase

   level = 2 (BPSK)

   r = Log( Level)

   B = (1 + d) S = (1 +d ) N/ r

3. FSK

   1 = Frequency Increased

   B = ( 1 + d) * S + 2F

4. QAM (ASK + PSK)

   Use constellation diagram

   example: 4 QAM, 16 QAM, 64 QAM

Analog to Analog: (Modulating Analog Signal + Carrier Signal = Modulated Signal)

1. AM

2. FM

3. PM

Bandwidth Utilization

There are 3 multiplexing techniques to utilize the bandwidth:

1. FDM (Analog Signal)

   Frequency Division Multiplexing: Create a composite signal of broad frequencies from input signals. Guard bands are strips of unused bandwidth. In Frequency-division multiplexing (FDM), Channels can be separated by guard bands to prevent signals from overlapping.

2. WDM (Optical Signal)

   Wavelength Division Multiplexing: Create a multiple wavelength signal from input-specific wavelength signals. We use prism for WDM.

3. TDM (Digital Signal)

   1. Synchronous:

      1. The frame is a combination of time slots. In a frame, number of time slots is the number of input lines.

      2. Frame rate = input data rate

      3. Frame duration = 1 / Frame rate

      4. bitrate = number of input lines * frame rate

      5. To fill empty slots:

         1. Multilevel Multiplexing (100 + 100 → 200)

         2. Multi-slot multiplexing (200 → 100 + 100)

         3. Pulse stuffing ( 190 + 10 → 200)

      6. It uses framing bit as 0 or 1 for synchronization

      7. Interleaving: TDM can be visualized as two fast-rotating switches, one on the multiplexing side and the other on the demultiplexing side. On the multiplexing side, as the switch opens in front of a connection, that connection has the opportunity to send a unit onto the path. This process is called interleaving

   2. Statistical:

      1. It uses no-synchronization

      2. It only takes slots that are filled and inserts an address beside the time slot to identify which slot it is referred to.

      3. In peak time, data lines need to wait for overhead bits.

Spectrum Spreading for Preventing Interference and Spying:

1. FHSS (Frequency Hopping Spread Spectrum)

   It uses a hopping sequence to hop frequencies for transferring data in runtime.

   Hopping sequence: 100, 400, 300, 200

   Data: 100, 010, 011, 101

   

2. DSSS (Direct Sequence Spread Spectrum)

   The signal encoding scheme is Polar NRZ-L. ( bit 1 = -v, Bit 0 = +v)

   Sending data: 101

   Spreading code: 1011

   Spread code: 1011 0100 1011

Transmission Media

1. Guided Media

   1. Twisted pair:

      1. Ground and Signal

      2. Plastic Cover + Core = UTP, Plastic Cover + Metal + Core = STP

      3. Connected by RJ45

   2. Co-axial:

      1. Outer Layer + Insulator + Outer Conductor + Insulator + Inner Conductor

      2. Connected by BNC

   3. Optical Fibre:

      1. Outer Layer + Dupont Kevlar + Plastic Buffer + Cladding + Core

      2. ST or SC Connector

      3. Mode:

         

         1. Multimode:

            1. Step index:

               1. The density of the core is constant

               2. Cladding and core are made of the same material

            2. Graded index:

               1. The density of the center of the core is higher and decreases gradually to its lowest at the edge.

               2. Cladding and core are not made of the same material

         2. Single mode:

            1. The critical angle is almost up to 90

            2. The propagation of the beam is almost horizontal

Unguided Media:

1. Radiowave: (3 KHz - 1 GHz)

2. Microwave: (1 GHz - 300 GHz)

3. Infrared: (300 GHz - 400 THz)

Propagation of Radiowave:

1. Ground propagation:

   1. It used a very low-frequency band

   2. propagates below the lower point of the atmosphere

   3. distance depends on the power of the signal

2. Sky propagation:

   1. Works by reflecting in the ionosphere

   2. Greater distance traveled by lower output data

   3. Band: High, very high-frequency band

3. Line of sight:

   1. Antenna-to-antenna data transfer

   2. Band: UHF, EHF

   3. Used in satellite

Antenna:

1. Omnidirectional Antenna:

   1. One sender to many receivers

   2. Used by radio wave

2. Unidirectional / Parabolic Antenna:

   1. Send only to one direction

   2. Used by microwave signal

Infrared:

1. Line of sight propagation

2. No Antenna needed

3. Used for shorter distance

Introduction to Data-link Layer

Packet: frame, Address: link-layer address

Connection between: node

Nodes are connected with links. Links are 2 types:

1. point to point link (DLC sublayer)

2. broadcast link (MAC and DLC sublayers)

Services of Data-link layer:

1. Framing

2. Flow Control (Produced Frames > Consumed Frames)

3. Error Control

4. Congestion Control

Link layer Addressing: (48 bits / 6 bytes / 12 hexadecimal digits)

1. Unicast:

   Address: 23:53:29:61:07:F1

2. Multicast:

   Address: 24:54:28:62:08:F2

3. Broadcast:

   Address: FF:FF:FF:FF:FF:FF

ARP (Address Resolution Protocol):

ARP accepts an IP Address from Internet Protocol and maps the address to the link-layer address in the data-link layer.

ARP Packet format:

ARP Caching:

Broadcast Link → Store Destination’s link-layer address → Unicast Link

Types of error

1. single error, 2. burst error

Burst length = length (position of first error, position, last error)

There are 2 types of block coding:

1. Dataword, 2. Codeword

The hamming distance can be solved by XORing a two-bit string

Minimum Hamming distance = s + 1 where s = number of errors that can be solved.

CRC and Polynomials:

Checksum:

Forward Error Correction Methods:

1. Hamming Distance

2. XOR

3. Chunk interleaving

4. Chunk interleaving with Hamming Distance

5. Compounding high and low-resolution packet

Note: CRC is better than Checksum in correcting errors.

DLC (Data link Control) Protocols

Framing: 1. Bit oriented, 2. Character Oriented (byte-oriented)

Byte stuffing: When data has a flag-like byte, we add an ESC byte before it so that the receiver doesn’t end the frame while reading user information. It is used in Character oriented framing

Bit stuffing: The flag is 01111110; while reading user information, it replaces 01111110 with 011111010

Buffer: A buffer is a set of memory locations that can hold packets at the sender and receiver. When the buffer of the receiving data-link layer is full, it informs the sending data-link layer to stop pushing frames. It is used in flow control.

Error Control: This service is provided by a 2-4 byte CRC added to the frame header.

Services: 1. Framing, 2. Flow control, 3. Error Control

DLC protocols can be:

1. Connectionless oriented: Frames are unnumbered

2. Connection-oriented: Frames are unnumbered

Simple protocol:

Stop and wait Protocol:

Flow control is provided by sequence number (0,1,0,1,..) and acknowledge number (1,0,1,0,..)

Two states:

1. Ready State:

   1. Waiting for the packet from the network layer

   2. The sender creates a frame and sends it.

   3. The sender saves a copy of the frame

Blocking state:

1. If a timeout occurs, the sender resends the frame

2. If ACK is corrupted, the frame is discarded

3. else receiver sends error-free ACK to receive the next frame

Piggybacking:

Bi-directional protocol that is sophisticated and costly. The sender and receiver both can send signals and acknowledgment.

HDLC (High-Level Data Link Control Protocol):

Characteristics: 1. Bit oriented, 2. More theoretical than practical, 3. Use Stop and Wait Protocol, 4. Use point-to-point or multi-point links.

Transfer modes:

1. NRM (Normal Response Mode): (Point to point / Multi-point, Unbalanced, 1 Primary Station → Multi Secondary Stations)

2. ABM (Asynchronous Balanced Mode) (Point to point, Balance)

Framing of HDLC

Information Frame: (Used for transferring data)

Supervisory Frame: (Used for Flow and Error Control)

ACKs: RR (Receive Ready), RNR (Receive Not Ready), REJ (Reject), SREJ (Selective Reject)

Unnumbered Frame: (Used for connection establishment and release)

PPP (Point-to-Point Protocol)

Services: 1. Most used protocol, 2. Provide Authentication and network configuration, 3. Error Control.

PPP doesn’t provide flow control.

PPP Framing:

PPP has created two protocols for authentication: PAP (Password Authentication Protocol) and CHAP (Challenge Handshake Authentication Protocol). Internet Protocol Control Protocol (IPCP) is framed inside PPP framing for carrying IP data packets.

Transition phase of PPP:

MAC Protocols (Media Access Control)

1. Random Access Protocol:

   1. ALOHA (Advocates of Linux Open-source Hawaii Association): Radio LAN

   2. CSMA ( Carrier Sense Multiple Access): Ethernet

   3. CSMA / CD (Carrier Sense Multiple Access with Collision Detection): Traditional Ethernet of 10 Mbps data rate

   4. CSMA / CA (Carrier Sense Multiple Access with Collision Avoidance): Wireless Network

2. Control Access Protocol:

   1. Reservation: Device needs reservation before sending data

   2. Polling: One device is the primary station, and others are the secondary station

   3. Token Passing: Networks are organized in a logical ring, and all stations are either predecessors or successors.

3. Channelization:

   1. FDMA (Frequency Division Multiple Access): The bandwidth of the common channel is divided into bands that are separated by guard bands.

   2. TDMA (Time Division Multiple Access): Stations share timeslots.

   3. CDMA (Code Division Multiple Access): All data are sent by one channel with different codes.

Abbreviations:

1. ARPANET: Advanced Research Projects Agency Network

2. TCP: Transmission Control Protocol

3. IP: Internet Protocol

4. ISOC: Internet Society

5. IAB: Internet Architecture Board

6. ASCII: American Standard Code for Information Interchange

7. ISO: Internation Organization for Standardization

8. OSI: Open Systems Interconnection

1. Shortest path in a Directed Acyclic Graph (DAG) using topological sorting

2. The Dijkstra algorithm

3. The Bellman-Ford algorithm

Relax Function (Edge Relaxation): (IMPORTANT)

In graph algorithms, particularly shortest path algorithms like Dijkstra's and the Bellman-Ford algorithm, the "Relaxation" process, also known as "Node Relaxation," is a crucial step that helps in finding the shortest paths efficiently.

Relaxation involves optimizing the current known distance to a node by potentially replacing it with a shorter distance. The process compares the distance of a potential path through a neighboring node to the currently known shortest path to the destination node. If the potential path is indeed shorter, the distance of the destination node is updated, and this action is referred to as "relaxing" the edge or the node.

Consider a graph where you are trying to find the shortest distance from a source node to other nodes. During relaxation, if you find a path that is shorter than the currently known path, you update the distance of the destination node with this shorter distance. This process iterates through all the nodes in the graph, ensuring that the distances are accurately updated based on the shortest paths discovered so far.
Algorithm:

relax(i,j,distance[], weight[][]):
if distance[i] + weight[i][j] < distance[j]:
   distance [j] = distance[i] + weight[i][j]
   predecessor [j] = i
end if

Shortest path in a DAG using topological sorting

When dealing with a Directed Acyclic Graph (DAG), a graph without any cycles, we can find the shortest path from a single source node to all other nodes using a combination of topological sorting and edge relaxation. The key insight is that we process nodes in topological order, calculating the shortest distance to each node based on the distances to its incoming neighbors.

0. single_source_shortest_path_dag (source, topolist, weight, adj):
1. for each vertex i in topolist:
2.     distance [i] = INFINITY
3.     predecessor [i] = NULL
4. end for
5. distance[source] = 0
6. for each vertex i in topolist:
7.     for each adjacent vertex j in adj[i]:
8.         relax(i,j,distance,weight)
9.     end for
10. end for
// Now using the distance and predecessor 
// we can measure distance from the single source 
// and track the path from source to destination

To make a graph topologically sorted, we have used below algorithm:

0. toposort(u):
1. visited[u] = true
2. for all the adjacency vertex i of adj[u]:
3.     if visited [i] is not true
4.         toposort(i)
5.     end if
6. end for
5. insert u in a linkedlist 'topolist' from front

Example:
The source node is r and explores all shortest paths from the source node. Show the tabular passing.

Answer: Tabular passing is given below in the chart,
where distance/pi = cost to reach the node from source node/predecessor's node

Now, we need to find paths from the source node to other nodes:

r to s: 5 (r -> s)
r to t: 3 (r -> t)
r to x: 10 (r -> t -> x)
r to y: 7 (r -> t -> y)
r to z: 5 (r -> t -> z)

Dijkstra Algorithm

Dijkstra is useful for cyclic non-negative edge graphs where we must find all the shortest paths from a single source node. The algorithm maintains a set of explored nodes and continually updates the shortest distance from the source node to each node in the graph.

Here's the step-by-step description of Dijkstra's algorithm:

Input:

• graph: The graph is represented as an adjacency list or matrix.

• source: The starting node from which to find the shortest paths.

Output:

• An array distances where distances[i] represents the shortest distance from the source node to the node i.

• An array prev where prev[i] represents the previous node on the shortest path from the source node to the node i.

• Note: To reconstruct the shortest paths themselves, you can use the prev array.

Algorithm:

1. Initialize an array distances with the shortest distance from the source node to each node. Set distances[source] to 0 and all other distances to infinity.

2. Initialize a priority queue or a min-heap pq to store nodes and their tentative distances. Add the source node with a distance of 0 to pq.

3. Initialize an array prev to store the previous node on the shortest path for each node.

4. While pq is not empty: a. Extract the node u with the smallest distance from pq. b. For each neighbor v of u:

   • Calculate a tentative distance new_distance from the source to v through u. It is the sum of the distance from the source to u and the weight of the edge from u to v.

   • If new_distance is less than the current distance stored in distances[v], update distances[v] with new_distance and set prev[v] to u.

   • Add node v to pq with its updated distance.

5. Once the algorithm finishes, the distances array will contain the shortest distances from the source node to all other nodes and the prev array will allow you to reconstruct the shortest paths.

dijkstra(source, adj):
    distances.assign(N, INF)
    prev.assign(N, -1)
    distances[source] = 0
    prev[source] = source
    pq.push({distances[source], source})
    while pq is not empty:
        u = pq.top().first
        u.pop()
        for all neighbour node v of adj[u]:
            if (distances[u] + weight[u][v] < distances[v]):
                distances[v] = distances[u] + weight[u][v]
                prev[v] = u
                pq.push({distances[v], v})
            end if
        end for
    end while

Example:
The source node is s and explores all shortest paths from the source node. Show the tabular passing.

Answer: Tabular passing is given below in the chart,
where distance/pi = cost to reach the node from source node/predecessor's node

Now, we need to find paths from the source node to other nodes:

s to a: 8 (s -> c -> a)
s to b: 9 (s -> c -> a -> b)
s to c: 5 ( s-> c)
s to d: 7 (s -> c -> d)

Bellman-Ford Algorithm

The Bellman-Ford algorithm finds the shortest paths from a single source vertex to all other vertices in a weighted, directed graph. It can handle graphs with negative weight edges and detect the presence of negative weight cycles. This algorithm is named after Richard Bellman and Lester Ford. This algorithm is one of the easiest to find a single source shortest path.

Here's an overview of how the Bellman-Ford algorithm works:

1. Initialize an array to store the minimum distance from the source vertex to each vertex in the graph. Initially, set the distance to infinity for all vertices except the source, which is set to zero.

2. Iterate over all edges in the graph repeatedly for a number of times equal to the number of vertices minus one. In each iteration, update the minimum distance to each vertex by considering all possible paths through other vertices.

$$Total\space number\space of \space iteration = Number \space of \space vertex-1$$

1. After the iteration is complete, check for negative weight cycles. If any vertex's distance can still be improved in one more iteration, it means there is a negative weight cycle in the graph.

2. If no negative weight cycles are detected, the minimum distances from the source vertex to all other vertices have been computed.

#include <bits/stdc++.h>
using namespace std;

struct Edge {
    int source, destination, weight;
};

void BellmanFord(vector<Edge>& edges, int V, int source) {
    vector<int> distance(V, INT_MAX);
    distance[source] = 0;

    for (int i = 0; i < V - 1; i++) {
        for (const Edge& edge : edges) {
            int u = edge.source;
            int v = edge.destination;
            int w = edge.weight;

            if (distance[u] != INT_MAX && distance[u] + w < distance[v]) {
                distance[v] = distance[u] + w;
            }
        }
    }

    // Check for negative weight cycles
    for (const Edge& edge : edges) {
        int u = edge.source;
        int v = edge.destination;
        int w = edge.weight;

        if (distance[u] != INT_MAX && distance[u] + w < distance[v]) {
            cout << "Graph contains a negative weight cycle!" << endl;
            return;
        }
    }

    // Print the shortest distances from the source vertex
    cout << "Shortest distances from source vertex " << source << ":" << endl;
    for (int i = 0; i < V; i++) {
        cout << "Vertex " << i << ": " << distance[i] << endl;
    }
}

int main() {
    int V, E;
    cout << "Enter the number of vertices and edges: ";
    cin >> V >> E;

    vector<Edge> edges(E);

    cout << "Enter source, destination, and weight for each edge:" << endl;
    for (int i = 0; i < E; i++) {
        cin >> edges[i].source >> edges[i].destination >> edges[i].weight;
    }

    int source;
    cout << "Enter the source vertex: ";
    cin >> source;

    BellmanFord(edges, V, source);

    return 0;
}

Example:
The source node is s and explores all shortest paths from the source node. Show the manual passing. (DO IT BY YOURSELF)

Answer: Passing is given below:
Initial distances:
s = 0
a = Infinity
b = Infinity
c = Infinity
d = Infinity

Edge list:

1. (a, b) = 5
2. (a, c) = 8
3. (a, d) = -4
4. (b, a) = -2
5. (c, b) = -3
6. (c, d) = 9
7. (d, s) = 2
8. (d, b) = 7
9. (s, a) = 6
10. (s,c) = 7

Iteration 1:
Relax edges (s, a) and (s, c).
s = 0
a = 6
b = Infinity
c = 7
d = Infinity

Iteration 2:
Relax edges (a, b), (a, d), and (c, b).
s = 0
a = 6
b = 4
c = 7
d = 2

Iteration 3:
Relax edges (b, a).
s = 0
a = 2
b = 4
c = 7
d = 2

Iteration 4:
Relax edges (a, d).
s = 0
a = 2
b = 4
c = 7
d = -2

Iteration 5:
No relaxes in edge list so it has no negative cycle.
s = 0
a = 2
b = 4
c = 7
d = -2
Note: We can store the predecessor value on edge relaxing updates to get the path.

Here is a table summarizing the differences between DAG shortest path algorithms using topological sort, Dijkstra, and Bellman-Ford:

Thank you for reading the article.

TARGET AUDIENCE
Ongoing students Of Ahsanullah University of Science and Technology, Bangladesh. Only AUST students can explore features signing with their edu mail provided by aust.edu

ANDROID VERSION
Android 6.0 Marshmallow (API level 23) or higher.

FEATURE LIST

SCREENSHOTS

APP LINK

https://github.com/anwholesquare/aust_open_android/blob/main/app-debug.apk

PRESENTATION

The new update is coming soon for both Android and iOS using Flutter.

DOWNLOAD EMU8086
https://emu8086-microprocessor-emulator.en.softonic.com/

TOPICS WE WILL REVIEW

1. Registers,

2. Template

3. I/O,

4. Operations,

5. Conditions,

6. Loop,

7. Array,

8. Stack

1. REGISTERS

   The 8086 microprocessor, part of the x86 family of processors, has a set of registers that play a crucial role in its operation. These registers store data, addresses, and intermediate results during the execution of instructions. The 8086 assembler registers can be categorized into various types based on their functionality:

   1. General Purpose Registers:

      • AX (Accumulator): This 16-bit register is used for arithmetic and logical operations. It's often used in conjunction with other registers for more complex operations.

      • BX (Base): Another 16-bit register that can be used to address memory or as a general-purpose register.

      • CX (Count): Often used as a loop counter in string and loop instructions. It can also be used for arithmetic operations.

      • DX (Data): This register is used for I/O operations and extended precision arithmetic.

   2. Segment Registers:

      • CS (Code Segment): Points to the start of the code segment in memory.

      • DS (Data Segment): Points to the start of the data segment, where variables and data are stored.

      • SS (Stack Segment): Points to the stack segment, which is used for storing temporary data during function calls and other operations.

      • ES (Extra Segment): An additional segment register that can be used to point to another data segment.

   3. Pointer Registers:

      • SP (Stack Pointer): Points to the top of the stack in the stack segment.

      • BP (Base Pointer): Often used to access parameters passed to functions and local variables within stack frames.

      • SI (Source Index): Used as an index for string operations.

      • DI (Destination Index): Similar to SI, but used as an index for destination data in string operations.

   4. Index Registers:

      • IP (Instruction Pointer): Points to the next instruction to be executed in the code segment.

      • Flags Register (FLAGS): Contains various flag bits that reflect the status of previous arithmetic and logic operations. These flags are used for conditional branching.

2. Template

    .MODEL SMALL
    .STACK 100H
   
    .DATA
    ; ALL DATA MUST BE HERE EXCEPT REGISTERS
    ; DB = DEFINE BYTE | DW = DEFINE WORD 
    MSG DB 'HELLO WORLD $'
   
    .CODE
    MAIN PROC
         ; IT IS A COMMENT
   
         MAIN ENDP
    END MAIN
   

3. I/O

   1. Print "Hello World":

       .MODEL SMALL
       .STACK 100H
      
       .DATA
       MSG DB 'HELLO WORLD $'
      
       .CODE
       MAIN PROC
            MOV AX, @DATA
            MOV DS, AX
      
            MOV AH, 
            LEA DX, MSG
            INT 21H
      
            MAIN ENDP
       END
      

   2. Read a character and print the character in a new line:

       .MODEL SMALL
       .STACK 100H
      
       .CODE
       MAIN PROC
           ; Display a character prompt and read a character from the keyboard
           MOV AH, 1       ; Set AH to 1 to indicate "Read Character" function
           INT 21H         ; Call the DOS interrupt to read a character from standard input
      
           MOV BL, AL      ; Store the input character in BL register
      
           ; Display newline character (LF)
           MOV AH, 2       ; Set AH to 2 to indicate "Display Character" function
           MOV DL, 10      ; Set DL to ASCII code 10 (newline character)
           INT 21H         ; Call the DOS interrupt to display the newline character
      
           ; Display carriage return character (CR)
           MOV AH, 2       ; Set AH to 2 again
           MOV DL, 13      ; Set DL to ASCII code 13 (carriage return character)
           INT 21H         ; Call the DOS interrupt to display the carriage return character
      
           ; Display the stored character in BL
           MOV AH, 2       ; Set AH to 2 again
           MOV DL, BL      ; Set DL to the value stored in BL (the input character)
           INT 21H         ; Call the DOS interrupt to display the character
      
           MAIN ENDP
       END
      

4. Operations

    1. SUM:
    ADD AX, BX; AX = AX + BX
   
    2. SUBSTRACT:
    SUB AX, BX; AX = AX - BX
   
    3. MULTIPLY:
    MOV AX, -4
    IMUL BX; AX * BX
   
    4. DIVISION:
    MOV AL, NUM_3 
    MOV BL, 3 
    IDIV BL; AL / BL
   
    5. LOGICAL SHIFT:
   
    ROL AX, 1; ROTATE LEFT FOR THE VALUE OF AX REGISTER
    ROR AX, 1; ROTATE RIGHT FOR THE VALUE OF AX REGISTER
    SHL AX, 1; SHIFT LEFT FOR THE VALUE OF AX REGISTER
    SRL AX, 1; SHIFT RIGHT FOR THE VALUE OF AX REGISTER
   
    6. LOGICAL OPERATION:
   
    AND AX, BX
    OR AX, BX
    NOT AX
    XOR AX, BX
   

5. Conditions

   1. Read two decimal digits and print the largest digit:

    .MODEL SMALL
    .STACK 100H

    .DATA
    FIRST DB 'FIRST INPUT: $'
    SECOND DB 'SECOND INPUT: $'

    .CODE
    MAIN PROC     
         ; Initialize DS register with the address of the data segment
         MOV AX, @DATA
         MOV DS, AX

         ; Display "FIRST INPUT: " prompt
         MOV AH, 9
         LEA DX, FIRST
         INT 21H

         ; Read a character from the keyboard
         MOV AH, 1
         INT 21H

         ; Store the input character in BL register
         MOV BL, AL 

         ; Display newline character
         MOV AH, 2
         MOV DL, 10
         INT 21H

         ; Display carriage return character
         MOV AH, 2
         MOV DL, 13
         INT 21H 

         ; Display "SECOND INPUT: " prompt
         MOV AH, 9
         LEA DX, SECOND
         INT 21H

         ; Read another character from the keyboard
         MOV AH, 1
         INT 21H

         ; Store the input character in BH register
         MOV BH, AL 

         ; Display newline character
         MOV AH, 2
         MOV DL, 10
         INT 21H

         ; Display carriage return character
         MOV AH, 2
         MOV DL, 13
         INT 21H

         ; Compare BH and BL, and set DL to the larger of the two
         MOV DL, BH
         CMP BH, BL
         JG PRINT  
         MOV DL, BL


    PRINT:
         ; Display the value stored in DL (larger of BH and BL)
         MOV AH, 2
         INT 21H


         MAIN ENDP
    END

More Jump Instructions
1. JC: Stands for 'Jump if Carry'

2. JNC: Stands for 'Jump if Not Carry'

3. JE / JZ: Stands for 'Jump if Equal' or 'Jump if Zero'

4. JNE / JNZ: Stands for 'Jump if Not Equal' or 'Jump if Not Zero'

5. JP / JPE: Stands for 'Jump if Parity' or 'Jump if Even Parity'

6. JNP / JPO: Stands for 'Jump if Not Parity' or 'Jump if Odd Parity'

Note: For multi-conditions, we may need to use unconditional jump condition which is JMP

1. LOOP

   1. Print “HELLO WORLD” 10 times:

    .MODEL SMALL
    .STACK 100H

    .DATA
    MSG DB 'HELLO WORLD $'  ; Define a null-terminated string message
    NEWLINE DB 13,10, '$'   ; Define a newline sequence (carriage return + line feed)

    .CODE
    MAIN PROC 
        ; Initialize DS register with the address of the data segment
        MOV AX, @DATA
        MOV DS, AX     

        MOV CX, 10       ; Set CX to the number of times to repeat the printing

    PRINT:
        ; Display the message
        MOV AH, 9        ; Set AH to 9 to indicate "Display String" function
        LEA DX, MSG      ; Load the address of MSG into DX
        INT 21H          ; Call the DOS interrupt to display the message

        ; Display a newline
        MOV AH, 9        ; Set AH to 9 again
        LEA DX, NEWLINE  ; Load the address of NEWLINE into DX
        INT 21H          ; Call the DOS interrupt to display the newline

        LOOP PRINT       ; Decrement CX and repeat the loop if CX is not zero

    MAIN ENDP
    END

1. Array

   1. Read 10 numbers and find the average of the sum:

       .MODEL SMALL
       .STACK 100H
      
       .DATA
           numbers DB 10 DUP (?)  ; Array to store 10 numbers
           prompt DB 'Enter a number: $'
           newline DB 13, 10, '$'
           avgMsg DB 'Average: $'
      
       .CODE
       MAIN PROC 
           ; Initialize DS register with the address of the data segment
           MOV AX, @DATA
           MOV DS, AX
      
           ; Initialize variables
           MOV CX, 10          ; Set CX to the number of elements
           MOV SI, 0           ; Initialize index for array traversal
           MOV BX, 0           ; Initialize sum
      
       INPUT_LOOP:
           ; Display prompt
           MOV AH, 9
           LEA DX, prompt
           INT 21H
      
           ; Read a number
           MOV AH, 1
           INT 21H
           SUB AL, '0'         ; Convert ASCII character to numerical value
           MOV numbers[SI], AL ; Store the number in the array at index SI
      
           INC SI              ; Move to the next index in the array
      
           LOOP INPUT_LOOP
      
           ; Calculate the sum of the numbers
           MOV CX, 10          ; Reset CX for sum calculation
           MOV SI, 0           ; Reset index for array traversal
           MOV BX, 0           ; Reset sum
      
       SUM_LOOP:
           ADD BL, numbers[SI]
           INC SI
           LOOP SUM_LOOP
      
           ; Calculate the average
           MOV AL, BL
           MOV BL, 10
           DIV BL              ; AL = Sum / 10
      
           ; Display the average
           MOV AH, 9
           LEA DX, avgMsg
           INT 21H
      
           MOV AH, 2
           ADD AL, '0'
           INT 21H
      
           ; Display a newline
           MOV AH, 9
           LEA DX, newline
           INT 21H
      
           ; Exit program
           MOV AH, 4CH
           INT 21H
      
       MAIN ENDP
       END
      

2. STACK

   

   1. Balanced Bracket Problem using PUSH and POP in 8086 assembler:

.MODEL SMALL
.STACK 100H

.DATA
    expression DB '(a + [b * {c + d}] - e) $'

.CODE
MAIN PROC
    ; Initialize DS register with the address of the data segment
    MOV AX, @DATA
    MOV DS, AX

    ; Initialize stack pointer
    MOV SP, 100H

    LEA SI, expression

CHECK_LOOP:
    MOV AL, [SI]
    CMP AL, '$'         ; Check for end of expression
    JE EXPRESSION_END

    CMP AL, '('         ; Opening parenthesis
    JE PUSH_STACK
    CMP AL, '['         ; Opening square bracket
    JE PUSH_STACK
    CMP AL, '{'         ; Opening curly brace
    JE PUSH_STACK

    CMP AL, ')'         ; Closing parenthesis
    JE POP_STACK
    CMP AL, ']'         ; Closing square bracket
    JE POP_STACK
    CMP AL, '}'         ; Closing curly brace
    JE POP_STACK

    INC SI              ; Move to the next character
    JMP CHECK_LOOP

PUSH_STACK:
    PUSH AL             ; Push opening bracket onto the stack
    INC SI              ; Move to the next character
    JMP CHECK_LOOP

POP_STACK:
    MOV AH, [SP]        ; Pop bracket from the stack
    CMP AL, '('         ; Matching parenthesis
    JE POP_STACK_DONE
    CMP AL, '['         ; Matching square bracket
    JE POP_STACK_DONE
    CMP AL, '{'         ; Matching curly brace
    JE POP_STACK_DONE

    ; Unmatched brackets, display error message and exit
    MOV AH, 9
    LEA DX, UNMATCHED_MSG
    INT 21H

    ; Exit program
    MOV AH, 4CH
    INT 21H

POP_STACK_DONE:
    ADD SP, 1           ; Pop one element from the stack
    INC SI              ; Move to the next character
    JMP CHECK_LOOP

EXPRESSION_END:
    ; Display balanced expression message
    MOV AH, 9
    LEA DX, BALANCED_MSG
    INT 21H

    ; Exit program
    MOV AH, 4CH
    INT 21H

.DATA
    UNMATCHED_MSG DB 'Unmatched brackets in expression', '$'
    BALANCED_MSG DB 'Expression is balanced', '$'

MAIN ENDP
END

To be Continued ...

Unlock a new card every day

Daily Sigma provides users with a structured and rewarding experience by presenting a new card to unlock daily. These 101 cards are carefully curated to offer valuable insights, challenges, and tasks to help users build positive habits, strengthen discipline, optimize their workouts, cultivate a growth mindset, and manage their cash flow effectively.

This app uses the Google mobile application's Flutter framework. The dependencies used in this project are given below:

flutter_screenutil: ^5.3.1
flutter_svg: ^0.23.0+1
font_awesome_flutter: ^[latest_version]
get: ^4.3.8
google_fonts: ^2.1.0
cupertino_icons: ^1.0.5

Comprehensive Life Disciplines

Daily Sigma covers various life disciplines to ensure holistic personal growth. From developing healthy habits and time management techniques to effective financial planning and mental resilience strategies, the app provides valuable insights and actionable steps to help users thrive in every aspect of their lives.

Inspiring Feed for Inner Growth

In addition to the card system, Daily Sigma offers a dynamic feed filled with relatable and uplifting posts. Discover thought-provoking articles, inspiring success stories, expert advice, and motivational quotes carefully curated to nourish your inner self. Engage with a vibrant community of like-minded individuals who share your passion for personal growth and exchange insights and experiences.

Customize Your Experience

Tailor Daily Sigma to your unique needs and preferences. Choose from various themes, set reminders, and personalize your daily card challenges. Whether an early riser or a night owl, the app adapts to your lifestyle, ensuring you can engage with the content at your own pace.

This app will be published by excess3.com, a unique IT firm that works on mobile and web development, brand guidelines, and AR/VR.

If you have any queries, email me at khandokeranan@gmail.com.

In this article, we will learn about Flutter state management with getX which is a powerful state management library for building applications using the Flutter framework. It offers a simple and intuitive way to manage the state of your application, making it easier to develop and maintain complex UIs. Except for handling states within the app, here are some of the key functionalities and features that GetX offers:

1. Dependency injection

2. Route management

3. Dialog and snackbar

4. Multi-language support

5. Animation management

6. Worker management

Let's create a flutter boilerplate using this command:

flutter create --org com.yourcompanyname -i swift -a kotlin appname

Now we need to install two GetX components by adding these lines in

pubspec.yaml

dependencies:
  flutter:
    sdk: flutter
  #add these lines
  get: ^4.6.1
  get_storage: ^2.0.3

Let's make an app where we can change a text based on TextField input and toggle the app theme by ElavatedButton.

To do this, we need two GetXControllers where we will initialize our observable variables and functions that can update the widget. They are AppController and ThemeController.

AppController.dart

import 'package:get/get.dart';

class AppController extends GetxController {
  var appName = "GetX Flutter".obs;

  void setAppName (String _appName) {
    appName.value = _appName;
  }
}

Using this AppController class which extends GetxController, we will observe the value of the app name.

ThemeController.dart

import 'package:get/get.dart';
import 'package:get_storage/get_storage.dart';
import 'package:flutter/material.dart';

class ThemeController extends GetxController {
    final _box = GetStorage();
    final themeModeKey = "isDarkMode";
    bool _loadTheme() => _box.read(themeModeKey) ?? false;

    ThemeData darkTheme = ThemeData(
      primarySwatch: Colors.red,
      brightness: Brightness.dark
    );

    ThemeData lightTheme = ThemeData(
      primarySwatch: Colors.red,
      brightness: Brightness.light
    );

    ThemeData get theme => _loadTheme() ? darkTheme : lightTheme;

    void toggleTheme () {
      _box.write(themeModeKey, !_loadTheme());
      Get.changeTheme(theme);
    }
}

In ThemeController.dart, we use GetStorage Library to persist the theme each time running the app on the mobile. By default, the theme will get the value of light theme as no data can be loaded as a theme from the _box or GetStorage. toggleTheme() is used to toggle the theme and save it in the _box.

main.dart

import 'package:flutter/material.dart';
import 'package:flutter_get_x/Controller/AppController.dart';
import 'package:flutter_get_x/Controller/ThemeController.dart';
import 'package:flutter_get_x/HomePage.dart';
import 'package:get/get.dart';

void main() async {
  await GetStorage.init();
  runApp(MyApp());
}

class MyApp extends StatelessWidget {

  final AppController appController = Get.put(AppController());
  final ThemeController themeController = Get.put(ThemeController());
  MyApp({super.key});

  @override
  Widget build(BuildContext context) {
    return GetMaterialApp(
      home: HomePage(),
      debugShowCheckedModeBanner: false,
      theme: themeController.theme,
    );
  }
}

Here we use GetMaterialApp as the root of widget tree which is similar to MaterialApp and we put the controller using Get.put() method to find those two controllers by Get.find<ControllerName>() method within the child widgets of the tree. Inside main() async, await GetStorage.init(); this line is important to initialize the GetStorage();

Now lastly add the HomePage class to render the initial widget of MaterialApp.

HomePage.dart

import 'package:flutter/material.dart';
import 'package:flutter_get_x/Controller/AppController.dart';
import 'package:flutter_get_x/Controller/ThemeController.dart';
import 'package:get/get.dart';

class HomePage extends StatelessWidget {
  final AppController appController = Get.find<AppController>();
  final ThemeController themeController = Get.find<ThemeController>();
  TextEditingController appNameController = TextEditingController(); 
  HomePage({super.key});

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      body: SafeArea(
        child: Obx( () =>   
           Center(child: Column(
            mainAxisAlignment: MainAxisAlignment.center,
            children: [  
              Padding(
                padding: const EdgeInsets.all(8.0),
                child: Text(appController.appName.value, style: const TextStyle(fontSize: 24, fontWeight: FontWeight.w600),),
              ),    
              SizedBox(
                width: 200,
                child: TextField(
                  controller: appNameController,
                  textAlign: TextAlign.center,
                  decoration: const InputDecoration(hintText: "Write App Name",),
                )
              ),
              const SizedBox(height: 10,),
              Row(
                mainAxisAlignment: MainAxisAlignment.center,
                children: [
                  ElevatedButton(onPressed: ()=> 
                    appController.setAppName(appNameController.text)
                  , child: const Text("Submit")),
                  const SizedBox(width: 10,),
                  ElevatedButton(onPressed: ()=> 
                    themeController.toggleTheme()
                  ,
                  style: ElevatedButton.styleFrom(backgroundColor: Colors.black), child: const Text("Toggle Theme"),
                  ),
                ],
              )      
            ],
           ))
        )
      ),
    );
  }
}

In the HomePage class, We use Obx( () => WidgetClass() ) to render the widget frequently when an update is available by the controller classes' observable variables.

Now this app looks like this.

In summary, we need to make a controller to observe variables (adding .obx at the end of the value) that update the widgets inside the Obx widget. And GetStorage() can read and write the data for persistence. All of these works have been done in this GitHub repository.

Checkout till this point: git checkout d6b63d2036b6c6fa178f114a3ca5ed5b198e94dc

Now your task is to add a few features to the app using GetX and GetStorage:

1. Login system based on email and password,

2. Change password page

3. Logout option

To do this task, there are a few more things to learn.

1.   Get.to( () => NewPage() );
     // this code is used to go to the new Page 
     // and leave the current page in a stack.
   

2.   Get.off(() => NewPage());
     // this code is used to go to the new Page 
     // and remove the current page from the stack.
   

3.   Get.offAll( () => NewPage());
     // this code is used to go to the new Page 
     // and clear the stack
   

4.   // add this importation for the persistance
     import 'package:get_storage/get_storage.dart';
   
     void main() async{
       // to work after restarting the app, we need to add this line
       await GetStorage.init();
       runApp(MyApp());
     }
     // to write to the storage via key-value pair
     GetStorage().write("email", "khandokerxyz@gmail.com");
     // to read from the storage via key
     GetStorage().read("email");
   

   To use GetX SnackBar, you can use this snippet:

5.  Get.snackbar("Flutter with GetX", "Logging out from the device", snackPosition: SnackPosition.BOTTOM);
   

   If you're stuck on this task, you can see how it has been done:

6.   git clone https://github.com/anwholesquare/flutter_get_x.git
     git checkout 0f42abc84d33f2268c9e58eb282d2daad8b2ff7e
   

   The outcome of the task may seem like this video:

7. https://www.youtube.com/watch?v=aNNVR2fYVCs

Layouts

There are many layouts where you can add components to it. They are:

1. Relative Layout

The Android Relative Layout is a type of layout manager in Android that allows you to position views relative to each other or the parent container. It enables you to define the position of child views based on their relationship to other views, such as aligning them to the left, right, top, bottom, or center and specifying their margin.

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="I'm the parent"
        android:id="@+id/mainBtn"
        android:gravity="center"
        android:layout_margin="10dp"
        android:layout_centerHorizontal="true"
        android:layout_centerVertical="true"
    />

    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Baccha Down Left"
        android:layout_marginLeft="20dp"
        android:id="@+id/leftMainBtn"
        android:gravity="center"
        android:layout_toLeftOf="@+id/mainBtn"
        android:layout_below="@+id/mainBtn"/>

    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Baccha Down Right"
        android:layout_marginRight="20dp"
        android:id="@+id/RightMainBtn"
        android:gravity="center"
        android:layout_toRightOf="@+id/mainBtn"
        android:layout_below="@+id/mainBtn"/>

    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Baccha Up Left"
        android:layout_marginLeft="20dp"
        android:id="@+id/leftMainBtn1"
        android:gravity="center"
        android:layout_toLeftOf="@+id/mainBtn"
        android:layout_above="@+id/mainBtn"/>

    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Baccha Up Right"
        android:layout_marginRight="20dp"
        android:id="@+id/RightMainBtn1"
        android:gravity="center"
        android:layout_toRightOf="@+id/mainBtn"
        android:layout_above="@+id/mainBtn"/>

</RelativeLayout>

Here are some common use cases:

1. User Interfaces with Flexible Positioning: You can position views relative to each other, making it easier to adapt to different screen sizes or orientations.

2. Form-Based Screens: Relative Layout is well-suited for forms or input screens where you need to align labels and input fields in a specific manner.

3. Custom List Items: If you are creating a custom listview or a recycler view, Relative Layout can define the layout of individual list items.

4. Toolbars and Action Bars: You can position the title, action buttons, and other components relative to each other, allowing you to create a consistent and organized layout for your app's navigation and actions.

5. Overlapping Views: Relative Layout enables you to create views that overlap each other, which can be useful for creating effects like pop-up windows, tooltips, or overlay screens.

1. Linear Layout

The Linear Layout is a type of layout manager in Android that arranges child views in a single direction, either horizontally or vertically. It provides a straightforward and flexible way to create user interfaces by linearly aligning views one after another.

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:layout_margin="10dp"
    android:layout_height="match_parent">




    <LinearLayout android:orientation="horizontal"
        android:layout_width="match_parent"
        android:gravity="center"
        android:layout_height="wrap_content">

        <Button
            android:layout_width="75dp"
            android:textSize="32sp"
            android:layout_height="80dp"
            android:layout_margin="5dp"
            android:text="1"/>

        <Button
            android:layout_width="75dp"
            android:layout_height="80dp"
            android:textSize="32sp"
            android:layout_margin="5dp"
            android:text="2"/>

        <Button
            android:layout_width="75dp"
            android:layout_height="80dp"
            android:textSize="32sp"
            android:layout_margin="5dp"
            android:text="3"/>

        <Button
            android:layout_width="75dp"
            android:layout_height="80dp"
            android:textSize="32sp"
            android:layout_margin="5dp"
            android:text="4"/>

    </LinearLayout>


    <LinearLayout android:orientation="horizontal"
        android:layout_width="match_parent"
        android:gravity="center"
        android:layout_height="wrap_content">

        <Button
            android:layout_width="160dp"
            android:layout_height="80dp"
            android:textSize="32sp"
            android:layout_margin="5dp"
            android:text="5"/>

        <Button
            android:layout_width="75dp"
            android:layout_height="80dp"
            android:textSize="32sp"
            android:layout_margin="5dp"
            android:text="6"/>

        <Button
            android:layout_width="75dp"
            android:layout_height="80dp"
            android:layout_margin="5dp"
            android:textSize="32sp"
            android:text="7"/>


    </LinearLayout>


    <LinearLayout android:orientation="horizontal"
        android:layout_width="match_parent"
        android:gravity="center"
        android:layout_height="wrap_content">

        <Button
            android:layout_width="75dp"
            android:layout_height="80dp"
            android:textSize="32sp"
            android:layout_margin="5dp"
            android:text="8"/>

        <Button
            android:layout_width="160dp"
            android:layout_height="80dp"
            android:textSize="32sp"
            android:layout_margin="5dp"
            android:text="9"/>

        <Button
            android:layout_width="75dp"
            android:layout_height="80dp"
            android:layout_margin="5dp"
            android:textSize="32sp"
            android:text="10"/>


    </LinearLayout>


    <LinearLayout android:orientation="horizontal"
        android:layout_width="match_parent"
        android:gravity="center"
        android:layout_height="wrap_content">

        <Button
            android:layout_width="75dp"
            android:layout_height="80dp"
            android:textSize="32sp"
            android:layout_margin="5dp"
            android:text="11"/>

        <Button
            android:layout_width="75dp"
            android:layout_height="80dp"
            android:textSize="32sp"
            android:layout_margin="5dp"
            android:text="12"/>

        <Button
            android:layout_width="160dp"
            android:layout_height="80dp"
            android:layout_margin="5dp"
            android:textSize="32sp"
            android:text="13"/>


    </LinearLayout>


    <LinearLayout android:orientation="horizontal"
        android:layout_width="match_parent"
        android:gravity="center"
        android:layout_height="wrap_content">


        <Button
            android:layout_width="330dp"
            android:layout_height="80dp"
            android:layout_margin="5dp"
            android:textSize="32sp"
            android:text="SUBMIT"/>


    </LinearLayout>
</LinearLayout>

Here are some use cases of Linear Layout:

1. Lists and RecyclerView Items: Linear Layout is commonly used to create lists or RecyclerView items in Android applications.

2. Forms and Input Screens: Linear Layout is useful for creating forms or input screens where you must organize various input fields, labels, or buttons in a linear order.

3. Chat Bubbles: You can achieve a linear representation of messages in a conversation by aligning views horizontally or vertically within each chat bubble.

4. Navigation Bars: Linear Layout can create navigation bars at the bottom or top of the screen. By arranging icons or buttons horizontally within the linear layout, you can provide easy navigation options for users.

5. Sliders and Seek Bars: Linear Layout is suitable for creating sliders or seek bars that allow users to select a value within a range.

6. Media Players: Linear Layout can create media player controls, such as play/pause buttons, progress bars, and volume controls.

1. Bubble Sort

2. Quick Sort

3. Merge Sort

4. Insertion Sort

5. Selection Sort

Let's quickly review the algorithm one by one below:

Bubble Sort

The idea is to place the largest/minimal element in its position and keep doing the same for every other element.

Code:

void bubble () {
    int n = v.size();
    for (int i = 0; i<n; i++) {
        for (int j =0; j<n; j++) {
            if (v[i] < v[j]) 
                swap(v[i], v[j]);
        }
    }
}

Selection Sort

Code:

void selection () {
    int n = v.size();
    for (int i = 0; i<n; i++) {
        for (int j =i+1; j<n; j++) {
            if (v[i] > v[j]) 
                swap(v[i], v[j]);
        }
    }
}

Insertion Sort

Code:

void insertion () {
    int n = v.size();
    for(int i=1;i<n;i++){
        int x = v[i];
        for (int j = i-1; j >=0; j--) {
            if (x < v[j])  {
                v[j+1] = v[j];
                v[j] = x;
            }else {
                break;
            }
        }
    }
}

Quick Sort:

Code:

int partition (vector<int>& v, int low, int high) {
    int pivot = v[low];
    int i = low +1;
    int j = high;
    while (true) {
        while (i <= j && v[i] <= pivot) {
            i++;
        }
        while ( i <= j && v[j] >= pivot) {
            j--;
        }
        if (i <= j) {
            swap (v[i], v[j]);
        }else {
            break;
        }
    }
    swap(v[low], v[j]);
    return j;
}

void quicksort (vector<int>& v, int low, int high)
{
    if (low < high) {
        int pi = partition (v, low, high);
        quicksort(v, low, pi-1);
        quicksort(v, pi+1, high);    
    }
}

Merge Sort

Code:

#include <bits/stdc++.h>
using namespace std;
int arr[] = {4, 2, 4, 5, -30, -02, 3, -60};
void merge(int low, int mid, int hi)
{
    int sa1 = mid - low + 1;
    int sa2 = hi - mid;
    int L[sa1 + 1], R[sa2 + 1];
    for (int i = 0; i < sa1; i++)
    {
        L[i] = arr[low + i];
    }
    for (int j = 0; j < sa2; j++)
    {
        R[j] = arr[mid + 1 + j];
    }
    L[sa1] = INT_MAX;
    R[sa2] = INT_MAX;
    int i = 0, j = 0;
    for (int k = low; k <= hi; k++)
    {
        if (L[i] <= R[j])
            arr[k] = L[i++];
        else
            arr[k] = R[j++];
    }
}
void mergeSort(int low, int hi)
{
    if (low < hi)
    {
        int mid = (low + hi) / 2;
        mergeSort(low, mid);
        mergeSort(mid + 1, hi);
        merge(low, mid, hi);
    }
}
int main()
{
    int size = sizeof(arr) / sizeof(arr[0]);
    mergeSort(0, size);
    for (int i = 0; i < size; i++)
    {
        cout << arr[i] << " ";
    }
}

N.B: Interesting sorting techniques are coming soon in this article.

In a directed acyclic graph (DAG), a topological sort is a linear ordering of the vertices such that for every directed edge, the vertex u comes before v in the ordering. This ordering can be used to find the shortest path between two vertices in the DAG.

To find the shortest path between two vertices s and t, We can perform a modified version of Dijkstra's algorithm in a Directed Acyclic Graph with the help of topological sort. First, we initialize the distance to s as 0 and the distance to all other vertices as infinity. Then, we perform a topological sort of the graph and visit each vertex in the sorted order.

For each visited vertex u, we examine each of its outgoing edges (u, v). If the distance to u plus the weight of (u, v) is less than the current distance to v, we update the distance to v. At the end of the algorithm, the distance to t will give us the shortest path from s to t.

This algorithm works because the topological sort ensures that we always visit vertices in the correct order. Specifically, if we visit u before v, we know that there can be no path from v to u, so we can safely update the distance to v based on the distance to u.

Overall, using a topological sort to find the shortest path in a DAG is an efficient way to solve this problem, with a time complexity of O(V + E), where V is the number of vertices and E is the number of edges in the graph.

C++ code for topological sort where every vertex holds a string:

class Graph {
    ll nodes;
    map <string,vector<string>> adj;
    map <string, bool > visited;
    map <pair<string, string>, ll > wgt;
    public:
    Graph (ll nodes) {
        this->nodes = nodes;
    }
    void addEdge (string u, string v, ll weight) {
        wgt [make_pair(u,v)] = weight;
        if (v != "") {
            adj[u].pb(v);
            visited[u] = false;
            visited[v] = false;
        }else {
            adj[u];
            visited[u] = false;
        }
    }
    vector<string> tSort;
    void tsort (string u) {
        visited [u] = true;
        for (auto i : adj[u]) {
            if (visited[i] == false) {
                tsort(i);
            }
        }
        tSort.insert(tSort.begin(), u);
    }
}

Algorithm for topological sort

0. toposort(u):
1. visited[u] = true
2. for all the adjacency vertex i of adj[u]:
3.     if visited [i] is not true
4.         toposort(i)
5.     end if
6. end for
5. insert u in a linkedlist 'topolist' from front

We can efficiently solve the single source shortest path problem using topological sort in a directed acyclic graph. The idea is described above. So, let's start writing the algorithm for it.

Algorithm for DAG single source shortest path with the help of topological sort

0. single_source_shortest_path_dag (source, topolist, weight, adj):
1. for each vertex i in topolist:
2.     distance [i] = INFINITY
3.     predecessor [i] = NULL
4. end for
5. distance[source] = 0
6. for each vertex i in topolist:
7.     for each adjacent vertex j in adj[i]:
8.         if distance[i] + weight[(i,j)] < distance[j]:
9.                distance [j] = distance[i] + weight[(i,j)]
10.               predecessor [j] = i
11.        end if
12.     end for
13. end for

// Now using the distance and predecessor we can measure distance from the single source and track the path from source to destination

Problem 1

Mr. Bombasta is an alien and is confused about how to dress up like a human being. So he needs to know the order for dressing up. And he has a cost to pick up dresses. Tell him the shortest path from picking up other things if he starts with underwear. Here is the graph of the dresses:

Think for a while and solve the problem. Though I have attached the solution to this article, you should try to solve the problem yourself.

Solution:

#include <bits/stdc++.h>
#define pb push_back
using namespace std;
typedef long long ll;
#define INF 10e9

class Graph {
    ll nodes;
    map <string,vector<string>> adj;
    map <string, bool > visited;
    map <pair<string, string>, ll > wgt;
    public:
    Graph (ll nodes) {
        this->nodes = nodes;
    }
    void addEdge (string u, string v, ll weight) {
        wgt [make_pair(u,v)] = weight;
        if (v != "") {
            adj[u].pb(v);
            visited[u] = false;
            visited[v] = false;
        }else {
            adj[u];
            visited[u] = false;
        }
    }

    vector<string> tSort;
    void tsort (string u) {
        visited [u] = true;
        for (auto i : adj[u]) {
            if (visited[i] == false) {
                tsort(i);
            }
        }
        tSort.insert(tSort.begin(), u);
    }

    void printTopology () {
        for (auto i : visited) {
            i.second = false;
        }
        tSort.clear();
        cout << "choose as source by order: ";
        while (tSort.size() < nodes) {
            string source = "";
            int flag = 0;
            for (auto i : visited) {
                if (i.second == false) {
                    source = i.first;
                    flag = 1;
                    break;
                }
            }
            if (flag) {
                cout << "'" << source << "' " << endl;
                tsort(source);
            }else {
                break;
            }
        }
        cout << endl << endl;
        cout << "Topological order: " << endl;
        int c= 1;
        for (auto i: tSort) {
            cout << c <<". " << i << endl;
            c++;
        }

        cout << endl;
        for (auto i: visited) {
            i.second = false;
        }
    }
    map <string, pair <ll, string> > single_source_shortest_path_dag(string s) {
        printTopology();
        map <string, pair<ll, string>> res;
        for (auto i : tSort ) {
            res[i] = make_pair(INF, "NULL");
        }
        res[s] = make_pair(0, "NULL");
        for (auto i: tSort) {
            for (auto j : adj[i]) {
                if (res[i].first + wgt [make_pair(i,j)] < res[j].first) {
                    res[j].first = res[i].first + wgt [make_pair(i,j)];
                    res[j].second = i;
                }
            }
        }
        return res;
    }

};


void solve () {
    Graph g(8);
    g.addEdge("socks", "shoes", 3);
    g.addEdge ("shoes", "", 0);
    g.addEdge("underwear", "socks", 2);
    g.addEdge("underwear", "pants", 6);
    g.addEdge("pants", "belt", 5);
    g.addEdge("pants", "shoes", 4);
    g.addEdge("shirt", "belt", 7);
    g.addEdge("shirt", "tie", 8);
    g.addEdge("tie", "jacket", 9);
    g.addEdge("jacket", "", 0);
    g.addEdge("socks", "shoes", 3);

    auto ans = g.single_source_shortest_path_dag("underwear");
    cout << "shortest path list: " << endl;
    for (auto i : ans) {
        cout << i.first << ": " << i.second.first << ", " << i.second.second << endl;
    }
    cout << endl << endl;
    cout << "shortest path from each destination: " << endl;
    for (auto i : ans)  {
        cout << i.first << "(" << i.second.first << "): ";
        stack <pair<string, ll>> st;
        if (i.second.first == INF) {
            cout << "N/A" << endl;
            continue;
        } 
        if (i.second.first == 0) {
            cout << "No route needed" << endl;
            continue;
        }
        string route = i.second.second;
        while (ans[route].second != "NULL") {
            st.push(make_pair(route, ans[route].first));
            route = ans[route].second;
        }
        st.push(make_pair(route, ans[route].first));
        while (!st.empty()) {
            cout << st.top().first << "(" << st.top().second<< ") -> ";
            st.pop();
        }
        cout << i.first << "(" << i.second.first << ")" << endl;
    }

}
int main () {
    solve ();
    return 0;
}

Problem 2

http://www.spoj.com/problems/TOPOSORT/

Problem 3

https://onlinejudge.org/index.php?option=onlinejudge&page=show_problem&problem=60

Problem 4

UVA 200 - Rare Order [difficulty: easy]

Problem 5

https://cses.fi/problemset/task/1679

We will try out the following techniques using the function:

$$f(x) = x^3 -x -1$$

Graph of the equation for further outcome validation:

There are several methods to find the root of the polynomial equations. They are-

1. Bisection method,

2. False position method,

3. Newton-Raphson method,

4. Secant method and

5. Newton's Method

Bisection Method

The bisection method is the simplest root-finding technique. The algorithm for bisection is similar to binary search. To use this method, we need to know about the intermediate value theorem (if f is a continuous function whose domain contains the interval [a, b], then it takes on any given value between f(a) and f(b) at some point within the interval). One of the outcomes of this theorem is "If a continuous function has values of opposite sign inside an interval, then it has a root in that interval" (Bolzano's theorem)

Algorithms for Bisection Method:

1. start
2. Define function f(x)
3. Choose initial guesses 'x0' and 'x1' such that f('x0')f('x1') < 0
4. Choose pre-specified tolerable error 'e'.
5. Calculate new approximated root as 'x2' = ('x0' + 'x1')/2
6. Calculate f('x0')f('x2')
    a. if f('x0')f('x2') < 0 then 'x1' = 'x2'
    b. if f('x0')f('x2') > 0 then 'x0' = 'x2'
    c. if f('x0')f('x2') = 0 then goto (8)
7. if |f('x2')| > 'e' then goto (5) otherwise goto (8)
8. Display 'x2' as root.
9. Stop

Code for Bisection Method in C++:

#include <bits/stdc++.h>
#define pb push_back
using namespace std;

double F (double x) {
    // define the polynomial function here
    return x*x*x -x - 1;
}

// Showing Each Iteration Function
void draw(vector<double>& v) {
    cout << "id\t\tx1\t\tx2\t\tx3\n";
    for (int i = 0; i < v.size()/3; i++) {
        cout << i+1 << "\t\t" << setprecision(4) <<  v[3*i] << "\t\t" << setprecision(4) <<  v[3*i+1] << "\t\t" << setprecision(4) << v[3*i+2] << '\n';
    }
}

void solve () {
    double x1,x2;
    cin >> x1 >> x2;
    if (F(x1) * F(x2) > 0) {
        cout << "No solution\n";
        return;
    }
    double E = 0.0001;
    double x3 = (x1+x2)/2;
    vector<double> v;
    while (abs(F(x3)) > E) {
        x3 = (x1+x2)/2;
        if (F(x1) * F(x3) < 0) x2 = x3;
        else x1 = x3;
        v.pb(x1);
        v.pb(x2);
        v.pb(x3);
    }
    cout << x3 << '\n';
    draw(v);
}

int main () {
    solve();
    return 0;
}

The output of the program:

Convergence

The bisection method has linear convergence with a constant of 1/2.

Drawbacks

The bisection method cannot solve for the root of x², as it never becomes negative.

False Position Method

The False position method works on the principle of the x-interception (C,0) of the straight line between two (x1, f(x1) ) and (x2, f(x2) ) points.

We know the the slope of straight line A { (x1, f(x1) ), (x2, f(x2) ) } and straight line B { ( (x1, f(x1) ), (C, f(C) ) or (x2, f(x2)) , (C, f(C) ) ) } is same.

$$\dfrac{f(x2)-f(x1)}{x2-x1} = \dfrac{0-f(x1)}{C-x1}$$

$$\therefore C = x1 - \dfrac{(x2-x1)*f(x1)}{f(x2)-f(x1)}$$

Visual representation of moving to the closer of the root of the equation by one of the iterations:

The working procedure is the same as the bisection method except for the approximate root formula.

Algorithm for False Position method:

1. start
2. Define function f(x)
3. Choose initial guesses 'x0' and 'x1' such that f('x0')f('x1') < 0
4. Choose pre-specified tolerable error 'e'.
5. Calculate new approximated root as 'x2' = = 'x0'- (f('x0') ('x1'-'x0') ) / (f ('x1') – f ('x0'))
6. Calculate f('x0')f('x2')
    a. if f('x0')f('x2') < 0 then 'x1' = 'x2'
    b. if f('x0')f('x2') > 0 then 'x0' = 'x2'
    c. if f('x0')f('x2') = 0 then goto (8)
7. if |f('x2')| > 'e' then goto (5) otherwise goto (8)
8. Display 'x2' as root.
9. Stop

Code for false position method in C++:

#include <bits/stdc++.h>
#define pb push_back
using namespace std;

double F (double x) {
    // define the polynomial function here
    return x*x*x -x - 1;
}

// Showing Each Iteration Function
void draw(vector<double>& v) {
    cout << "id\t\tx1\t\tx2\t\tx3\n";
    for (int i = 0; i < v.size()/3; i++) {
        cout << i+1 << "\t\t" << setprecision(4) <<  v[3*i] << "\t\t" << setprecision(4) <<  v[3*i+1] << "\t\t" << setprecision(4) << v[3*i+2] << '\n';
    }
}

void solve () {
    double x1,x2;
    cin >> x1 >> x2;
    if (F(x1) * F(x2) > 0) {
        cout << "No solution\n";
        return;
    }
    double E = 0.0001;
    double x3 = (x1+x2)/2;
    vector<double> v;
    while (abs(F(x3)) > E) {
        x3 = x1- (F(x1) * (x2-x1) ) / (F (x2) - F (x1));
        if (F(x1) * F(x3) < 0) x2 = x3;
        else x1 = x3;
        v.pb(x1);
        v.pb(x2);
        v.pb(x3);
    }
    cout << x3 << '\n';
    draw(v);
}

int main () {
    solve();
    return 0;
}

The output of the program:

Convergence:

The rate of convergence may vary widely depending on the function and the initial interval used.

Drawbacks:

Potential for oscillations: In some cases, the false position method can oscillate between two endpoints without converging to the root. This can happen when the function has a steep gradient near the root.

The Newton-Raphson Method

Newton-Raphson's method is based on the working principle of function derivatives because it updates the approximate root variable with the y-axis-intercept value of the tangent of the equation that touches the previous approximate root value.

The visual representation of Newton-Raphson's Method:

To use this method, we require an initial guess and the 1st derivatives of the function so that we can form a tangent line and update the approximate value closer to the root.

$$y - F(X_{n-1}) = F'(X_{n-1})* (X_{n}- X_{n-1})$$

$$\therefore X_{n} = X_{n-1} - \dfrac{F(X_{n-1})}{F'(X_{n-1})}$$

Algorithm for Newton-Raphson's Method:

1. Start
2. Define the F(x)
3. Define the derivative of the F1(x)
4. Choose pre-specified tolerable error 'e'.
6. Set initial variable 'x0' via input
6. While function(x0) > 'e':
7. 'x0' = 'x0' - F('x0')/F1('x0')
8. Display 'x0' as root
9. Stop

Code for Newton-Raphson's Method in C++:

#include <bits/stdc++.h>
#define pb push_back
using namespace std;

double F (double x) {
    // define the polynomial function here
    return x*x*x -x - 1;
}

double F1 (double x) {
    // define the derivative of the polynomial function here
    return 3*x*x - 1;
}

// Showing Each Iteration Function
void draw(vector<double>& v) {
    cout << "id\t\tXn\n";
    for (int i = 0; i < v.size(); i++) {
        cout << i+1 << "\t\t" << setprecision(4) <<  v[i] << '\n';
    }
}

void solve () {
    double x0;
    cin >> x0;
    double E = 0.0001;
    vector<double> v;
    while (abs(F(x0)) > E) {
        x0 = x0 - F(x0)/F1(x0);
        v.pb(x0);
    }
    cout << x0 << '\n';
    draw(v);
}

int main () {
    solve();
    return 0;
}

The output of the program:

Convergence:

This rapid convergence makes Newton-Raphson's method one of the most popular algorithms for finding roots of nonlinear equations.

Drawbacks:

1. Sensitivity to initial guess: Newton-Raphson's method requires an initial guess of the root. If the initial guess is not close enough to the actual root, the method may fail to converge, converge to the wrong root, or oscillate between different roots. In practice, finding an appropriate initial guess can be difficult, especially when dealing with complex functions.

2. Need for derivative information: Newton-Raphson's method requires the derivative of the function to be evaluated at each iteration. This can be computationally expensive, especially when the function is complex or expensive to evaluate. Additionally, the derivative may not be readily available or may be difficult to compute accurately.

3. Potential for divergence: Newton-Raphson's method can diverge if the derivative of the function is close to zero or if it changes sign in the neighborhood of the root. This can happen when the function has singularities or sharp turns near the root.

4. Not guaranteed to converge: Newton-Raphson's method is not guaranteed to converge to a root in all cases. For example, if the function has an infinite number of roots or if the initial guess is very far from the root, the method may not converge.

5. Multiple roots: If the function has multiple roots that are close together, Newton-Raphson's method may converge to a root that is different from the desired one. This can happen if the initial guess is not sufficiently accurate.

6. Requires smoothness of the function: Newton-Raphson's method requires the function to be differentiable and smooth in the neighborhood of the root. If the function has discontinuities, singularities, or sharp turns near the root, the method may fail to converge or converge very slowly.

Secant Method

secant method uses the same technique as Newton-Raphson's Method. But sometimes, it's hard to find the derivative of the function analytically. The Secant method overcomes this problem by using the estimating value of the tangent's slope / derivative function.

$$F'(X_{n-1}) \approx \dfrac{ F(X_{n-1}) - F(X_{n-2})}{X_{n-1}-X_{n-2}}$$

$$X_{n} = X_{n-1} - \dfrac{F(X_{n-1}) * (X_{n-1} - X_{n-2})}{F(X_{n-1}) - F(X_{n-2})}$$

$$X_{n} = \dfrac{X_{n-2} * F(X_{n-1}) - X_{n-1} * F(X_{n-2})}{F(X_{n-1}) - F(X_{n-2})}$$

In short, we can use this formula to compute the result

$$\therefore X_3 = \dfrac{x_1F_2 - x_2F_1}{F_2 - F_1}$$

Code for secant method in C++:

#include <bits/stdc++.h>
#define pb push_back
using namespace std;

double F (double x) {
    // define the polynomial function here
    return x*x*x -x - 1;
}


// Showing Each Iteration Function
void draw(vector<double>& v) {
    cout << "id\t\tXn\n";
    for (int i = 0; i < v.size(); i++) {
        cout << i+1 << "\t\t" << setprecision(4) <<  v[i] << '\n';
    }
}

void solve () {
    double x1,x2;
    cin >> x1 >> x2;
    double E = 0.0001;
    double f1, f2;
    f1 = F(x1);
    f2 = F(x2);
    double x3 = x1;
    vector<double> v;
    while (abs(F(x3)) > E) {
        x3 = (x1*f2 - x2*f1)/ (f2-f1);
        x1 = x2;
        x2 = x3;
        f1 = F(x1);
        f2 = F(x2);
        v.pb(x3);
    }
    cout << x3 << '\n';
    draw(v);
}

int main () {
    solve();
    return 0;
}

The output of the program:

Convergence:

This method has slower convergence than Newton-Raphson's Method.

Drawbacks:

Same drawbacks as Newton-Raphson's method, except you don't need to find out the derivative of the function.

N.B: Newton's and Modified Bi-section methods are coming soon on this post.

Practice Questions:

1. Write a program on the function f(x) = 2x³ + 3x - 1 to output all the possible real roots of the function with a tolerance of 0.0001.

2. Write a program on the function f(x) = x³ + 9x - 4 with a tolerance of 0.001 to find the root of the function and decide which methods will perform better.

Demo

List of commands

1. Download the Firebase CLI

2. Open VSCode and create a new flutter project using this command:

    flutter create --org com.khandokeranan -i swift -a kotlin app_name
   

3. Now run VSCode current folder terminal

    firebase login
    dart pub global activate flutterfire_cli
    flutterfire configure
   

4. FlutterFire automatically configures the project and extra layers of security for you. Now, add this line if you want to use the google_sign_in system to ios/Runner/Info.plist.

    <key>CFBundleURLTypes</key>
        <array>
            <dict>
                <key>CFBundleTypeRole</key>
                <string>Editor</string>
                <key>CFBundleURLSchemes</key>
                <array>
                    # you will find the code in ios/Runner/GoogleService-Info.plist -> REVERSED_CLIENT_ID
                    <string>com.googleusercontent.apps.128343086777-lo0d43u57fbc6irsvp719ne025ok8a2g</string>
                </array>
            </dict>
        </array>
   

5. Now enable Google or other sign-in methods. Please visit the Firebase console and enable it.

   

6. We need to add the SHA-1 and SHA-256 string to the Firebase for Android.
   Now right-click on gradlew under the android folder of the project folder and click ‘open in terminal’ and run this command:

    gradlew signingReport
   

7. Now you can implement login features with these plugins:

      firebase_core: ^2.9.0
      firebase_auth: ^4.4.1
      google_sign_in: ^6.1.0
   

Flutter Dart codes for the signing flow

import 'package:firebase_auth/firebase_auth.dart';
import 'package:google_sign_in/google_sign_in.dart';
import 'package:flutter/material.dart';

class AuthService {

  signInWithGoogle () async {
    final GoogleSignInAccount? user = await GoogleSignIn().signIn();
    if (user == null) return; 
    final GoogleSignInAuthentication auth = await user.authentication;
    final credential = GoogleAuthProvider.credential(
      idToken: auth.idToken,
      accessToken: auth.accessToken
    );
    return await FirebaseAuth.instance.signInWithCredential(credential); 
  }

  void userSignOut() {
    FirebaseAuth.instance.signOut();
  }

  void signUserInWithEmailPass(String email, String pass, BuildContext context) async{
    showDialog(context: context, builder: (context) {
        return const Center(child: CircularProgressIndicator());
    });
    try{
      await FirebaseAuth.instance.signInWithEmailAndPassword(email: email, password: pass);
    } catch (e) {
      Navigator.pop(context);
      ScaffoldMessenger.of(context).showSnackBar(const SnackBar(content: Text("Please use the correct username/password or login with Google or Apple id.")));
    }
  }


  void signUserUpWithEmailPass(String email, String pass) async {
      showDialog(context: context, builder: (context) {
        return const Center(child: CircularProgressIndicator());
      });
      try {
      final credential = await FirebaseAuth.instance.createUserWithEmailAndPassword(
        email: email,
        password: pass,
      );
    } on FirebaseAuthException catch (e) {
      if (e.code == 'weak-password') {
        ScaffoldMessenger.of(context).showSnackBar(const SnackBar(content: Text("The password provided is too weak.")));
      } else if (e.code == 'email-already-in-use') {
        ScaffoldMessenger.of(context).showSnackBar(const SnackBar(content: Text("The account already exists for that email.")));
      }
    } catch (e) {
      ScaffoldMessenger.of(context).showSnackBar(const SnackBar(content: Text("Something went wrong. please try again with proper internet connection and strong password")));
    }
  }

  // Before you begin, configure Sign In with Apple and enable Apple as a sign-in provider.
  // Next, make sure that your Runner apps have the "Sign in with Apple" capability.
  // Link : https://firebase.google.com/docs/auth/ios/apple#configure-sign-in-with-apple
  // Link for enabling apple provider: https://firebase.google.com/docs/auth/ios/apple#enable-apple-as-a-sign-in-provider
  signInWithApple() async {
    final appleProvider = AppleAuthProvider();
    await FirebaseAuth.instance.signInWithProvider(appleProvider);
  }
}

Important: Read this carefully

Sign-in with Apple must be implemented if you are using any social media authentication providers to publish the app in Apple App Store.

To use the sign-in with Apple, you need to subscribe Apple Developer Program (PAID) and go through these links to implement the feature:
Configure Sign In with Apple and enable Apple as a sign-in provider. Make sure that your Runner apps have the "Sign in with Apple" capability.

For Google sign-in flow, make sure that ios/runner has a file named GoogleService-Info.plist and android/app has a file named google-services.json

If you are using Github public repository for the source control system, add these lines in gitignore to prevent using the files by others.

# Firebase Credentials
/android/app/google-services.json
/ios/Runner/GoogleService-Info.plist

Github link

GitHub link: https://github.com/anwholesquare/firebase_google_apple_emailpass_auth_flutter_flutterfire

Required Flutter packages

Open pubspec.yaml and add these packages under dependencies:

dependencies:
  flutter:
    sdk: flutter
  # add these packages in your flutter project first
  google_fonts:
  shared_preferences:
  intl:
  sign_button:

Google Fonts is used for custom fonts. Shared Preferences, this package is used for storing small data such as current_theme_mode, is_user_logged_in, etc. Intl is widely used to convert DateTime to our desired date string. The Sign_button package is used to design social media login buttons with proper design guidelines.

Import Necessary Assets

To use local assets, we must add this line to the pubspec.yaml: assets:

flutter:
  uses-material-design: true  
# add this line and create a new folder named assets and inside the folder, create another folder named images
  assets:
    - assets/images/

I have saved a .gif image named 'boring.gif' inside the folder named 'images.' The link to the file is HERE.

Import dart files to main.dart

For the project, we need these importations inside the main.dart file:

// ignore_for_file: prefer_const_constructors
import 'package:flutter/material.dart';
import 'package:google_fonts/google_fonts.dart';
import 'package:intl/intl.dart';
import 'package:http/http.dart' as http;
import 'dart:convert';
import 'package:sign_button/sign_button.dart';

Widgets we need to use

The list of widgets we will use:

1. HomePage

   1. DropdownButtonFormField

   2. TextFormField

   3. showDatePicker()

   4. ElevatedButton

   5. Others: Container, Column, Material, Scaffold, Center, Row, Icon, Text, BoxDecoration, Navigator.push(), SizedBox, Padding, SingleChildListView, Flexible

2. ThankYouPage

   1. Image.asset

   2. Text

   3. Scaffold

Full main.dart code

// ignore_for_file: prefer_const_constructors

import 'package:flutter/material.dart';
import 'package:google_fonts/google_fonts.dart';
import 'package:intl/intl.dart';
import 'package:http/http.dart' as http;
import 'dart:convert';
import 'package:sign_button/sign_button.dart';

void main () {
    runApp(MyApp());
}

class MyApp extends StatefulWidget {
  const MyApp({super.key});

  @override
  State<MyApp> createState() => _MyAppState();
}

class _MyAppState extends State<MyApp> {
  int appColor = 3;
  void update (int status, dynamic data) {
      if (status == 1 && data is int) {
        appColor = data % 4;
        setState(() {});
      }
  }
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
        theme: ThemeData(
            primarySwatch: appColor == 3 ? Colors.blue : appColor == 2 ? Colors.green : Colors.red,
            fontFamily: GoogleFonts.poppins().fontFamily
        ),
        debugShowCheckedModeBanner: false,
        home: HomePage(updateMyApp: update)

    );
  }
}

class HomePage extends StatefulWidget {
  final void Function (int, dynamic)? updateMyApp;
  const HomePage({super.key, required this.updateMyApp});

  @override
  State<HomePage> createState() => _HomePageState();
}

class _HomePageState extends State<HomePage> {
  String dob = DateFormat.yMd().format (DateTime.now());
  List<DropdownMenuItem<String>> countries = [DropdownMenuItem(child: Text("No Country"))];
  String? selectedCountry;
  bool _isChecked = true;
  int appColor = 3;

  Widget TextBox (String label, String hint, {bool security = false}) => TextField(
    obscureText: security,
    decoration: InputDecoration (
      labelText: label,
      hintText: hint,
      prefixIcon:  Icon (security ? Icons.pin : Icons.person),
      border: UnderlineInputBorder()
    )
  );

  void getCountries () async {

    final response = await http.get(Uri.parse("https://raw.githubusercontent.com/anwholesquare/form-building-json/main/countries.json"));
    countries = [DropdownMenuItem(child: Text("No Country"))];
    if (response.statusCode == 200) {
        var cntr = json.decode(response.body);
        for (dynamic k in cntr) {
            String nText = k["text"].toString();
            countries.add(DropdownMenuItem(value: k["value"], child: Text(nText)));
        }
        setState(() {

        });
    }
  }

  @override
  void initState() {
    super.initState();
    getCountries();
  }

  @override
  Widget build(BuildContext context) {
    return Material(
      child:SafeArea(
        child: Padding(
          padding: const EdgeInsets.all(24),
          child: Container(
              width: double.infinity,
              child: SingleChildScrollView(
                  child: Column (children: [
                      Row (children: [
                        Icon(Icons.arrow_back_ios_new_rounded),
                        SizedBox(height:20),
                        Text("Coursido Login", style: TextStyle(fontSize: 24, fontWeight: FontWeight.bold) )
                       ],),
                       SizedBox(height: 20,),
                       TextBox("Email", "Enter Email Address"),
                       SizedBox(height: 20,),
                       Row (children: [
                          Flexible (
                            flex:4,
                            child: 
                          DropdownButtonFormField<String>(
                              items: countries,
                              isExpanded: true,
                              onChanged: (String? ne) {
                                debugPrint(ne);
                              },
                              decoration: InputDecoration(
                                labelText: "Country",
                                prefixIcon: Icon(Icons.public_rounded)
                              ),

                          ),),
                          SizedBox(width: 5,),
                          Flexible(
                            flex:3,
                            child: TextFormField(
                              onTap:() async {
                                  final DateTime? pickDate = await showDatePicker(context: context, initialDate: DateTime.now(), firstDate: DateTime(1900), lastDate: DateTime.now());

                                  if (pickDate != null) {
                                      setState(() {
                                        dob = DateFormat.yMd().format(pickDate);
                                      });
                                  }
                              },
                              readOnly: true,
                              controller: TextEditingController(text:dob),
                              decoration: InputDecoration(
                                labelText: "Date of Birth",
                                prefixIcon: Icon(Icons.calendar_month_sharp),
                                border: UnderlineInputBorder()
                              )
                            )
                          )

                       ],),
                      SizedBox(height:20),
                      TextBox(security: true, "PIN", "Enter PIN"),
                      SizedBox(height: 20,),
                      Row (children: [
                        Checkbox(
                          value: _isChecked,
                          onChanged: (val) => setState(() {
                            _isChecked = val!;
                          }),
                        ),
                        SizedBox(width: 10,),
                        Text("I agree with terms and conditions")


                      ],),
                      Row(
                        mainAxisAlignment: MainAxisAlignment.center,
                        children: [
                          InkWell(
                            onTap: () => setState(() {
                              appColor = 1; widget.updateMyApp!(1, appColor);
                            }),
                            child: Container (
                              height: 32,
                            width: 32,
                            decoration: BoxDecoration(shape:BoxShape.circle, color: Colors.red),
                            child: (appColor == 1) ? Icon(Icons.check_rounded, color: Colors.white,) : null,

                            ),
                          ),
                          SizedBox(width: 10,),
                          InkWell(
                            onTap: () => setState(() {
                              appColor = 2; widget.updateMyApp!(1, appColor);
                            }),
                            child: Container (
                              height: 32,
                            width: 32,
                            decoration: BoxDecoration(shape:BoxShape.circle, color: Colors.green),
                            child: (appColor == 2) ? Icon(Icons.check_rounded, color: Colors.white,) : null,

                            ),
                          ),
                          SizedBox(width: 10,),
                          InkWell(
                            onTap: () => setState(() {
                              appColor = 3; widget.updateMyApp!(1, appColor);
                            }),
                            child: Container (
                              height: 32,
                            width: 32,
                            decoration: BoxDecoration(shape:BoxShape.circle, color: Colors.blue),
                            child: (appColor == 3) ? Icon(Icons.check_rounded, color: Colors.white,) : null,

                            ),
                          ),


                        ]
                      ),
                      SizedBox(height: 20,),
                      Center (child: ElevatedButton(
                        onPressed: () {
                          Navigator.push(context, MaterialPageRoute(builder: (context) => ThankYouPage()));
                        },
                        child: Text("Create a New Account")
                      ),),
                      SizedBox(height: 20,),
                      Center(child: Text("OR",style: TextStyle(fontSize: 24, fontWeight: FontWeight.bold),),),
                      SizedBox(height: 20,),
                      Center(
                        child: SignInButton(buttonType: ButtonType.google, buttonSize: ButtonSize.small,
                        onPressed: () {
                          Navigator.push(context, MaterialPageRoute(builder: (context) => ThankYouPage()));
                        },
                        ),
                      )


                  ],)
              ),
            ),
        )
      )

    );
  }
}


class ThankYouPage extends StatelessWidget {
  const ThankYouPage({super.key});

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: Text("Coursido")),
      body: Center(child: Column(
        mainAxisAlignment: MainAxisAlignment.center,
        crossAxisAlignment: CrossAxisAlignment.center,
        children: [
          Image.asset("assets/images/boring.gif", height: 300,),
          SizedBox(height: 20,),
          Text("Thank you for the registration", style: TextStyle(fontWeight: FontWeight.bold),)

      ],)),
    );
  }
}

Youtube Fast Flutter Implementation

Project GitHub link

https://github.com/anwholesquare/flutter-testdesign/tree/680d8d52a2a71ee1daec099bc5629073e71a62c7

Prerequisites:

1. Before you can start building Flutter apps, you must set up your development environment. This includes installing the Flutter SDK, Android Studio, and VS Code, XCode, and Cocoapods you might need. If you haven't already installed Flutter, follow the instructions on the official Flutter website to download and install it on your computer.

2. Flutter uses Dart as its programming language. Dart is a modern, object-oriented programming language with a syntax that is easy to learn and understand. You should spend some time learning Dart programming, including its syntax, data types, variables, functions, and control structures.

Dart Basics:

Here's a quick reference of important things to keep in mind when using Dart for Flutter:

Data Structures and Variables:

// Importing core libraries
import 'dart:math';
// Importing libraries from external packages
import 'package:test/test.dart';
// Importing files
import 'path/to/my_other_file.dart';

void main(){
    // This is a normal, one-line comment.

    /// This is a documentation comment, used to document libraries,
    /// classes, and their members. Tools like IDEs and dartdoc treat
    /// doc comments specially.

    int x = 2;
    var p = 5;
    dynamic z = 8;
    z = "cool";
    final email = "temid@gmail.com"; 
    const qty = 5;

    var multilist = [];
    multilist.add([1,2]);
    multilist.add([3,6,1,4,6,9]);
    for (List<int> i in multilist) {
        print ("list: $i");
        i.sort((x,y) {
            return x>y ? x : y;
        });
        print("sorted list: ${i.toString()}");
    }


   var person = {};
   person["name"] = "Khandoker Kafi Anan";
   person["age"] = 22;
   person["socials"] = {
     "facebook": "https://facebook.com/khandoker.anan",
     "website" : "https://khandokeranan.com",
     "linkedin": "httpsL//linkedin.com/in/khandokeranan"
   };
   person["favorite_numbers"] = [6,5,11,28,101,7,3];

   person.forEach( (key,val) {
     print ("$key : $val");
   });

}

Class, Inheritance, mixin, and Polymorphism:

class Analytics {
    int totalViewsCount = 0;
    int blogId = 0;
    Analytics (int blogId, int totalViewsCount) {
      this.blogId = blogId;
      this.totalViewsCount = totalViewsCount;
    }
    void increaseView () {
      totalViewsCount++;
    }
}

class Audio {
    void playSound (String filename) {
        print ("Playing $filename");
    }
}

class BlogWriter extends Analytics with Audio{
    String? title, description, author;
    BlogWriter( super.blogId, super.totalViewsCount, { required this.title, this.description, required this.author});

    void showDetails () {
        description ??= "No description found";
        print ("Title: $title\nDescription: $description\nAuthor: $author\nBlog ID: $blogId\nTotal Views: $totalViewsCount");
    }

    @override 
    void increaseView () {
      totalViewsCount+=2;
    }
}

void main () {

    BlogWriter bw = BlogWriter(11, 2011, title: "Anan's Sight", description: "This is a blog", author: "Khandoker Anan");
    bw.increaseView ();
    bw.showDetails();
    bw.playSound("C:/app/anan.mp3");

}

Optional Function Passing in a Function:

int maxVal (List<int> v) {
    int maxv = -999999999999;
    for (int i=0; i<v.length; i++) {
        maxv = (maxv < v[i]) ? v[i] : maxv;
    }
    return maxv;
}
void deleteMaxVal(var v, {Function max = maxVal}) {
  var maxValue = max(v);
  bool check = v is List && v.isNotEmpty && maxValue.runtimeType.toString() == v[0].runtimeType.toString();
  if (check) {
    v.remove(maxValue); 
    print (v);
  }

}
void main () {
  var v = [4,3,6,1,3,11,33,55,1,21];
  print (maxVal (v));
  deleteMaxVal(v, max: maxVal);
}

Flutter Project Creation and Source Control:

HOW TO CREATE A FLUTTER PROJECT

To create a flutter project, we need to run this command on the specific folder's terminal/CMD:

flutter create --org com.khandokeranan -i swift -a kotlin testdesign

"com.khandokeranan" represents the organization's name and type, and "-i swift" uses for using swift for iOS development, and "-a kotlin" uses for using kotlin for android development.

FLUTTER DEFAULT PROJECT STRUCTURE

using the flutter create command, it generates a default project structure with several directories and files. Here's an overview of the main directories and files in a typical Flutter project:

1. android: This directory contains the Android-specific configuration files, such as the Gradle build scripts, AndroidManifest.xml, and other resources required for building and running the Flutter app on Android.

2. ios: This directory contains the iOS-specific configuration files, such as the Xcode project, Info.plist, and other resources required for building and running the Flutter app on iOS.

3. lib: This directory is the heart of your Flutter app, and it contains the Dart source code for your app. It's where we'll write our app's main logic and UI code using Flutter widgets.

4. test: This directory is used for writing tests for your Flutter app. It can contain unit tests, integration tests, and widget tests to ensure the quality and correctness of your app.

5. assets: This directory is used for storing static assets, such as images, fonts, and other files, that are bundled with your app. You can access these assets in your Flutter app using the AssetBundle class.

6. lib/main.dart: This is the entry point of your Flutter app. It contains the main() function, which is the starting point of your app's execution.

7. pubspec.yaml: This is the configuration file for our Flutter app, written in YAML format. It contains your app's dependencies, assets, and other settings, such as the app name, version, and description.

8. pubspec.lock: Flutter automatically generates this file and contains the locked versions of the dependencies used in your app, ensuring that the same dependencies are used across different builds.

9. build: This directory is automatically generated by Flutter, and it contains the compiled output of your app, including the APK (Android) and IPA (iOS) files, as well as intermediate build artifacts.

ACTIVATING GITHUB REPOSITORY WITH THE PROJECT INSIDE VS CODE

Make sure Git is installed. VS Code will use your machine's Git installation (at least version 2.0.0), so you need to install Git first before you get these features to publish the project directly to GitHub. By following these two steps to publish the repository to a public or private remote repository to GitHub without using commands, we can commit to the project, open new branches for production, development, android-specific, etc, manage branches and commits and collaborate with other developers.

To know more about it, click the image for more references.

The First Hello World Flutter App from Scratch:

The git repo: https://github.com/anwholesquare/flutter-testdesign/tree/13d9c28909d9f2a30216952273726d2e1b38461e

import 'package:flutter/material.dart';
void main () {
  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      theme: ThemeData(
        primarySwatch: Colors.blue
      ),
      home: const Material (
        child: Center(
          child: Text("Hello World", 
            style: TextStyle(
              fontSize: 24,
              fontWeight: FontWeight.bold
            ),
          ),
        ),
      )

    );
  }
}

The rest of the blog is to be continued.