DEV Community: Hein Khant Zaw

Django Deployment with Nginx in Ubuntu

Hein Khant Zaw — Sat, 25 Jun 2022 08:03:51 +0000

This was just a note for myself as I faced several errors during my first deployment with Django. This note is for those who are facing problems during the deployment. I hope it helps!

Install the Packages from the Ubuntu Repositories first. If you are using Django with Python 3, type:

sudo apt-get update
sudo apt-get install python3-pip python3-dev libpq-dev nginx

Postgresql installation

sudo apt-get update
sudo apt-get install python3-pip python3-dev libpq-dev postgresql postgresql-contrib nginx

MySQL installation

sudo apt-get update
sudo apt-get install mysql-server
mysql_secure_installation

Database creation

CREATE DATABASE myproject;

Postgres

CREATE USER myprojectuser WITH PASSWORD 'password'; 
GRANT ALL PRIVILEGES ON DATABASE myproject TO myprojectuser;

MySQL

CREATE USER 'newuser'@'localhost' IDENTIFIED BY 'password'; 
GRANT ALL PRIVILEGES ON * . * TO 'newuser'@'localhost';

Python VirtualEnv Creation

sudo -H pip3 install --upgrade pip
sudo -H pip3 install virtualenv
cd ~/myproject
virtualenv myprojectenv
source myprojectenv/bin/activate 
pip install django gunicorn psycopg2 (For Postgres)

Changes in setting.py

ALLOWED_HOSTS = [ ‘*’ ]
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql_psycopg2',
        'NAME': 'myproject',
        'USER': 'myprojectuser',
        'PASSWORD': 'password',
        'HOST': 'localhost',
        'PORT': '',
    }
}

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'myproject',
        'USER': 'myprojectuser',
        'PASSWORD': 'password',
    }
}

Migrations

Now, we can migrate the initial database schema to our database using the management script:

python manage.py makemigrations
python manage.py migrate

Create an administrative user for the project by typing:

python manage.py createsuperuser

You will have to select a username, provide an email address, and choose and confirm a password.
We can collect all of the static content into the directory location we configured by typing:

python manage.py collectstatic

Create a Gunicorn systemd Service File

Now, we are going to implement a more robust way of starting and stopping the application server with Gunicorn. To accomplish this, we’ll make a systemd service file.

Create and open a systemd service file for Gunicorn with sudo privileges in your text editor:

sudo nano /etc/systemd/system/gunicorn.service

gunicorn.service file

[Unit]
Description=gunicorn daemon
Requires=gunicorn.socket
After=network.target

[Service]
Type=notify
# the specific user that our service will run as
User=root
Group=root
# another option for an even more restricted service is
# DynamicUser=yes
# see http://0pointer.net/blog/dynamic-users-with-systemd.html
RuntimeDirectory=gunicorn
WorkingDirectory=/var/www/html/[ProjectName]
ExecStart=/var/www/html/[ProjectName]/project_venv/bin/gunicorn config.wsgi
ExecReload=/bin/kill -s HUP $MAINPID
KillMode=mixed
TimeoutStopSec=5
PrivateTmp=true

[Install]
WantedBy=multi-user.target

Check for the Gunicorn Socket File

Check the status of the process to find out whether it was able to start:

sudo systemctl status gunicorn

Create gunicorn.socket

sudo nano /etc/systemd/system/gunicorn.socket

gunicorn.socket File

[Unit]
Description=gunicorn socket

[Socket]
ListenStream=/run/gunicorn.sock
# Our service won't need permissions for the socket, since it
# inherits the file descriptor by socket activation
# only the nginx daemon will need access to the socket
User=www-data
# Optionally restrict the socket permissions even more.
# Mode=600

[Install]
WantedBy=sockets.target

Run gunicorn service

sudo systemctl start gunicorn
sudo systemctl enable gunicorn
sudo systemctl status gunicorn
sudo systemctl daemon-reload
sudo systemctl restart gunicorn

Configure Nginx to Proxy Pass to Gunicorn

sudo nano /etc/nginx/sites-available/[ProjectName]

Then, type

upstream app_server {
    server unix:/run/gunicorn.sock fail_timeout=0;
}

server {
    listen 80;
    listen [::]:80;
    server_name 128.199.221.253;  # here can also be the IP address of the server

    keepalive_timeout 5;
    client_max_body_size 4G;

    access_log /var/www/html/[ProjectName]/logs/nginx-access.log;
    error_log /var/www/html/[ProjectName]/logs/nginx-error.log;

    location /static/ {
        autoindex on;
        alias /var/www/html/[ProjectName]/static/;
    }

    # checks for static file, if not found proxy to app
    location / {
        try_files $uri @proxy_to_app;
      }

    location @proxy_to_app {
      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
      proxy_set_header Host $http_host;
      proxy_redirect off;
      proxy_pass http://app_server;
    }
  }

Adding SSL Certificate

upstream app_server {
    server unix:/run/gunicorn.sock fail_timeout=0;
}

server {
    listen 80;
    listen [::]:80;
    server_name 128.199.79.246;  # here can also be the IP address of the server
    return 301 https://[DomainName]$request_uri;
  }

server{
    # SSL configuration
    listen 443 ssl http2;
    listen [::]:443 ssl http2;
    server_name [DomainName];

    ssl        on;
    ssl_certificate         /etc/ssl/certs/cert.pem;
    ssl_certificate_key     /etc/ssl/private/key.pem;
    ssl_client_certificate /etc/ssl/certs/cloudflare.crt;
    ssl_verify_client on;

    keepalive_timeout 5;
    client_max_body_size 4G;

    access_log /home/[UserName]/logs/nginx-access.log;
    error_log /home/[UserName]/logs/nginx-error.log;

    location /static/ {
        autoindex on;
        alias /home/[UserName]/[ProjectName]/[DjangoAppName]/static/;
    }

    # checks for static file, if not found proxy to app
    location / {
        try_files $uri @proxy_to_app;
      }

    location @proxy_to_app {
      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
      proxy_set_header Host $http_host;
      proxy_redirect off;
      proxy_pass http://app_server;
    }
}

Restart all the service

sudo systemctl daemon-reload
sudo systemctl restart gunicorn
sudo nginx -t && sudo systemctl restart nginx

Parameter Passing

Hein Khant Zaw — Sat, 25 Jun 2022 07:46:12 +0000

Parameters ဆိုတာက subprogram (subprogram ဆိုတာက C++ မှာဆို function, Java မှာဆို Methods) ထဲမှာ သုံးဖို့အတွက်‌ထည့်ပေးလိုက်တဲ့ တန်ဖိုး(or) subprogram ကနေတွက်ထုတ်‌ေပးလိုက်တဲ့တန်ဖိုး ကိုခေါ်တယ်။

Formal parameter ဆိုတာက subprogram ထဲမှာပါတဲ့ parameter ကိုပြောတာ
Actual parameter ဆိုတာက subprogram ကိုခေါ်တဲ့အချိန် မှာထည့်ပေးလိုက်တဲ့ဟာကိုခေါ်တယ်။ Actual parameter ကို Arguments လို့လဲေခါ်ကြပါတယ်။

Example of formal parameters

public int addTwoNum(int a, int b) // a and b are formal parameters
{
   int c = a + b; // a, b are input parameters
   return c; // c is output parameter
}

Example of actual parameters (a.k.a Arguments)

int num1 = 1, n2 =2;
int sum = addTwoNum(num1, num2); //num1 and num2 are actual parameters

အဲ့တော့ subprogram တစ်ခုကိုခေါ်မယ်ဆိုရင် ဘယ်လိုဖြစ်သွားသလဲဆိုတော့
actual parameter ထဲကတန်ဖိုးကို formal parameter ထဲလွဲပေးလိုက်တယ်။
subprogram က သူ့ထဲက formal parameter နဲ့ပဲအလုပ်လုပ်တယ်။
အပေါ်က code မှာဆိုရင် num1, num2 ကို addTwoSum() ထဲထည့်ပေးလိုက်
တာတွေ့တယ်မလား။ အဲ့ num1, num2 ထဲက တန်ဖိုးက addTwoNum()
ထဲရောက်သွားတော့ a, b အနေနဲ့ပဲ calculation လုပ်သွားတယ်။
ဒီလောက်ဆို formal နဲ့ actual ကိုကွဲပြီထင်တယ်။

Input, Output, Input/Output

Input parameter က subprogram ကလက်ခံတဲ့ parameter ကိုခေါ်တာ။
အပေါ်က formal parameters example မှာပြထားတဲ့ a နဲ့ b ဆိုတာက input parameter ပဲ ။

Output parameter ကျတော့ subprogram ကနေ ပြန်ထုတ်ပေးလိုက်တဲ့ parameter ကိုခေါ်တာ။
Eg. အပေါ်က addTwoNum() မှာဆိုရင် c က output parameter ဖြစ်တယ်။

