DEV Community: JohnOdhiambo

Run Docker on WSL without Docker Desktop

JohnOdhiambo — Fri, 03 Oct 2025 09:14:25 +0000

You need to have first install WSL and Ubuntu, Debian or any other Linux Distribution of your preference on your windows computer.
To install the Docker Community Engine, run the following scripts

Update your package lists and upgrade existing packages

$ sudo apt update && sudo apt upgrade -y

Install necessary packages to allow apt to use repositories over HTTPS

$** sudo apt install apt-transport-https ca-certificates curl software-properties-common -y**

🐳 Download and save Docker’s official GPG key

$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | \
sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

🐳 Add Docker’s stable repository to your APT sources list

$ echo "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] \
https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | \
sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Update package index again, now with Docker packages included

$ sudo apt update

🐳 Finally, install the Docker Engine

$ sudo apt install docker-ce -y

Docker Components

JohnOdhiambo — Mon, 23 Sep 2024 13:30:41 +0000

Docker is an open-source platform that leverages containerization to enable automated deployment, scalability, and management of applications. It provides an easy way to package an application with all its dependencies into a container (a standardized entity).

Docker streamlines application deployment by encapsulating applications and their dependencies into standardized, scalable and isolated containers(containerization).
Main Components of Docker
Docker Images
Read-only templates that are used to build containers. Images are created with Dockerfile instructions or can be downloaded from a Dockery registry like Docker Hub.
Container
An instance of an image. It’s a lightweight, standalone package that includes everything needed to run an application.
Dockerfile
A script-like that defines the steps to create a Docker image.
Docker Engine
The docker engine is responsible for running and managing containers. It’s composed of the docker daemon and docker CLI that communicates through REST API.
Docker Daemon
The daemon is a persistent background service responsible for managing objects. It does so via listening for API requests. Docker objects include images, containers, networks and storage volumes.
Docker registry
These are repositories where docker images are stored and can be distributed from. Docker registries can be public or private. Docker hub is the default public registry that Docker is configured with.
Docker network
Containers run on networks allowing them to communicate with each other and the outside world. The network provides the communication gateway between containers running on the same/ different hosts.
Volumes
Allow data to persist outside of a container and to be shared between container instances, even after a container is deleted. Volumes decouple data life from the container lifecycle. The components listed above all tie together to produce a simple system for developers to automate the deployment, scaling and management of applications.

AWS Services

JohnOdhiambo — Mon, 30 Oct 2023 10:51:33 +0000

Architecture Skeleton

AWS Services Architecture

Virtual Private Network - Private network in AWS to manage public network for web server and load balancers and a private network for databases.
Elastic Load Balancer (ELB) - distribute incoming traffic to multiple back-end EC2 machines.
Route53 - DNS service for mapping domain name to load balancer.
EC2 Machines - VMs
EBS Disk (Elastic Block Storage) - have a limitation of maximum size. EC2 and EBS address the VMs that typically deploy the applications on web and app servers.
RDB - service for Relational Databases
DynamoDB - service for NoSQL DB
ElastiCache - for DB Caches that comes with REDIS and memcached engines.
S3 (Simple Storage Service) - for external storage.
Rekognition - Content filter service
Lambda - video converter e.g. MP4 to a different mobile friendly format.
Kinesis - for click stream data analysis and store in S3
EMR - service for Spark/Hadoop platform. It does operations like aggregation, sorting and run distributed jobs like SPARC, Flink jobs.
Glue - service that converts data from DynamoDB into different format data cataloging and further do some data processing using EMR. Extract, transform and load operations (ETL).
Redshift - data warehouse service for storing data after it's been processed.
Amazon Quicksight - BI tool for analysis and seeing the results. **Athana **is an SQL query interface to pull data from S3, perform an SQL operation and view the results in Quicksight. One can also build some graphs, charts and get insights of data.
CloudFront - content delivery network service which can cache static content or one's data in edge locations which are across cities. When one uses CloudFront service, all your data from S3 service or wherever you store your data it gets your data cached in the nearest edge location from where the user is coming.
SNS (Simple Network Service) - SMS Mobile Push Notifications service.
SES (Simple Email Service) -
SQS (Simple Queue Service) - for messaging queues for chatting applications.
CloudWatch - to monitor all the infrastructure and how EC2 instances are doing, CPU utilization of EC2, database performance.

AWS Security Services

IAM (Identity and Access Management) - manage the authentication and authorization.
KMS (Key Management Service) - encrypt data that is stored at various storage locations like EBS, S3, EMR, Redshift, Queue messages, Databases etc.
ACM (Amazon Certificate Manager) - digital certificates to one may deploy on load balancers or CloudFront so that communication is secure.
WAF (Web Application Firewall) - application firewalls to prevent attacks e.g cross-site scripting, SQL injection, DDoS.
Inspector - assigns an agent inside your machine and scans for any known vulnerabilities and then it will offer reports.

AWS Development and Deployment Services

CloudFormation - takes a template in JSON or YAML template format and create infrastructure from scratch.
CodeCommit - code repository like Git service for QA, Developers and DevOps to check-in code.
CodeBuild - service to build a product using some build tool like ant/maven and also perform some unit tests while building and even produce some artifacts.
Codepipeline - automatically build code, test and deploy into corresponding application servers running in EC2.

Codestar - integrate with project management tools like Jira, bug-tracking tool.

SET UP VIRTUAL ENVIRONMENT IN UBUNTU

JohnOdhiambo — Wed, 09 Aug 2023 09:10:28 +0000

cd /etc/apache2/sites-available/

sudo cp 000-default.conf salespro.conf

sudo vim salespro.conf

ServerAdmin webmaster@localhost
DocumentRoot /var/www/html/Salespro
ServerName servername_example

AllowOverride All

--Add the new servername_example to list of hosts
sudo vim /etc/hosts
For example, 127.0.0.1 servername_example

--Enable a new virtual host file
sudo a2ensite salespro.conf

--Restart the server
sudo systemctl restart apache2

OZEKI NG SMS Gateway

JohnOdhiambo — Wed, 09 Aug 2023 09:07:35 +0000

Install Ozeki from the url https://ozekisms.com/p_2661-how-to-setup-ozeki-ng-sms-gateway-on-ubuntu-linux.html for Ubuntu
Other OS installation are also found on the same url.

--sudo apt-get install mono-*
--sudo apt-get install libmono-winforms2*
--cd /var/lib/
--sudo wget http://ozekisms.com/attachments/2661/OzekiNG_SMS_Gateway-3.15.6.tgz
--sudo tar -xzvf OzekiNG_SMS_Gateway-3.15.6.tgz
--sudo ln -s OzekiNG_SMS_Gateway-3.15.6 /var/lib/ozeking
--sudo iptables -I INPUT -p tcp --dport 9501 -j ACCEPT
--sudo iptables -I INPUT -p tcp --dport 9010 -j ACCEPT
--cd OzekiNG_SMS_Gateway-3.15.6/
--sudo mono OzekiNG.exe /run

sudo apt install guake -y

admin
abc123

Sample SMPP Connection Details

host = 30.170.254.90
port = 9010
username = should_created_username
password = should_created_password
system-type = SMPP
smpp-version=34

R Programming Language

JohnOdhiambo — Sun, 23 Jul 2023 16:20:55 +0000

R is a programming language used for statistical analysis, visualization, and other data analysis. As a data analyst, you will use R to complete many of the tasks associated with the data analysis process. Understanding how it works and why you use it is crucial to developing a mastery of data analytics.

The is a download link for various versions of R studio based on the OS https://cran.r-project.org/mirrors.html
RStudio desktop download page
https://posit.co/download/rstudio-desktop/#download