Input/Output parameters ကတော့ subprogram ကလက်ခံထားတဲ့ input parameter ကိုပဲ output parameter အဖြစ် ပြန်ထုတ်ပေးတာကို Input/Output parameter လို့ခေါ်တယ်။
ဆိုလိုချင်တာက input ကိုပဲတန်ဖိုးပြောင်းပြီး ပြန်ထုတ်ပေးလိုက်တာမျိုးကိုပြောတာ။

input/output parameters က callByReference မှာ‌‌သုံးလို့ရတယ်။

Example of input/output parameters

public int addTwoNum(int &a,int &b) 
{
   a = a + b;
   return a; // a is input/output parameter
}

Value or Reference?

Parameter pass တဲ့အခါမှာ အသုံးအများဆံုးက value pass တာနဲ့ reference ကို pass တာဆိုပြီး နှစ်မျိုးရှိတယ်။

Call by Value

Call by Value ဆိုတာက subprogram ထဲကို parameter pass
ပေးတဲ့အခါ ဟိုအပေါ်မှာ‌ေြပာထားသလိုပဲ actual parameter ရဲ့ တန်ဖိုးကို formal parameter ထဲ လွှဲပေးလိုက်တာ။
အဲ့တော့ subprogram ထဲမှာလုပ်သမျှတွေသည် actual parameter ကို ဘာမှလာမပြောင်းလဲစေဘူး။
formal parameter ကပဲပြောင်းသွားလိမ့်မယ်။

Example of Call by Value

#include <iostream>
using namespace std;

void increaseByValue(int n){
  n++; // n = 2
}

int main() {
  int num = 1;
  increaseByValue(num); // This won't change the value in num
  cout<<"After Passing by value :"<<num<<'\n'; // num = 1
}
// Since it's call by value, you'll need to return the value or else, there won't be any effect.

ဒီ code ထဲမှာဆိုရင် increaseByValue() က n တန်ဖိုးကို 1 တိုးပေးတယ်။
subprogram တွေက သူတို့အလုပ်ပြီးသွားတာနဲ့
formal parameter ကို destroy လုပ်လိုက်တယ်။
eg. variable n ရဲ့ scope က increaseByValue() အတွင်းမှာပဲရှိတယ်
အဲ့တော့ သူ့ထဲကတန်ဖိုးက increaseByValue() ရဲ့အလုပ်ပြီးရင် အပြင်က main function ကိုရောက် မသွားဘူး။
Main function ထဲကိုရောက်ချင်ရင် အဲ့ n ကို output parameter အဖြစ် return ပေးမှပဲရလိမ့်မယ်။
example code မှာက function return ကို void ထားတော့ဘာမှ return မလုပ်ဘူး။
အဲ့တော့ ဘယ်လိုဖြစ်သွားလဲဆိုတော့ increaseByValue(num)
လုပ်လိုက်တဲ့အခါ n တန်ဖိုးက ၂ တော့ဖြစ်သွားတယ်။
ဒါပေမယ့် num ရဲ့တန်ဖိုးက ၁ က ၁ ပဲ။ မပြောင်းသွားဘူး။
တကယ်လို့ num မှာပါလာပြောင်းချင်တယ်ဆိုရင်
increaseByValue() မှာ n ကို return ပေးမှရမယ်။

I'll show the correct way in this example.

#include <iostream>
using namespace std;

int increaseByValue(int n){
  n++; // n = 2
  return n;
}

int main() {
  int num = 1;
  num = increaseByValue(num); // This won't change the value in num
  cout<<"After Passing by value with return statement :"<<num<<'\n'; // num = 1
}
// Since it's call by value, you'll need to return the value or else, there won't be any effect.

Call by reference

Call by Reference ကျတော့ actual parameter ကနေ formal parameter
ထဲတန်ဖိုးလွှဲပေးလိုက်တဲ့အခါမှာ value အစား memory address ကိုလွှဲပေးလိုက်တာ။
Variables ရဲ့ တန်ဖိုးတွေက memory address မှာသိမ်းတာတော့သိတယ်မလား။ အဲ့ address ကိုလွှဲပေးလိုက်တော့ subprogram က အဲ့ variable ကို directly access ရသွားတယ်။ call by value တုန်းကလို တစ်ဆင့်ခံမဟုတ်တော့ဘဲ အဲ့တန်ဖိုးသိမ်းထဲတဲ့နေရာကိုယူပြီး calculationsလုပ်လို့ရသွားတာ။ အဲ့တော့ ဘာကွာလဲဆိုတော့ callByReference မှာဆိုရင် return လုပ်စရာမလိုဘဲ actual parameter ရဲ့ တန်ဖိုးကိုပြောင်းလို့ရသွားလိမ့်မယ်။

Example ကိုဘာလို့C++နဲ့ရေးလဲဆိုေတာ့....

Java doesn't support call by reference, so, I wrote it in C++.

Example of Call by Value and Call by Reference

Java Enumeration

Hein Khant Zaw — Sun, 12 Sep 2021 18:45:21 +0000

Java SE 5 တွင် Reference Type အသစ်နှစ်မျိုး ဖြည့်စွက်ခဲ့ပါတယ်။ တစ်မျိုးမှာ class ပုံစံ အသစ်တစ်မျိုးဖြစ်တဲ့ enumeration ဖြစ်ပြီး နောက်တစ်မျိုးကတော့ interface ပုံစံအသစ် တစ်မျိုးဖြစ်တဲ့ annotation ဖြစ်ပါသည်။ Enum ဆိုတာကတော့ Enumeration ကိုအတိုကောက်ခေါ်တာဖြစ်ပါတယ်။ Enum type အမျိူးအစားကိုပြောင်းလဲ၍ မရနိုင်သော const တန်ဖိုးများကိုဖော်ပြရန်ဖြစ်ပါတယ်။ လက်တွေ့မှာတော့ Enumerations များအား Constants များအနေနဲ့ အသုံးပြုတဲ့အပြင် singleton pattern များအား ရေးသားတဲ့အခါမှာလည်း အသုံးပြုကြပါတယ်။

Java မှာ Enumeration မပါလာခင်တုန်းက Constants တွေအသုံးပြုချင်တယ်ဆိုရင် static final variable များကို အသုံးပြုခဲ့ကြရပါတယ်။ အထက်ပါ code example မှာဆိုရင် Level အတွက် LOW, MEDIUM, HIGH ၏ တန်ဖိုးများကို static final variable များအဖြစ် အသုံးပြုခဲ့ပါတယ်။ အဲ့လိုအသုံးပြုတဲ့အခါ level ၏တန်ဖိုးမှာ int ဖြစ်တဲ့အတွက်ကြောင့် သတ်မှတ်ထားတဲ့ constant တန်ဖိုးများအပြင် အခြားသော int တန်ဖိုးများကိုလည်း အစားထိုး အသုံးပြုလို့ရနေပါတယ်။ System.out.println() နဲ့ output ထုတ်ပြတဲ့အခါမှာလည်း level အမျိုးအစားကိုထုတ်ပေးမှာမဟုတ်ဘဲ သတ်မှတ်ထားတဲ့ integer ရဲ့တန်ဖိုးကိုသာ ထုတ်ပေးမှာဖြစ်ပါတယ်။

အထက်ပါ အဆင်မပြေမှုတွေအားလုံးကို Enumeration အသုံးပြု၍ အခုလိုဖြေရှင်းနိုင်ပါလိမ့်မယ်။

Enums in if Statements

Enum အမျိူးအစားက constants တွေဖြစ်တဲ့အတွက် Program ထဲမှာရှိတဲ့ variables တွေနဲ့ enum constants တွေနဲ့ တိုက်စစ်ရတဲ့ အခြေအနေမျိုးတွေရှိပါတယ်။
အောက်မှာတော့ Enum ကို if statements တွေထဲမှာ ဘယ်လိုအသုံးပြုလို့ရလဲဆိုတာကို ဖော်ပြထားပါတယ်။

Enum ထဲမှာပါတဲ့ constants တန်ဖိုးတွေများရင်တော့ if statements တွေအစား switch statements ကိုအောက်ပါအတိုင်း အသုံးပြုနိုင်ပါတယ်။

Level level = ...  //assign some Level constant to it

switch (level) {
    case HIGH   : ...; break;
    case MEDIUM : ...; break;
    case LOW    : ...; break;
}

Enum Iterations

Enum ထဲက တန်ဖိုးတွေကို Iterations လုပ်ရမယ့် ကိစ္စမျိုးတွေကြုံလာရင်အောက်ပါအတိုင်း ရေးလို့ရပါတယ်။

အထက်ပါ code ထဲမှာပါတဲ့ values() method က Enum type ထဲမှာပါတဲ့ method တစ်ခုဖြစ်ပြီး သူက enum constant တွေပါတဲ့ array တစ်ခုကို return ပြန်ပေးပါတယ်။
အဲ့ array ကိုမှ Enhanced for loop နဲ့ပတ်ပြီး output ထုတ်လိုက်တဲ့အခါ အောက်ပါအတိုင်း ထွက်လာပါလိမ့်မယ်။

HIGH
MEDIUM
LOW

Enum Methods