Open the R console where you can write and execute commands. You can write simple commands in the command prompt such as print ("Hey Jay") or 1 + 2
Enter a quit() command to quit or type q()

Packages
Units of reproducible R code. R community members create packages to keep track of the R functions that they write and reuse. To install a package, the syntax is install.packages("name_of_package")

For instance, install.packages("tidyverse"). Tidyverse is a collection of packages in R with a common design philosophy for data manipulation, exploration, and visualization. Then reload the tidyverse library with the library function everytime you want to start a session. library(tidyverse)
Common tidyverse packages
ggplot2 - used for data visualization, specifically plots.
tidyr- package used for cleaning to make tidy data.
readr - used for importing data. Common function is read_csv.
dplyr - offers a consistent set of functions that help one complete some common data manipulation tasks.E.g select() function

?print() - helps one learn more about the function in the help window.
my_variable <- "My variable"
my_variable <- 2.23

Vector - group of data elements of same type stored in a sequence in R
vec_variable <- c(10, 45, 78.2)
vec_variable // execute the variable

Pipe - a tool in R for expressing a sequence of multiple operations, represented with "%>%", used to apply the output of one function into another function.

The most common data structures (a format for organizing and storing data) in R include Vectors, Data frames, Matrices and Arrays.
Data frames is a collection of columns-similar to a spreadsheet or SQL table. Each column has a name at the top that represents a variable and includes one observation per row.
file.create (“new_csv_file.csv”) - create a file.
unlink (“some_.file.csv”) - delete a file.

Matrix is a two-dimensional collection of data elements. This means it has both rows and columns.
matrix() function - create a matrix
matrix(c(3:8), nrow = 2) - creates a two rows by three columns matrix containing the values 3-8, nrow=2 specifies the number of rows.

The examples of types of date/time data in R are 06:11:13 UTC, 2019-04-16, and 2018-12-21 16:35:28 UTC.

CRAN is a commonly used online archive with R packages and other resources.

data("dataset_name") - to load a dataset.
View(dataset_name) - to checkout the dataset.

Pipe operator (%>%)
filtered_toothgrowth <- ToothGrowth %>%
filter(dose==0.5) %>%
group_by(supp) %>%
arrange(len)

head(gold) - returns a preview of the first 6 rows.
str(gold) - returns the structure of the data frame.
colnames(gold) - returns the column names of the data frame.

How to create a data frame
Here's how this works. First, create a vector of names:

names <- c("Peter", "Jennifer", "Julie", "Alex")

Then create a vector of ages:

age <- c(15, 19, 21, 25)

With these two vectors, you can create a new data frame called people:

people <- data.frame(names, age)

**<u>TIBBLES</u>**
**Tibbles** are a little different from standard data frames. A data frame is a collection of columns, like a spreadsheet or a SQL table. Tibbles are like streamlined data frames that are automatically set to pull up only the first 10 rows of a dataset, and only as many columns as can fit on the screen. Unlike data frames, tibbles never change the names of your variables, or the data types of your inputs.
**as_tibble() function** - Used to create a tibble from existing data. For example, as_tibble(gold)

**data(Indometh)** - load a specific dataset.

**`read_csv()` function** - import data from a .csv in the project folder called "hotel_bookings.csv" and save it as a data frame called `bookings_df`

{r}
bookings_df <- read_csv("hotel_bookings.csv")



**<u>Cleaning data example</u>**
let's say one is primarily interested in the following variables: hotel, is_canceled, lead_time. Create a new data frame with just those columns, calling it `trimmed_df`.

{r}
trimmed_df <- bookings_df %>%
select(hotel, is_canceled, lead_time)


Rename the variable 'hotel' to be named 'hotel_type' to be crystal clear on what the data is about:

{r}
trimmed_df %>%
select(hotel, is_canceled, lead_time) %>%
rename(hotel_type = hotel)


You can also use the`mutate()` function to make changes to your columns. Let's say you wanted to create a new column that summed up all the adults, children, and babies on a reservation for the total number of people. Modify the code chunk below to create that new column:

{r}
example_df <- bookings_df %>%
mutate(guests = adults + children + babies)

head(example_df)


**<u>Manually create a Data Frame</u>**
id <- c(1:10)

name <- c("John Mendes", "Rob Stewart", "Rachel Abrahamson", "Christy Hickman", "Johnson Harper", "Candace Miller", "Carlson Landy", "Pansy Jordan", "Darius Berry", "Claudia Garcia")

job_title <- c("Professional", "Programmer", "Management", "Clerical", "Developer", "Programmer", "Management", "Clerical", "Developer", "Programmer")

employee <- data.frame(id, name, job_title)

**<u>Import data</u>**

{r load dataset from a .csv folder and save it in data frame called hotel_bookings }
hotel_bookings <- read_csv("hotel_bookings.csv")



head(hotel_bookings) - preview columns and first 6 rows
View(hotel_bookings)- view the data frame
str/glimpse(hotel_bookings) - to see a summary of each column
arrange(hotel_bookings, desc(lead_time)) - r arrange function descending.
max(hotel_bookings$lead_time) - check out the maximum lead_time without sorting the entire data.

**<u>Benefits of Data cleaning in R</u>**
Cleaning data in R is done by applying specific cleaning functions that work on the original data without modifying it. We can save the result of our cleaning as a new dataset which will keep the changes but in any case we will keep the initial data as it was, plus we can always see how it has been processed from dirty to clean.

This allows for great traceability of our data, a better understanding the work that has been done for future users and, of course, the possibility to get back to the original dataset whenever we need it. 

On the other hand, the cleaning made in spreadsheets usually overwrites the data and we rely on regularly saving versions of it and documenting the changes as a way of keeping tabs on the process.

The **sd()**, **cor()**, and **mean()** functions can provide a statistical summary of the dataset using standard deviation, correlation, and mean.

Linux/Ubuntu OS

JohnOdhiambo — Tue, 18 Jul 2023 08:29:20 +0000

Linux File System
It helps locate files swiftly, troubleshoot issues more effectively, and makes you a proficient developer or system administrator.

/Root
/bin: Binaries - This directory holds the essential user command binaries that all users can access.

/sbin: System Binaries - Contains the essential binaries used by the system administrator for system maintenance and troubleshooting.

/etc: System Configuration - Houses the system configuration files, acting as the control panel on Linux.

/dev: Device Files - Home to all device files, such as hard disks, USB, CD-ROM, etc.

/proc: Process Information - A virtual directory detailing system and process information.

/var: Variable Files - This is the variable data directory storing changing data like logs, mails, print spools, etc.

/tmp: Temporary Files - This directory stores temporary files created by the system and users.

/usr: User Binaries - Contains multi-user utilities, applications, and libraries.

/home: User Home Directories - Contains the home directories for users and other accounts.

/lib: System Libraries - Houses library files that are needed by the system and the users.

/opt: Optional Software - Stores optional or additional software from vendors.

/mnt: Mount Directory - Used for mounting other temporary file systems.

/media: Removable Media - Acts as a temporary mount directory for removable devices.

/srv: Service Data - This directory contains server-specific services related data.

/boot: Boot Files - Contains boot loader related files.

/root: Root Home - This is the home directory for the root user.

/run: Application Information - A tmpfs file system that contains application information.

/usr/local: User Local - Contains user's programs that are installed from the source.

/lib64: 64-bit Libraries - This is where the 64-bit library files are stored

General Commands
pwd - Generate file/folder path
touch file_name - Create a file
mkdir folder_name - Create a folder
Ctrl + O - Save
Ctrl + C - Cancel
Ctrl + X - Quit
Ctrl + O + M + X - Save and move back to terminal