Enum ထဲမှာ Methods တွေကိုလည်းထည့်သွင်းရေးသားနိုင်ပါတယ်။ Example အနေနဲ့ Enum ထဲမှာ constructor နဲ့ getter method ဘယ်လိုရေးလို့ရလဲဆိုတာကိုပြောပြပါမယ်။

ဒီ code ကိုကြည့်မယ်ဆိုရင် main method ထဲမှာ enum level ကို HIGH ပေးထားလိုက်တော့ enum ထဲက constructor က levelCode constant ကို 3 အဖြစ်တန်ဖိုးထည့်ပေးလိုက်ပါတယ်။ နောက် line မှာတော့ getLevelCode() ဆိုတဲ့ getter method နဲ့ level ရဲ့တန်ဖိုးကိုယူပြီး print ထုတ်လိုက်တော့ output မှာ 3 ထွက်လာမှာဖြစ်ပါတယ်။

Enum ထဲတွင် getter/setter methods များသာမက enum constant ၏ field တန်ဖိုးများကို အခြေခံပြီး တခြားသော methods များကိုလည်းဖန်တီးရေးသားနိုင်ပါတယ်။

Enum Abstract Methods

Enum class ထဲမှာ Abstract methods များလည်းရေးသားလို့ရပါတယ်။ တကယ်လို့ ကိုယ်က Enum class ထဲမှာ Abstract method တွေထည့်ရေးထားမယ်ဆိုရင် အဲ့ enum class ထဲမှာပါတဲ့ constant တစ်ခုချင်းစီတိုင်းမှာ abstract method တွေကို override လုပ်ပေးပြီး ရေးသားပေးဖို့တော့လိုပါလိမ့်မယ်။ ဥပမာ အားဖြင့် အောက်က example ကိုတစ်ချက်ကြည့်ပေးပါ။

Enum class ရဲ့ အောက်ဆုံးမှာ abstract method ကြေငြာထားတာကိုသတိထားမိကြမယ်ထင်ပါတယ်။ ဒီ example မှာတော့ HIGH, MEDIUM, LOW တစ်ခုချင်းစီအတွက် asLowerCase() ဆိုတဲ့ abstract method ကို override လုပ်ထားတာကိုတွေ့ရမှာဖြစ်ပါတယ်။ အဆိုပါ abstract method မျိူးကိုဘယ်အချိန်မှာအသုံးပြုသင့်လဲဆိုတော့ Enum class ထဲက constant တွေအတွက် မတူညီတဲ့ methods များရေးရန်လိုအပ်လာတဲ့အခါမှာ အသုံးပြုနိုင်ပါတယ်။

ဆိုတော့ Enum နဲ့ပတ်သက်တာကတော့ဒီလောက်ပါပဲ။ Java Enum နဲ့ပတ်သက်တဲ့ exercises တွေကို ဒီ link ထဲမှာဝင်လေ့လာလို့ရပါတယ်။

Java Conditional Statements

Hein Khant Zaw — Mon, 05 Jul 2021 07:32:38 +0000

Conditional statement ဆိုတာက program အခြေအနေတွေကိုစစ်ဆေးပြီး မှန်ရင်ဘယ်ဟာလုပ် မှားရင်ဘယ်ဟာလုပ် ဆိုပြီး program အသွားအလာကို ထိန်းချုပ်ပေးတဲ့ statement ဖြစ်ပါတယ်။ တနည်းအားဖြင့် အခြေအနေမှန်မမှန် (Boolean တန်ဖိုး true / false) ကို စစ်ဆေးပေးခြင်းဖြစ်ပါတယ်။ Conditional statements တွေကို ဘယ်လိုနေရာမှာသုံးလဲဆိုတော့ နံပါတ်တစ်ခုကို စုံကိန်းလား မကိန်းလား ခွဲတာမျိုးတို့ user ကဘာလုပ်ရင် program မှာဘာဖြစ်မယ်ဆိုတာ မျိုးတို့ မှာ အသုံးပြုပါတယ်။
Conditional statement အမျိုးအစားတွေကတော့

if statement
switch statement တို့ပဲဖြစ်ပါတယ်။

if Statement

if statement ကိုအောက်ပါအတိုင်းထက်ခွဲထားပါတယ် -

if
if/else
if/else if/else
nested if

ရိုးရိုး if statement ကတော့ if ထဲမှာရှိတဲ့ condition က true ဖြစ်ခဲ့ရင် if block ထဲမှာရှိတဲ့ operation ကိုအလုပ်လုပ်ပါတယ်။

Syntax:

if (condition) {
//code to be executed
}

Example:

အထက်ပါ example မှာဆို age ဆိုတဲ့ integer variable ကို 20 တန်ဖိုးပေးထားပါတယ်။ နောက်တစ်လိုင်းမှာ if condition ကိုမှန်မမှန် အရင်စစ်ပါတယ်။ ပထမ တစ်ခုမှာ မှန်တဲ့အတွက် if block ထဲက System.out.print("Age is greater than 18"); ကိုအလုပ်လုပ်ပါတယ်။
အဲ့တော့ output မှာ Age is greater than 18 ဆိုပြီး ထွက်သွားတာကိုတွေ့ရပါမယ်။
တကယ်လို့ age ကို 18 ထက်ငယ်တဲ့တန်ဖိုးပေးပြီးပြန် run ကြည့်လိုက်ရင် if condition မှားသွားတဲ့အတွက် ဘာမှထွက်လာမှာမဟုတ်ပါဘူး။
အဲ့တော့ if statement ကို ကိုယ်လိုတဲ့ condition အတိုင်းမှန်ရင် အလုပ်တစ်ခုခုလုပ်စေလိုတဲ့အခါမျိုး မှာအသုံးပြုသင့်ပါတယ်။

if/else Statement

if/else statement က if statement နဲ့ပုံစံဆင်တူပါတယ်။ မတူတာကတော့ if statement က မှန်ခဲ့ရင်ဘာအလုပ်လုပ်မလဲဆိုတာကိုပဲညွှန်ကြားနိုင်ပြီး မှားခဲ့ရင် ဘာလုပ်ရမလဲဆိုတာကို ညွှန်ကြားလို့မရပါဘူး။ အဲ့အတွက်ကြောင့် if-else statement မှာဆို condition မှန်ခဲ့ရင် if block ကအလုပ်လုပ်မှာဖြစ်ပြီး condition မှားခဲ့ရင်တော့ else block ကအလုပ်လုပ်မှာဖြစ်ပါတယ်။

Syntax:

if (condition) {
//code to be executed if condition is true
} else {
//code to be executed if condition is false
}

Example:

အပေါ်က code example မှာဆိုရင် number variable မှာ 13 လို့တန်ဖိုး သတ်မှတ်ထားပြီး if-else condition မှာ number ကို ၂ နဲ့စားလို့ သုည ကြွင်းရင် စုံကိန်း မဟုတ်ခဲ့ရင် မကိန်းဆိုပြီးတော့ ထုတ်ပေးမှာဖြစ်ပါတယ်။ if ထဲမှာရှိတဲ့ condition က true ဖြစ်ခဲ့ရင် if block ထဲမှာရှိတဲ့ operation ကိုအလုပ်လုပ်ပြီးတော့ false ဖြစ်ခဲ့ရင် else block ထဲမှာရှိတဲ့ operation ကိုအလုပ်လုပ်ပါမယ်။
ဒီ example မှာ number = 13 ဆိုတော့ if ထဲက condition နဲ့မကိုက်တဲ့အတွက် else ထဲက System.out.println("odd number"); ကို အလုပ် လုပ်သွားပါတယ်။

if/else if/else Statement

if/else if/else statement ကတော့ ပထမ condition က false ဖြစ်ခဲ့ရင် ဒုတိယ condition ဆီသွားပါတယ် ဒုတိယ condition က true ဖြစ်ခဲ့ရင်တော့ အောက်မှာရှိတဲ့ condition တွေဆီဆက်မသွားတော့ပါဘူး။ တကယ်လို့ ဒုတိယ condition က false ဖြစ်ခဲ့ရင် တတိယ condition ရှိမရှိကြည့်ပြီး ရှိခဲ့ရင်ဆက်စစ်ပါမယ်။ တတိယ condition မရှိခဲ့ရင်တော့ else ရှိမရှိ ကြည့်ပြီး ရှိခဲ့ရင်တော့ else block ထဲက အလုပ်ကိုလုပ်ပါလိမ့်မယ်။

Syntax:

if (condition1) {  
//code to be executed if condition1 is true  
} else if (condition2) {  
//code to be executed if condition2 is true  
} else if (condition3) {  
//code to be executed if condition3 is true  
}  
//you can add else if as much as you can...  
else {  
//code to be executed if all the conditions are false  
}

Example:

ဒီ program မှာဆိုရင်တော့ int variable mark မှာပေးထားတဲ့တန်ဖိုး အပေါ်မူတည်ပြီး ထုတ်ပေးမှာဖြစ်ပါတယ်။ mark = 65 ဖြစ်တဲ့အတွက် 2nd else if condition နဲ့ကိုက်ညီပြီး အဲ့ block ထဲကအလုပ်ကို လုပ်ဆောင်သွားမှာဖြစ်ပါတယ်။