sudo rm -rf - Remove a file
sudo rm -r - Remove a folder
mv folder_name/ destination_folder/folder_name - move a folder to the specified destination
sudo find / -name specified_name - find file anywhere with the specified_name
unzip foldername.zip -d /var/www/html - unzip to the specified path
sudo chown -R $USER /var/log/odoo/ - grant permission to the logged in user
sudo chown -R dev /var/log/odoo/ - grant permission to a specific user

lsof -i :8080 - List all processes running on the port
kill 64789 - Kill a given process

My SQL Terminal Commands
mysql -u root -p
show databases;
show table $tablName
show create table $tablName

Postgress Terminal Commands
sudo service postgresql restart
**
**sudo -u postgres psql -d db_name - connect to db you want to use with postgres as user
\c db_name - connect to a different db
\dt - tables in a db
\d table_name *- schema of table
*\q **- Quit psql
**sudo passwd postgres
*sudo passwd -d postgres
*

sudo -u postgres psql -c "\l" - List all databases
sudo -u odoo psql -d odoo - Use a specific DB

sudo -u postgres psql -c "CREATE USER steve WITH PASSWORD 'password';"

sudo -u postgres psql -c "SELECT * FROM pg_user WHERE usename='postuser';"

sudo -u postgres createuser -sS odoouser
sudo -u postgres createuser -s postuser
**
*sudo -u postgres psql -c "SELECT passwd FROM pg_shadow WHERE usename='postuser';"
*
**sudo -u odoo psql -c "ALTER USER odoo WITH PASSWORD 'password';"

sudo -u postgres psql -c "DROP USER odoouser;"

Getting Started with GoLang

JohnOdhiambo — Tue, 28 Mar 2023 14:05:43 +0000

http://go-database-sql.org/index.html -SQL

https://echo.labstack.com/guide/response/ -Echo Web-Framework

https://www.golinuxcloud.com/go-gorilla-mux/ -Gorilla Mux Web-Framework

https://gorm.io/docs/advanced_query.html -ORM Library for Go

Install Go from https://golang.google.cn/doc/install

OR for Ubuntu https://buildvirtual.net/how-to-install-go-on-ubuntu-20-04/

Open Cmd *and type *$ go version to display the Go version in order to verify that it has been successfully installed.
Navigate to home directory using cd %HOMEPATH% command.
Create a directory for your first Go source code using the commands below mkdir test then navigate to the folder with cd test
Enable dependency tracking for your code. When your code imports packages contained in other modules, you manage those dependencies through your code's own module. That module is defined by a go.mod file that tracks the modules that provide those packages. Type the following command for our test directory. $ go mod init test/hello go: creating new go.mod: module example/hello
Create a file test.go where you will write your code. package main. Below is an example.

   package main
   import "fmt"

   func main() {
     fmt.Println("Hello, Jay!")
   }

Run your code using $ go run . The following is displayed- Hello, Jay!

Essential Go Commands
go mod vendor command constructs a directory named vendor in the main module’s root directory that contains copies of all packages needed to support builds and tests of packages in the main module.
It creates the file vendor/modules.txt that contains a list of vendored packages and the module versions they were copied from.
Vendor directories are not used in any module.

go mod tidy command ensures that the go.mod file matches the source code in the module. It adds any missing module requirements necessary to build the current module’s packages and dependencies, and it removes requirements on modules that don’t provide any relevant packages. It also adds any missing entries to go.sum and removes unnecessary entries.

go get github.com/joho/godotenv to set up go environment variables

go get -u github.com/go-sql-driver/mysql to get sql driver package

go get github.com/labstack/echo/v4 to use Echo web framework

Common Git commands

JohnOdhiambo — Mon, 30 Jan 2023 16:23:10 +0000

--globally configure username
$ git config --global user.name "JohnDoe"
$ git config user.name "JohnDoe"

--globally configure password
$ git config --global user.email "johndoe@gmail.com"
$ git config user.email "johndoe@gmail.com"

--Navigate to previous directory
$ cd ..

--navigate to the stated directory
$ cd My_Portal/ChannelsPortal

--Add a specific file
$ git add 'My_Portal_lattest.bak'

--Add all files
$ git add .

--Commit changes
$ git commit -m 'Db Commit'

--Add to the remote repository
$ git remote add origin https://github.com/JohnDoe/My_APIs.git

--Push to the master repository
$ git push -u origin main

$ git push origin master --force

ADD A SINGLE FILE
LENOVO@DESKTOP-PIVU MINGW64 /e/Learning/ReactJs (Main)
$ git init

LENOVO@DESKTOP-PIVU MINGW64 /e/Learning/ReactJs (master)
$ git add 'Intro_To_React.html'

LENOVO@DESKTOP-PIVU MINGW64 /e/Learning/ReactJs (master)
$ git commit -m "First React Commit:file"

LENOVO@DESKTOP-PIVU MINGW64 /e/Learning/ReactJs (master)
$ git branch -M main

LENOVO@DESKTOP-PIVU MINGW64 /e/Learning/ReactJs (main)
$ git remote add origin https://github.com/JohnDoe/ReactJS.git

LENOVO@DESKTOP-PIVU MINGW64 /e/Learning/ReactJs (main)
$ git push -u origin main

HOW TO CLONE FROM EXISTING REPO
$ git clone https://https://github.com/JohnDoe/Read.git(url to be cloned)
$ cd name-of-folder
$ git add .
$ git commit "comment"
$ git set-url https://https://github.com/JohnDoe/Tech.git(url to your repo)
$ git push -u origin main

HOW TO ADD AN ENTIRE FOLDER
$ git add foldername
$ git commit -m "commit comment"
$ git push

Running a React App using VSCode and How to Debug React

JohnOdhiambo — Tue, 10 Jan 2023 10:34:36 +0000

CREATING & RUNNING REACT

Install VS code using the url https://code.visualstudio.com/download if you do not have it already installed in your machine
Install NodeJS from this url https://nodejs.org/en/download/
Create a folder where to want to create the react application.
You can create the application by either using GitBash or the terminal on VSCode

Using GitBash: Right click on the folder and select Gitbash here if you have git installed in your computer. Then type the command npx create-react-app your-name-of-application e.g., create-react-app my-reactapp

Using Terminal on VSCode: Type the command npx create-react-app your-name-of-application and wait for the commands to finish executing.

Open the folder containing your application in VS code and navigate to src/app.js and write some code. Below is a sample App.js file after making a few changes
On the VSCode terminal, navigate to the folder by typing cd foldername for instance cd my-application.
Type nmp start and the application should launch on the browser as shown below.

DEBUGGING REACT

Configure the debugger by going to Run and Debug view (Ctrl + Shift + D)
Select create a launch.json file link to create a launch.json debugger configuration file.
Select the debugger dropdown list and choose Web App (Edge).
Change the port of the url from 8080 to 3000. The launch.json file should look as shown below.

Press F5 or the green arrow with Run to launch the debugger.
You can set break points as you run the code and step through using F10

Project management; Overview of what you need to know

JohnOdhiambo — Thu, 08 Dec 2022 11:02:02 +0000

1.Foundations of Project Management
2.Project Initiation
3.Project Planning
4.Project Execution
5.Agile Project Management
6.Capstone: Applying Project Management in real world

COST BENEFIT ANALYSIS

-The process of adding up the expected value of a project, the benefits, and comparing them to the dollar costs.
-A cost-benefit analysis can minimize risks and maximize gains for projects and organizations. It can help you communicate clearly with stakeholders and executives and keep your project on track
ROI
-The process of calculating costs and benefits is also called calculating return on investment
(G-C)/C = ROI
G- expected financial gain from the project
C- upfront and ongoing costs of your investment in the project
For example, imagine your project costs $6,000 up front plus $25 per month for 12 months. This equals $300 per year, but you estimate that the project will bring in $10,000 in revenue over the course of that year. Using the formula above, you calculate the ROI as: ($10,000 - $6,300) ÷ $6,300 = 0.58 = 58%