Nested if Statement

Nested if statement ဆိုတာကတော့ if block ထဲမှာရှိတဲ့ နောက်ထပ် if block တစ်ခုဖြစ်ပါတယ်။ အပြင်ဘက် if ရဲ့ condition က true ဖြစ်မှသာ အတွင်းဘက် if ရဲ့ condition ဆီကိုရောက်မှာဖြစ်ပါတယ်။

Syntax:

if (condition1) {    
    //code to be executed    
    if (condition2) {  
        //code to be executed    
    }    
}

Example:

ဒီမှာဆိုရင်တော့ age = 20 နဲ့ weight = 80 ဆိုတဲ့ int variable ၂ ခု ကြေညာထားပြီး ပထမ if condition မှာ age က ၁၈ နဲ့ အထက်ဖြစ်မဖြစ် (age>=18) ကိုစစ်ထားပါတယ်။ မှန်ခဲ့ရင်တော့ ဒုတိယ if condition ထဲမှာ weight က ၅၀ ထက်များမများ (weigh>50) ကို ထပ်စစ် ထားပြီး နှစ်ခုလုံး ကိုက်ညီမှသာ “You are eligible to donate blood” ဆိုတဲ့စာသားကို output ထုတ်ပေးမှာဖြစ်ပါတယ်။

switch statement

Switch statement ဆိုတာကတော့ if/else if/else statement လိုဘဲ condition အများကြီးကို စစ်ဆေးနိုင်ဖို့အတွက်အသုံးပြုပါတယ်။ ဒါပေမယ့် if/else if/else statement တွေမှာက ကျတော့ condition တွေကို ကိုယ်ကြိုက်သလိုရေးလို့ရပေမယ့် switch statement တွေမှာကတော့ variableရဲ့ value က caseထဲကတန်ဖိုးနဲ့တူမတူစစ်ပြီး operations တွေလုပ်ဆောင်ပေးတာမျိုးဖြစ်ပါတယ်။ switch ထဲမှာ ထည့်စစ်လို့ရတဲ့ data type တွေကတော့ byte, short, char, and int အစရှိတဲ့ primitive data types တွေရယ်၊ Enum နဲ့ String data type တွေထည့်စစ်လို့ရမှာဖြစ်ပြီး case ထဲမှာကတော့ switch ထဲမှာပါတဲ့ datatype အလိုက် value ကိုက်မကိုက်စစ်မယ့် တန်ဖိုးတွေ ရေးပေးရမှာဖြစ်ပါတယ်။ value ကိုက်ညီမယ်ဆိုရင်တော့ ကိုက်တဲ့ case ထဲကအလုပ်ကိုလုပ်မှာဖြစ်ပါတယ်။ case ထဲကအလုပ်ကိုလုပ်ရင်း break keyword တွေ့ရင်တော့ switch statement ထဲကနေ ထွက်သွားမှာဖြစ်ပြီး break မရှိခဲ့ရင်တော့ အောက်မှာ ကျန်သေးတဲ့ case ထဲကအလုပ်တွေကိုပါ ဆက်လက်လုပ်ဆောင်သွားမှာဖြစ်ပါတယ်။

default ဆိုတာကတော့ case ထဲကvalueတွေလုံးဝမတူညီတဲ့အချိန်မှာလုပ်ရမယ့် အလုပ်တွေကို ရေးရမှာဖြစ်ပါတယ်။

Syntax:

switch(expression){    
case value1:    
 //code to be executed;    
 break;  //optional  
case value2:    
 //code to be executed;    
 break;  //optional  

//can add more cases.....

default:     
//code to be executed if all cases are not matched;    
}

Example:

ဒီ example မှာဆိုရင်တော့ integer variable တစ်ခုအဖြစ် int number = 20; ဆိုတာကို ကြေညာထားပါတယ်။ switch() ထဲမှာ number variable ကို pass လုပ်ပြီး case ၃ ခုနဲ့ တိုက်စစ်ဆေးပါတယ်။ ပထမ case မှာဆိုရင် number တန်ဖိုးက ၁၀ နဲ့ညီတဲ့အခါမှာ System.out.println("10"); ဆိုတဲ့ operation ကိုအလုပ်လုပ်ပါလိမ့်မယ်။ ဒါပေမယ့် အခု number ရဲ့တန်ဖိုးက 20 ဖြစ်နေတဲ့အတွက် ဒုတိယ case မှာ မှန်သွားပါလိမ့်မယ်။ အဲ့တော့ program ကို run လိုက်တဲ့အခါမှာ 20 ဆိုပြီး output ထွက်ပါမယ်။ တစ်ခုသိထားရမှာက တကယ်လို့ ဒုတိယ case မှာသာ break statement မထည့်ထားဘူးဆိုရင်အောက်က တတိယ case အထိပါဆက်သွားမှာဖြစ်ပြီး 30 ကိုပါ output ထုတ်ပေးသွားမှာဖြစ်ပါတယ်။ အဲ့ဒါကြောင့် case တစ်ခုချင်းစီသာ အလုပ်လုပ်လိုပါက case ရဲ့အဆုံးရောက်တိုင်း break; ကိုမဖြစ်မနေထည့်ပေးဖို့ လိုအပ်ပါတယ်။
Default မှာကတော့ အပေါ် မှာ ပြောထားသလိုပဲ case တွေအားလုံး စစ်ဆေးတာ မအောင်မြင်ခဲ့ရင် default ထဲက operations တွေကို အလုပ် လုပ်ပါလိမ့်မယ်။

ဒီလောက်ဆို conditional statements တွေအကြောင်း နားလည်သွားပြီလို့ထင်ပါတယ်။ နောက်တစ်ပိုင်းမှာ loop statements တွေအကြောင်း ဆက်ပြောပြသွားပါမယ်။

Loops in Java

Hein Khant Zaw — Fri, 02 Jul 2021 05:35:32 +0000

Loop ဆိုတာက သတ်မှတ်ထားတဲ့ condition မဖြစ်မချင်း ထပ်ကာထပ်ကာ အလုပ်လုပ်စေဖို့ ညွှန်ကြားပေးနိုင်တဲ့ iteration statement တွေဖြစ်ပါတယ်။
program မှာ loop တွေ ကို ပုံစံ အမျိုးမျိုး သုံးလေ့ရှိပါတယ် ။ ဥပမာ - program ထဲမှာ ၁ ကနေ ၁၀၀ အထိ နံပါတ်များကို print ချင်တယ်ဆိုရင် system.out.println() အကြောင်း ၁၀၀ ရေးရမယ့်အစား loop အခါ ၁၀၀ ပတ်ပြီးထုတ်လို့ရပါတယ်။

Java မှာ

for loop
while loop
do-while loop ဆိုပြီးအဓိက loop သုံးမျိုးရှိပါတယ်။

for loop

for loop ကိုဘယ်အချိန်မှာ အသုံးပြုသင့်လဲဆိုတော့ program ထဲမှာ loop လုပ်ရမယ့် အရေအတွက် အတိအကျသိရင် for loop ကိုအသုံးပြုသင့်တယ်။
for loop ထဲမှာလည်း အမျိုးအစားအလိုက် အောက်ပါ ၃ မျိုးရှိပါတယ်။

traditional for loop
enhanced for loop
labeled for loop

Traditional for loop

Traditional/Simple for loop က counter အပေါ်မှာမူတည်ပြီး loop ပတ်တဲ့ပုံစံဖြစ်ပါတယ်။ သူ့မှာ initialization (စမှတ်) ရယ် condition စစ်ဆေးခြင်း(ဆုံးမှတ်)ရယ် increment/decrement value (ထပ်တိုး/ထပ်လျော့တန်ဖိုး) ဆိုပြီးသုံးခုပါ၀င်ပါတယ်။

Syntax:

for(initialization; condition; increment/decrement){
//code to be executed  
}

ဒါဆိုရင် ဥပမာ တစ်ခုလုပ်ကြည့်ရအောင် ကျွန်တော်တို့ hello world ဆိုတဲ့စာသားကို 10 ခါထုတ်မယ့် program ပေါ့။

ဒီ program မှာ startpoint ဆိုတဲ့ int variable တစ်ခုကိုတည်ဆောက်ပြီး 0 ပေးလိုက်ပါတယ်။ condition ကိုတော့ startpoint က 10 အောက်ငယ်တဲ့အထိအလုပ်လုပ်မယ်လို့ပြောထားပါတယ်။ increment value မှာ startpoint++ လို့ပြောတာက loop တစ်ခါပတ်ပြီးတိုင်း startpoint value ကို 1 တိုးမယ်လို့ပြောထားတာပါ။ ဒီတော့ program flow ကိုကြည့်မယ်ဆိုရင် for loop statement ရောက်တာနဲ့ အရင်ဆုံး startpoint တန်ဖိုး 0 နဲ့စမယ်။ condition ကိုစစ်ဆေးတော့ 10 ထက်ငယ်တယ်။ အဲ့တော့ condition မှန်သွားလို့ loop ထဲဆက်သွားမယ်။ နောက်ပြီး increment/decrement နေရာရောက်တော့ startpoint++ ဆိုတာ ကြောင့်ချက်ခြင်းမတိုးသေးဘဲ loop statement အဆုံးမှ 1 တိုးမှာပါ။တကယ်လို့ ++startpoint ဆိုရင်တော့ ဘာမှမလုပ်ခင် startpoint value အရင်တိုးမှာဖြစ်ပါတယ်။ အဲတော့ဆက်သွားရမယ်ဆိုရင် system.out.println(“hello world”); ဆို တဲ့ output တစ်ခုထွက်လာမယ်။ ပြီးတော့ နောက်ထပ် loop တစ်ခါပတ်တော့ increment value 1 တိုးခဲ့ပြီဖြစ်လို့ startpoint = 1 အဖြစ်နဲ့ condition စစ်ဆေးတယ် 10 အောက်ကငယ်နေသေးတာကြောင့် loop ဆက်သွားမယ် နောက်ထပ် system.out.println(“hello world”); ကို ထပ်ထုတ်မယ်။ ဒီလိုနဲ့ startpoint = 9 အထိပတ်တဲ့ အခါမှာ နောက်ဆုံး 10 ကြိမ်မြောက်ရောက်တဲ့အခါမှာ startpoint < 10 မဖြစ်တော့တာမို့လို့ loop ရပ်သွားပါတယ်။

ဒီနေရာမှာ တစ်ခု ပြောချင်တာက တကယ်လို့ ကိုယ်က decrement value သုံးပြီး loop ပတ်ချင်လည်းပတ်လို့ရပါတယ်။ အဲ့အခါဘယ်လိုပုံစံဖြစ်သွားမလဲဆိုတော့

Infinite for Loop

နောက်တစ်ခုကတော့ ကျွန်တော်တို့ for() ထဲမှာ ဘာမှမကြေညာဘဲ semicolons နှစ်ခုပဲ ရေးထားမယ်ဆိုရင်ကော? ဘယ်လိုဖြစ်သွားမလဲ? အဖြေကတော့ ဒီ loop ဟာ ဘယ်တော့မှ ရပ်တော့မှာမဟုတ်တဲ့ infinite loop ဖြစ်သွားပါလိမ့်မယ် ။ဒါပေမယ့်ရပ်ဖို့အတွက်ကတော့ Ctrl+c (or) Command+c ကိုတွဲနှိပ်ရင်တော့ ရပ်ပါတယ်နော်။

Syntax:

for( ; ; ){
//code to be executed
}

ဒါဆိုရင် သင်မရပ်မချင်း ဘယ်တော့မှရပ်မှာမဟုတ်တဲ့ program တစ်ခုစမ်းရေးကြည့်ရအောင်။

Program run လိုက်မယ်ဆိုရင်တော့ မရပ်ဘဲ run နေတဲ့ loop တစ်ခုကို ရမှာဖြစ်ပါတယ်။ မျက်စိနောက်လောက်အောင်ကိုတက်လာပါလိမ့်မယ်။ Ctrl+c (or) Command+c သာနှိပ်လိုက်ပါ။

Nested for Loop

Nested Loop ဆိုတာ Loop ထဲမှာ Loop တွေထပ်ပတ်ထားတဲ့ဟာပါ။ အများဆုံးကတော့ for loop တွေမှာတွေ့ရပါတယ်။ကျွန်တော်တို့ nested loop တွေကိုတစ်ချက်ရေးကြည့်ကြရအောင်။

ဒီ program မှာ for loop နှစ်ခါပတ်ထားပါတယ်။ ပထမ for loop မှာက အရင်ဆုံး i တန်ဖိုးနဲ့ ပတ်တာပါ။ i < 5 ဆိုတော့ 5 ခါပေါ့။ အဲ့ဒီ i နဲ့ပတ်တဲ့ for loop ထဲမှာမှ j နဲ့ထပ်ပတ်တာပါ j < 5 ကလည်း j ကို ၅ခါထပ်ပတ်ထားပါတယ်။ အဲဒီတော့ i loop တစ်ခါပတ်တိုင်း j loop ထဲမှာ ရှိတဲ့ အလုပ် ၅ ခုလုပ်ပါတယ်။ j loop ထဲကိုကြည့်လိုက်ရင် System.out.print("*"+" "); ဖြစ်တဲ့အတွက် * ငါးခုကို ဘေးတိုက် * * * * * ဆိုပြီး output ထွက်ပါမယ်။ သူ အောက်မှာမှ i loop ထဲမှာ println() ရေးထားတဲ့အတွက် နောက်တစ်ကြောင်းဆင်းသွားပါမယ်။ ဒီလိုနဲ့ i loop ၅ပတ်လည်း ပြည့်ရော * * * * * ငါးကြောင်း output ထွက်လာပြီး လေးထောင့်တုံးပုံစံတွေ့ရမှာဖြစ်ပါတယ်။

ဒါကတော့ traditional for loop အသုံးပြုနည်းဖြစ်ပါတယ်။

Enhanced For Loop

Enhanced For Loop(For-Each Loop) ကို array (သို့) collection တွေကိုမှာ အသုံးပြုလေ့ရှိပါတယ်။ ဘာလို့လဲဆိုတော့ အဲ့ loop က increment value မလိုအပ်သလို တခြားဘာမှလည်းမလိုအပ်ပါဘူး။ For-Each Loop က array ရဲ့ index ပေါ်မှာ အလုပ်လုပ်တာမဟုတ်ဘဲ elements တွေပေါ် မှာလုပ်တာဖြစ်ပါတယ်။ ဒီ Loop ကိုသုံးလိုက်တဲ့အခါမှာ array ထဲက elements တွေကို သတ်မှတ်ထားတဲ့ variable ထဲကို တစ်ခုချင်း return ပြန်ပေးသွားမှာဖြစ်ပါတယ်။

Syntax:

for(dataType variable: array_name){
//code to be executed;
}

Example တစ်ခုရေးကြည့်ရအောင်

ဒီ example မှာဆို ကျွန်တော်က arr လို့ခေါ်တဲ့ integer array တစ်ခုကို တည်ဆောက်ထားတယ်။ အဲဒီထဲမှာ integer value တွေဖြစ်တဲ့ 12,23,44,55,44,66 သိမ်းထားပါတယ်။ အဲဒါကို For-Each Loop နဲ့ loop ပတ်ဖို့အတွက် for() ထဲမှာ int i ဆိုပြီး variable တစ်ခုကိုတည်ဆောက်ပါတယ် ပြီးတော့ ကျွန်တော်တို့ရဲ့ array နာမည်ကိုထည့်ပေးလိုက်တာပါဘဲ ဒီတော့ ဘယ်လိုဖြစ်သွားလဲဆိုတော့ loop ပတ်တဲ့အခါမှာ array ထဲမှာရှိတဲ့ elements တွေက ကျွန်တော်တို့တည်ဆောက်ထားတဲ့ variable i ထဲကိုရောက်ပြီး return ပေးပါတော့တယ် ဒီတော့ ကျွန်တော်တို့ array ထဲက element တွေ output ထွက်လာပြီဖြစ်ပါတယ်။

Labeled For Loop

Labeled For Loop ကတော့အသုံးနည်းတဲ့ loop တစ်ခုပါ။ သူကကျတော့ loop တစ်ခုချင်းစီကို label ပေးလို့ရတဲ့ loop ဖြစ်ပါတယ်။ ရေးရမယ့် ပုံစံကတော့ for loop မတိုင်မီ label (နာမည်) တစ်ခု အရင်ပေးရပါတယ်။ အကယ်၍ program ထဲမှာ nested for loop ရှိပါက loop တစ်ခုချင်းစီကို label တပ်ပြီး break/continue keyword တွေနဲ့ control လို့ရပါတယ်။

Syntax:

labelName:  
for(initialization; condition; increment/decrement){  
//code to be executed  
}

Example:

ဒီမှာဆိုရင် အပြင်ဘက်က i နဲ့ပတ်တဲ့ loop ကို aa လို့ label တပ်ထားပြီး အထဲက j နဲ့ပတ်တဲ့ loop ကိုတော့ bb ဆိုပြီး label တပ်ထားပါတယ်။ bb loop ထဲမှာ if(i==2 && j==2) ဆိုတဲ့ condition တစ်ခုစစ်ပြီး တကယ်လို့ condition ကိုက်ညီတယ်ဆိုရင် break aa; ဆိုပြီး aa loop ကို break လုပ်ထားပါတယ်။ break statement ဆိုတာကတော့ loop block တွေထဲမှာ အကြောင်းတစ်မျိုးမျိူးကြောင့် break statement ကိုရောက်ပြီဆိုတာနဲ့ လက်ရှိ loop ကနေ ထွက်ပေးနိုင်ပါတယ်။ အထက်ပါ example မှာဆိုရင် i နဲ့ j တန်ဖိုးနှစ်ခုစလုံး 2 နဲ့ညီသွားတဲ့အခါ aa loop ကို break statement နဲ့ရပ်လိုက်မှာဖြစ်ပါတယ်။ အဲ့တော့ output ထွက်တဲ့အခါ i = 1 မှာ j နဲ့ပတ်တဲ့ bb loop က သုံးကြိမ် အထိပတ်ပြီး i = 2 ဖြစ်တဲ့အချိန်မှာ bb loop ထဲမှာ j = 1 အထိပဲ output ထွက်မှာကို မြင်တွေ့ရပါလိမ့်မယ်။