Customer satisfaction. Will the project increase customer retention, causing them to spend more on the company’s products or services?

Employee satisfaction. Is the project likely to improve employee morale, reducing turnover?

Employee productivity. Will the project reduce employee’s overtime hours, saving the company money?

Brand perception. Is the project likely to improve the company’s brand perception and recognition, attracting more customers or providing a competitive advantage?

KEY COMPONENTS OF PROJECT INITIATION
-Goals
-Scope
-Deliverables
-Success criteria
-Stakeholders
-Resources

SMART (Specific, Measurable, Attainable, Relevant, Time-bound)

“Office Green will create an app that offers tips and reminders to help customers care for their plants. The app will be completed within 18 months and be compatible with 100% of the types of plants Office Green sells.”

Specific: The team knows what they’re building: an app that helps users care for their plants and reminds them to do so.

Measurable: The app will be complete when it includes 100% of the plant types of Office Green sells.

Attainable: The company has the knowledge, time, resources to build the app.

Relevant: Office Green’s business model relies on customers caring for their plants successfully.

Time-bound: The goal includes an 18-month timeframe.

OBJECTIVES + KEY RESULTS (OKR)
Objectives define what needs to be achieved and describe a desired outcome. Key results define how the project team knows whether or not they have met their objective.

TRIPPLE CONSTRAINTS

Scope, Time & Cost - they affect the output and quality of the project

A RACI chart helps to define roles and responsibilities for individuals or teams to ensure work gets done efficiently. It creates clear roles and gives direction for each team member. There are four types of participation included in a RACI chart. These are:
R: Responsible: who gets the work done

A: Accountable: who makes sure the work is done

C: Consulted: who gives input or feedback on work

I: Informed: who needs to know the outcome

A project charter clearly defines the project and outlines the necessary details for the project to reach its goals. The charter is the formal way that the project’s goals, values, benefits, and details are captured.

PROJECT PLANNING
Schedule, budget, and risk management plan

COMPONENTS OF A PROJECT PLAN
Tasks, milestones, people, documentation and time

-In addition to the schedule, you should also include the following components in your project plan:
Scope and goals
Work Breakdown Structure (WBS)
Budget
Management plans such as the change management plan, risk management plan, and communication plan

WATERFALL METHODOLOGY - Traditional methodology in which tasks and phases are completed in a linear, sequential manner, and each stage of the project must be completed before the next begins.

AGILE METHODOLOGY - Short phases of collaborative, iterative work with frequent testing and regularly implemented improvements. Scrum and Kanban are examples of Agile frameworks.
Scrum is an Agile framework that focuses on developing, delivering, and sustaining complex projects and products through collaboration, accountability, and an iterative process. It is ideal for projects with rapidly changing requirements, using short sprints.
Kanban is a tool used in both Agile and Lean approaches that provides visual feedback about the status of the work in progress through the use of Kanban boards or charts. It represents the team’s tasks with categories like “To do,” “In progress,” and “Done.” It visualizes project progress and is great for tasks requiring steady output.

6 SIGMA - (DMAIC) Define, Measure, Analyze, Improve, Control
Lean uses the 5S quality tool to eliminate eight areas of waste, save money, improve quality, and streamline processes. It streamlines processes, eliminating waste for customer value.
Extreme Programming (XP): It enhances software quality and responsiveness to customer satisfaction.

PROCUREMENT
Initiating: planning what you need to meet your project goals
Selecting: deciding which supplies and vendors to use
Contract writing: developing, reviewing, and signing contracts
Controlling: making payments and maintaining and ensuring quality
Completing: measuring your success