For Loop တွေအကြောင်း ကတော့ ဒီမှာ ပြီးပါပြီ။

While Loop

While Loop ကို ကျွန်တော်တို့ program ထဲက condition တစ်ခုဟာမှန်နေသရွေ့ ထပ်ကာထပ်ကာအလုပ်လုပ်စေလိုသောအခါ အသုံးပြုပါတယ်။ ပြီးတော့ ဒီ while loop ကို အကြိမ်အရေအတွက် အတိအကျမရှိတဲ့ loop တွေအတွက်အသုံးပြုကြတာ ဖြစ်ပါတယ်။ ပြီးတော့ဘယ်တော့မှမရပ်တဲ့ Loop တွေအတွက်လဲ အသုံးပြုနိုင်ပါတယ်။

Syntax:

while(condition){
//code to be executed
}

Example:

ဒီမှာ While Loop ကို တည်ဆောက်ဖို့အတွက် while ကိုရေးပြီး condition ထည့်ရပါတယ် သူ့ထဲက အခြေအနေ မှန်ကန်နေသရွေ့ ကျွန်တော်တို့ Loop က အလုပ်လုပ်နေအုန်းမှာပါ။ ဒါပေမယ့် ဒီမှာ for လို တစ်ခါထဲတည်ဆောက် လိုက်လို့မရဘူး။ int i = 1 ဆိုတာ အရင်ဆုံးကြေညာပြီး while loop ထဲမှာ ဘယ်အောက်ငယ်တဲ့ အထိဆိုပြီး condition တစ်ခုသတ်မှတ်ပေးရတယ်။ အခု i<=5 ဆိုတော့ i က 5 နဲ့ညီတဲ့ အထိ loop ပတ်မယ်ဆိုပြီး ရေးလိုက်တာဖြစ်ပါတယ်။ပြီးတော့ တန်ဖိုးတိုးသွား မယ့် i ကို output ထုတ်ပါတယ် ပြီးတော့ counter တိုးဖို့ လျော့ဖို့အတွက် increment/decrement ကိုရေးဖို့လိုပါသေးတယ်။ ဒီတော့အောက်မှာ i++; ဆိုပြီးရေးပေးရပါတယ်။

Infinite While Loop

Infinite While Loop ရဖို့က Condition နေရာမှာ true လုပ်ထားလိုက်ရုံပါပဲ။ အဲ့လိုသာရေးထားလိုက်မယ်ဆိုရင် ဘယ်တော့မှ while loop ထဲက ထွက်နိုင်မှာ မဟုတ်တော့ပါဘူး။
ထွက်ချင်ရင်တော့ ခုနက Infinite for Loop တုန်းကလိုပဲ Ctrl+c ကိုတွဲနှိပ်လိုက်ရုံပါပဲ။

Syntax:

while (true) {
// code to be executed
}

Example:

Do-While Loop

ဒီ Do-While Loop ကလည်း တခြား Loop တွေလိုဘဲ ထပ်ခါထပ်ခါလုပ်မယ့် လုပ်တွေ အတွက်သုံး နိုင် ပါတယ်။ဒါပေမယ့် တစ်ခုရှိတာကတော့ ကျွန်တော်တို့ ထပ်ခါထပ်ခါလုပ်ဖို့ အကြိမ်ရေအတိကျမရှိတဲ့အခါမျိုး နဲ့ condition မမှန်ကန်ခဲ့ရင်တောင် အနည်းဆုံးတစ်ခေါက်ကတော့ လုပ်ကိုလုပ်ရမယ်ဆိုတဲ့အခြေအနေမျိုးတွေအတွက် အသုံးပြုရပါတယ်။

Syntax:

do{
//code to be executed
}while(condition);

သူ့ရဲ့ syntax တည်ဆောက်ပုံအရ condition စစ်ဆေးခြင်းက နောက်မှလာတာဖြစ်တဲ့ အတွက် condition စစ်ဆေးမှုက false ဖြစ်နေခဲ့ရင်တောင် loop က အနည်းဆုံး 1 ကြိမ်တော့အလုပ်လုပ်မှာပါ။
အရင်ဆုံး condition မှန်တဲ့ program တစ်ခုရေးပြီးနောက်မှ condition မှားတာတစ်ခုရေးကြပါမယ်။

ဒီ program က i တန်ဖိုး 5 နဲ့မညီမချင်း အလုပ်လုပ်မယ့် program ဖြစ်ပါတယ်။ ဒါကတော့ခုနက while loop ပုံစံနဲ့အတူတူပဲဖြစ်ပါတယ်။

အခု ကျွန်တော်တို့ condition အမှားတစ်ခုရေးရအောင်။

ဒီမှာဆို condition စစ်ဆေးထားတာက i<=5 ဖြစ်ပါတယ်။ ဒါပေမယ့် အခု i တန်ဖိုးက စကြေညာတည်းက 6 ဖြစ်နေပြီဆိုတော့ ဘယ်လိုနည်းနဲ့မှ condition မမှန်တော့ပါဘူး။ ဒါပေမယ့် do block ထဲက code ကိုတော့ တစ်ကြိမ်အလုပ်လုပ်သွားတာတော့တွေ့ရမှာဖြစ်ပါတယ်။

ကဲ....ဒီလောက်ဆိုရင် loop ကောင်းကောင်းပတ်တတ်သွားပြီထင်ပါတယ်။ အဲ့တော့ ဒီ link ထဲက loop နဲ့ ပတ်သက်တဲ့ exercise လေးတွေလုပ်ကြည့်ရင်ပိုပြီးနားလည်တတ်မြောက်သွားမယ်ထင်ပါတယ်။

Things to know before using public Wi-Fi

Hein Khant Zaw — Sun, 06 Jun 2021 19:39:46 +0000

Accessing wifi is not a problem while you are at home - it’s secure, easy to connect and no strangers are using your home network. However, when you are outside, using public Wi-Fi will give you a nightmare if you aren't aware of the risk of security issues. So, if you are considering whether to connect to the public Wi-Fi network at the shopping mall, the airport, etc. beware of the potential risk to your device because hackers love public Wi-Fi!
Although it’s risky to use Wi-Fi in public, I’m going to explain how to safely use public Wi-Fi services.

Use VPN

The most effective trick to staying safe on public Wi-Fi is to use a VPN on your devices. Although virtual private networks are not infallible, they can protect your privacy. They encrypt data that passes through the network and connect your device to a secure server, making it harder for the hackers on the same network or anyone who controls the network to see what you're doing. So, using a VPN will secure your information from other users of the same connection.

Always HTTPS

When the site you're visiting uses an unencrypted HTTP connection, most of the browsers let you know with the "Not Secure" label beside the URL. Beware of that warning especially if you are connected to public Wi-Fi. When you browse over HTTPS, people on the same Wi-Fi network can’t sniff the data that travels between you and the server of the website you're connecting to. If it’s over HTTP, it’s gonna be very easy for them to track what you're surfing. So, always verify that the website you surf uses HTTPS.

Never give away too much info

It’s better not to access personal bank accounts, or give sensitive personal data (your address, phone number or email, etc.) on public Wi-Fi. If you have no choice, you should consider using an alternative email address or phone number that isn't your primary one. And also, it’s not recommended to do online shopping over public Wi-Fi. Of course, shopping doesn’t seem like a big deal, but making purchases online requires personal information - bank account or credit card numbers.

Don’t let your guard down

Never leave your device unattended in public. Even if you’re on a secure network or unsecured network, that won’t stop someone from taking your device or sneaking a peek at your device.
Always keep your device near you.

If you follow the steps mentioned above, you will have more chances of staying out of trouble while you're using public Wi-Fi. However, Always keep in mind that no public Wi-Fi network is secure and you should always use public Wi-Fi with caution.
And Remember - any device could be at risk too.

Speeding up Android Studio on 4GB RAM

Hein Khant Zaw — Mon, 11 Jan 2021 10:59:38 +0000

Although Android Studio is a powerful IDE, there are many memes about long building time, slow speed, taking huge amount RAM etc.

According to developers.android.com, minimum requirement for android studio is:

4 GB RAM minimum, 8 GB RAM recommended
2 GB of available disk space minimum,
4 GB Recommended (500 MB for IDE + 1.5 GB for Android SDK and emulator system image)
1280 x 800 minimum screen resolution

However Windows usually takes 2GB and Android Studio will alone take up to 1GB and if you run with emulator, it will consume about 1.5GB - 2 GB. So basically, when you try to run Android Studio in Windows with emulator, it's gonna be a very huge pain in the ass.

So, How can we speed up our Android Studio in a laptop with 4GB RAM?
The best way is to upgrade your RAM to 8GB as recommended in official website. (Just kidding..xD I'll be more serious after this).
There are several ways to speed up your Android Studio.
When I learned android development for the first time, my laptop had only 4GB RAM and I went through so much trouble to run an android app. It took about 15 minutes to build gradle and opening the emulator will take about another 15 minutes. So, here comes the tip.

If your laptop has only 4GB RAM, don't run your project with emulator or it will end up in a complete disaster!

Running with a physical device will reduce both your anger and loading time of the android project.
So, I recommend you to use your android device instead of emulator to test the apps.

Another way to speed up android studio is to run it in different OS rather than Windows. As I've said above, Windows OS usually takes 2GB as there are many background processes and system process running in Windows that you can't stop. So, another tip is to dual boot your laptop with a Linux distro or just remove Windows completely and use Linux instead :P
Currently I use Debian OS with Windows dual boot and my laptop RAM is 8GB. According to my experience, starting Android Studio and running an project in Debian is much faster than in Windows.
So, here is another popular tip.

Use Linux. Run Android apps with your android device instead of emulator. Then, 4GB RAM will be sufficient to run smoothly without any lags.

However, if you are too attached to Windows, it's ok. Let it be.
I'll telling another way to speed up Android Studio in your Windows Laptop.

Go to Android Studio first.
Then, click Power save mode. It will reduce lots of background work in Android Studio.

After that , click File > Setting > Plugins .

As I disabled the plugins that I don't need, you won't see so many enabled plugins in my laptop.
However, in you laptop, you will see so many enabled plugins and these are also the things which slows down your IDE. You will see IDE gets slower when adding plugins. So, if you disable all the plugins that you don't use (I know you are not using all these plugins to develop your app), I guarantee that Android Studio will speed up for sure.

I disabled the following plugins in my IDE:

Android APK Support
Android Games
Android NDK
App Links Assistant
Change Reminder
Copyright
Coverage
Editor Config
Firebase App Indexing
Firebase Testing
Google Cloud Tools Core
Google Cloud Tools for Android
Google Developer Samples
Google Login
Google Services
Mercurial
Settings repository
Subversion
Task management
Test recorder
TestNG
YAML After that, click Apply and restart your Android Studio.

But wait. What if you need Any Plugin Later?
Easy Buddy! Relax.
For example, if you are adding google services or firebase in your app in the future, just go back to plugins and enable again.

If you are also using any antivirus, make sure to add Exception of all android studio directories. So it won’t scan those folders while you are using Android Studio. This will make it even faster.
As for default Windows Defender, you can follow this guide to add exception for Android Studio.

You can follow these tips from official documentation to improve the build speed of your Android Studio project.

Here's my final tip 😛:

Hope you guys won't suffer from Android Studio nightmares. Peace <3

Introduction to Android Lifecycle

Hein Khant Zaw — Sat, 09 Jan 2021 03:48:32 +0000

The android activity lifecycle includes the following callbacks: onCreate(), onStart(), onResume(), onPause(), onStop(), onRestart(), and onDestroy().

onCreate()

The lifecycle of an android activity begins here. This is where any layout resources (Buttons, textViews, editText, etc.) and background threads are initialized.

onStart()

Called right after onCreate(). In this state the activity becomes visible to the user.

onRestart()

Called after an activity has been stopped. This call reverts the activity to its visible lifetime.

onResume()

Called when the user returns to an activity after briefly exiting it. The app stays in this state until something happens to take focus away from the app. Such an event might be, for instance, receiving a phone call, the user’s navigating to another activity, or the device screen’s turning off.

onPause()

Called when the user leaves the current activity to another activity or leaves the app for a while. It indicates that the activity is no longer in the foreground and certain processes that are not needed while the activity is not in the foreground will be stopped.

onStop()

Called when the activiy becomes invisible to the user. The activity and its resources may still be running in the background even though it is not visible. After onStop() is called, the activity will call onRestart() if it needs to be loaded again.

onDestroy()

The end of the activity lifecycle. This activity is used to stop all resources and tasks started in onCreate(). After onDestroy() is called, the activity will call onCreate() if it needs to be loaded again.
The system invokes this callback either because:

The activity is finishing (due to the user completely dismissing the activity or due to finish() being called on the activity), or
The system is temporarily destroying the activity due to a configuration change (such as device rotation or multi-window mode)

You can learn more about android life cycle here !

How encryption algorithms provide confidentiality

Hein Khant Zaw — Mon, 04 Jan 2021 13:46:25 +0000

As computer networks becomes essential in everyday life, it is important to secure every aspect of data and information online. This is where encryptions algorithms become useful. Once data is encrypted, only authorized parties who have a “key” can read it or use it. It means that if the encryption method is effective, it will completely protect data from unauthorized access. This necessarily requires that the message be somehow encrypted so that in case if the message is intercepted, it cannot be understood by eavesdroppers. This aspect of confidentiality is probably the most commonly perceived meaning of the term secure communication.

So, how encryption algorithms provide confidentiality? First of all, there are two classes of encryption algorithms – Symmetric Encryption Algorithm and Asymmetric Encryption Algorithm.

Symmetric Encryption Algorithm includes DES, AES, etc.
Asymmetric Encryption Algorithm includes RSA, Diffie–Hellman, etc.

Although, all these algorithms involve substituting one thing for another (e.g., taking a piece of plaintext and then substituting the appropriate ciphertext to create the encrypted message), Symmetric Encryption Algorithm use the same cryptographic key for encrypting and decrypting information, whereas Asymmetric Encryption Algorithm use a private key and a public key for encryption and decryption.

Symmetric Encryption Algorithm

Let’s begin with Symmetric Encryption Algorithm which is also known as shared secret key algorithm. As it is symmetric encryption, the sender and receiver use a pre-shared secret key and the length of the key is usually between 80 to 256 bits. These kinds of algorithm are faster than Asymmetric Encryption Algorithm because they base on simple mathematical operations. Let’s examine how symmetric key encryption is done today. There are two broad classes of symmetric encryption techniques: stream ciphers and block ciphers.

In Block cipher technique, encryption is done in blocks of k bits. If k = 64, then the message is broken into 64-bit blocks, and each block is encrypted independently. The example of a 64-bit block cipher is shown in the following figure.

Today, there are a number of popular block ciphers, including DES (Data Encryption Standard), 3DES, and AES (Advanced Encryption Standard).

DES uses 64-bit blocks with a 56-bit key. The resource consumption of DES algorithm is medium and it would take approximately 6.4 days to crack a DES key.
3DES was developed as a more secure alternative because of DES’s small key length. In 3DES, the DES algorithm is run through three times with three keys and it will take 4.6 billion years to crack with current technology.
AES uses 128-bit blocks and can operate with key that are 128, 192, and 256 bits long. Resource consumption of this algorithm is low and would take approximately 149 trillion years to crack a 128-bit AES key.

Due to the larger fixed-length input, block ciphers are generally slower than stream ciphers.

In Stream cipher, encryption is done one bit at a time. For Encryption, the plaintext will undergo XOR operation with keystream bit-by-bit and produces the Cipher Text. For Decryption, the ciphertext will undergo XOR operation with keystream bit-by-bit and produces the original plain text. This type of encryption is not that common. Block ciphers are used much more frequently for symmetric encryption.

Asymmetric Encryption Algorithm

Asymmetric Encryption Algorithm, also known as Public Key Encryption, works in a similar manner to symmetric-key algorithms, where plaintext is combined with a key, input to an algorithm, and outputs ciphertext. The only difference is that the keys used for the encryption and decryption are different, unlike Symmetric Encryption Algorithm. Hence the name itself imply the asymmetry of the algorithm. The key pair is comprised of a private key and a public key. The public key is made available to everyone, whereas the private key is kept secret. Below is the illustration of how Asymmetric Encryption Algorithm provide confidentiality.

The concept of Asymmetric Encryption Algorithm is quite simple. Suppose Alice wants to communicate with Bob. As shown in the figure, rather than Bob and Alice sharing a single secret key (as in the case of Symmetric Encryption Algorithm), Bob (the recipient of Alice’s messages) instead has two keys—a public key that is available to everyone in the world and a private key that is known only to Bob. In order to communicate with Bob, Alice first fetches Bob’s public key. And then she encrypts her message, m, using Bob’s public key. After that, Bob receives Alice’s encrypted message and uses his private key to decrypt Alice’s encrypted message. This is how asymmetric encryption algorithm works. While there may be many asymmetric encryption algorithms, the RSA algorithm (named after its founders, Ron Rivest, Adi Shamir, and Leonard Adleman) has become almost synonymous with public key cryptography.

First, each entity needs to set up their own key pairs and share the public key with one another. The two entities need to keep their private keys secret in order to keep their communications to remain secure. Once the sender has the public key of their recipient, they can use it to encrypt the data that they want to keep secure. Once it has been encrypted with a public key, it can only be decrypted by the private key from the same key pair. Even the same public key can’t be used to decrypt the data because RSA encryption works under the premise that the algorithm is easy to compute in one direction, but almost impossible in reverse. When the recipient receives the encrypted message, they use their private key to access the data. If the recipient wants to return communications in a secure way, they can then encrypt their message with the public key of the party they are communicating with. Again, once it has been encrypted with the public key, the only way that the information can be accessed is through the matching private key. In this way, RSA encryption can be used by previously unknown parties to securely send data between themselves.

Another popular algorithm is the Diffie-Hellman Algorithm (also known as DH). The main purpose of the Diffie-Hellman key exchange is to securely develop shared secrets that can be used to derive keys. These keys can then be used with symmetric-key algorithms to transmit information in a protected manner. Symmetric algorithms tend to be used to encrypt the bulk of the data because they are more efficient than public key algorithms. Technically, the Diffie-Hellman key exchange can be used to establish public and private keys. However, in practice, RSA tends to be used instead. This is because the RSA algorithm is also capable of signing public-key certificates, while the Diffie-Hellman key exchange is not. And also, Diffie-Hellman algorithm is not as versatile as RSA as it cannot be used to encrypt messages of arbitrary length.

As a conclusion, the need for secure communication and information is important for the success of every enterprise. Therefore, people use different encryption algorithms to provide confidentiality of data. As explained above, two cryptographic techniques for encrypting and decrypting data are symmetric key cryptography (shared secret key) and asymmetric key cryptography (public key and private key). DES and RSA are shown as an example for these two major classes of cryptographic techniques used in today’s networks.

2020 Hacktoberfest swag unboxing

Hein Khant Zaw — Fri, 18 Dec 2020 11:32:20 +0000

Hello everyone! Today, I received my 2020 Hacktoberfest package from Kotis Design.
A few months back, in October, I joined Hacktoberfest which is a month long open-source event.

To explain what Hacktoberfest is, it's a perfect opportunity for students learning to code and for those who wanna get their feet wet in the ocean of open-source software development.

During this event, they can learn about OSS development, git and Github. At least 4 pull requests must be submitted to public GitHub repositories to earn a free T-Shirt and stickers.

Enough talking! Let's unbox the package!!

So here we go! Here is the package.

I am going to unbox it quickly so you can see what's inside the package.

What's inside?

So, a T-shirt. You can't see clearly here but the fabric feels so soft and nice - Medium quality, neither cheap nor expensive.

Two cards from sponsors (Intel and Dev).

And...

So, many stickers! I didn't expected that much to be honest. There are altogether 14 stickers from sponsors such as DEV, JetBrains, circleCI, Github, etc.

And here is a promo code from Digital Ocean! This code can be used to get $100 credits in Digital Ocean (only for new users ☹️)

Ok. Now, it's time to add these cool stickers to my laptop 😉

So, that's it! If you want these cool stuffs, I highly recommend you to participate in next year Hacktoberfest. You can sign up anytime between October 1 and October 31 every year!

May open source be with you....

Github Universe 2020 is live now

Hein Khant Zaw — Tue, 08 Dec 2020 19:00:06 +0000

Guys! Don’t miss a minute of Github Universe 2020. The sessions are worth listening. For those who don't know what Github universe is, it is an annual community event hosted by Github. This year, the event is virtually hosted due to COVID-19 pandemic.

The sessions are grouped into four channels : Developer, Enterprise, Univers(ity) and Play.

Here is a brief explanation about each channel (resources from github universe FAQs):

Developer: geared towards open source contributors and maintainers running projects of all sizes, as well as developers looking to understand the latest software tools, techniques, and best practices.
Enterprise: tailored for senior leaders and decision-makers from global companies interested in transformation, security, scalability, and productivity.
Univers(ity): designed specifically for college students seeking the tools, techniques, and connections that will help expand their resumes and prepare them for their future.
Play: take a break, get inspired, or discover something new with entertaining performances, tutorials, and unexpected stories, all driven by code.

This event will be hosted for three days (Dec 8 - Dec 10). So, I hope you learn something from the sessions that you find interesting.

Algorithm design and optimization for beginners

Hein Khant Zaw — Sun, 06 Dec 2020 08:07:25 +0000

Hi! This is my first post on DEV. I’m going to tell why you should optimize algorithms. As an example, I will show how to design algorithm for maximum pairwise product which is pretty basic. I’ll explain how to design algorithm for this problem and optimize until we get an efficient one. So, Let’s get started!

Understand Problem Statement

First of all, “What is maximum pairwise product” problem? Well, the problem is to find a highest product value in a sequence of non-negative integers.

Just for clarification,

Input: A sequence of non-negative integers.

Output: The maximum value that can be obtained by multiplying two different elements from the sequence.

Sample:

Design the algorithm

Ok! So, let’s start with the simplest algorithm first. It is to go through all possible pairs of the input elements A[1 . . . n] = [a 1 , . . . , a n ] and to find a pair of distinct elements with the largest product.

Here is the pseudocode of the above algorithm:

Implement the Algorithm

According to the pseudocode, we'll implement the algorithm in java as follows:

Test, Debug and Optimize

Test

Check this code on a small datasets such as [1, 3, 4, 6] to ensure that it produces correct results. Then try an input [100000, 100000]. According to the algorithm, the output should be 10000000000. But wait...what happened?? The program fails to give an output for 100 000 * 100 000 and it gives 1,410,065,408 instead of the correct result 10,000,000,000. You know why?

Debug

Well, this kind of error is probably caused by an Integer Overflow. Integer overflows cannot be detected until they have happened. That's why, we should always keep in mind about overflow errors in programming. So as you can see, this algorithm only works for small data and therefore, we need to assign another data type for large datasets. We are going to use long here.

Optimize

Everything works well now. But you think it'll work fast and correctly when there are billions of input? As we can see there's two nested for loops for finding maximum pairwise product, this still is an O(n²) algorithm. So it still has an ugly running time. For large datasets, it will take for a long time to complete. WE NEED A FASTER ALGORITHM!

Stop and Think for a while. What if we find only the two largest numbers in the array and multiply them instead of multiplying each and every single possible combination.

Since we need to find the largest and the second largest numbers of the array, we'll only need two scans of the sequence.

During the first scan, we find the largest number.
During the second scan, we find another largest number among the remaining ones and skip the number found at the previous scan.
Finally multiplying both numbers and return the result

This reduces the complexity of algorithm to O(n) and our algorithm is much optimized.

The pseudocode will be changed like this:

Here is the code for the optimized algorithm.

Stress Testing

After doing optimization,testing and debugging, it is also required to test beyond the limits of normal operation. Writing bug-free code is impossible. There is no such thing like this but you can somehow minimize the volume and the severity of the bugs present in your code. Always remember, your algorithm can sometimes fail for some test cases and you will need to know which are those cases. This is where stress testing technique becomes useful. So, what's stress testing and why do we need it? To explain, it is a technique for generating thousands of tests with the goal of finding a situation where the algorithm fails to give the correct output.

Basically, a stress test consists of:

At least two different implementations of an algorithm (For our scenario, one is the simple brute force algorithm and the other is the optimized algorithm)
A random test generator.
An infinite loop in which random test generator generate a new test case, pass into both implemented algorithms and compare the results. If the results are different, the program stops, else, the loop repeats.

For our case, we create a infinite while loop and then generate arrays with random size and assign each array with random numbers. After that, we pass the array to both implementations and then compare the results.

Here is the stress test for the algorithm:

After running the code, you will see a test case where getMaxPairwiseProduct and MaxPairwiseProductFast produce different results, so now we can check what went wrong. Can you find anything suspicious in the dataset of different results?

Well, the bitter truth is that generating tests automatically and running stress test is easy,
but debugging is hard, right?

Take a look at this stress test result(the result can be different on your computer because of a different random number generator):

As you can see, the simple brute force algorithm gave the correct result but the optimized algorithm didn't. Why? To make a long story short, the optimized one doesn't work when the maximum numbers have the same value. The algorithm always fails on any test case where the largest number is equal to the second largest number.

So, although, the first algorithm works correctly, it becomes really slow when dealing with very large datasets. The second algorithm, however, is fast but doesn't work for the above cases in stress test.

What should we do now??

Ok. We just need to go back to our optimized algorithm and check the process again. And .. here we go! The condition that checks the second largest number is the reason of the wrong result!

So, we are changing that code to make it correct.
Here is the final code:

Run the stress test again and wait for a minute until we get bored. You will see there's no different results anymore.

MaxPairwiseProductFast algorithm is finally correct and optimized!

As for the final conclusion, even for such a simple problem like this, it is easy to make mistakes during algorithm designs and optimization. But practice makes perfect 😉. There are many ways to find the solution to this problem so I hope you can find more efficient algorithm than the example one.

Thank you very much for giving your time to read my post and please forgive me if my writing is too boring or too complicated. I'll try my best to write more blog post in the future 😃