Troubleshooting Techniques for Software Developers

 1. Understand the Problem:

   - Before diving into troubleshooting, ensure you understand the problem thoroughly. Gather information about the symptoms, error messages, and the circumstances under which the issue occurs.

 

 2. Reproduce the Issue:

   - Attempt to replicate the problem in a controlled environment. Determine the specific steps or conditions that trigger the issue. Reproducing the problem is crucial for identifying its root cause.

 

 3. Check Logs and Error Messages:

   - Examine log files, console outputs, and error messages related to the issue. Logs often contain valuable clues about the cause of the problem, such as stack traces or error codes.

 

 4. Isolate the Scope:

   - Narrow down the scope of the problem to identify its source. Determine whether the issue is localized to specific components, modules, or environments. Isolating the problem helps focus your troubleshooting efforts.

 

 5. Review Recent Changes:

   - Investigate any recent code changes, updates, or deployments that may have introduced the issue. Changes in code, configuration, or dependencies could be potential triggers for unexpected behavior.

 

 6. Use Debugging Tools:

   - Employ debugging tools and techniques to analyze code execution, inspect variables, and track program flow. Tools like debuggers, logging frameworks, and profilers are invaluable for diagnosing complex issues.

 

 7. Test Hypotheses:

   - Formulate hypotheses or theories about the cause of the problem based on available evidence and observations. Test each hypothesis systematically to validate or refute its validity.

 

 8. Apply Binary Search Method:

   - Divide and conquer by applying the binary search method to narrow down possible causes. Split the problem space into halves and systematically eliminate non-contributing factors until you isolate the root cause.

 

 9. Consult Documentation and Resources:

   - Refer to documentation, manuals, forums, and online resources for insights and solutions to common issues. Community forums and knowledge bases often provide valuable tips and workarounds for troubleshooting problems.

 

 10. Seek Peer Review and Collaboration:

   - Don't hesitate to seek assistance from colleagues, mentors, or online communities when troubleshooting challenging issues. Collaborative problem-solving can provide fresh perspectives and lead to faster resolution.

 

 11. Document Findings and Solutions:

   - Keep detailed records of your troubleshooting process, including observations, actions taken, and outcomes. Documenting your findings and solutions helps build a knowledge base for future reference and knowledge sharing.

 

 12. Learn from Experience:

   - Treat each troubleshooting experience as an opportunity for learning and skill development. Reflect on your troubleshooting techniques, successes, and challenges to refine your problem-solving skills over time.

 

Read More

Programming Pitfalls: Avoiding Common Mistakes in Your Code

"Programming Pitfalls: Avoiding Common Mistakes in Your Code" refers to recognizing and addressing typical errors or pitfalls that programmers encounter during software development. Here are several common pitfalls along with examples:

 

1. Null Pointer Dereference:

   - Description: Attempting to access or manipulate an object or variable that is null, leading to a null pointer exception.

   - Example: In Java, if you try to call a method on a null object reference:

     ```java

     String str = null;

     int length = str.length(); // This will throw a NullPointerException

     ```

 

2. Off-by-One Errors:

   - Description: Iterating over arrays or collections using incorrect index boundaries, often leading to out-of-bounds errors or incorrect data processing.

   - Example: In C++, iterating over an array one element past its size:

     ```cpp

     int arr[5] = {1, 2, 3, 4, 5};

     for (int i = 0; i <= 5; i++) {

         cout << arr[i] << endl; // This may access memory out of bounds

     }

     ```

 

3. Uninitialized Variables:

   - Description: Using variables before initializing them, leading to unpredictable behavior or bugs.

   - Example: Accessing the value of an uninitialized variable in C:

     ```c

     int num;

     printf("%d", num); // The value of 'num' is undefined and can lead to unpredictable output

     ```

 

4. Memory Leaks:

   - Description: Failing to deallocate dynamically allocated memory after its use, resulting in memory leaks and eventual resource exhaustion.

   - Example: In C++, failing to delete dynamically allocated memory:

     ```cpp

     int *ptr = new int;

     ptr = nullptr; // The allocated memory is lost and not deallocated

     ```

 

5. Infinite Loops:

   - Description: Loops that do not terminate due to incorrect loop conditions or missing break statements.

   - Example: In Python, an infinite loop:

     ```python

     while True:

         print("This is an infinite loop")

     ```

 

6. Type Conversion Errors:

   - Description: Incorrectly converting between different data types, leading to data loss or unexpected results.

   - Example: Truncating a floating-point number during integer division in Python:

     ```python

     result = 7 / 2  # This will result in 3.5 in Python 3, but 3 in Python 2

     ```

 

7. String Manipulation Errors:

   - Description: Mishandling strings, such as improper bounds checking, leading to buffer overflows or memory corruption.

   - Example: In C, not properly terminating a string with a null character:

     ```c

     char str[10];

     str[10] = 'a'; // This may corrupt memory beyond the allocated space for 'str'

     ```

 

8. Ignoring Error Handling:

   - Description: Failing to handle errors or exceptions properly, leading to program crashes or unexpected behavior.

   - Example: In Java, catching exceptions but not handling or logging them:

     ```java

     try {

         // Some code that may throw an exception

     } catch (Exception e) {

         // No handling or logging of the exception

     }

     ```

 

By being aware of these common pitfalls and incorporating best practices such as rigorous testing, code reviews, and defensive programming techniques, developers can write more robust and reliable code while avoiding common mistakes.

 

Read More

Exploring the Most Infamous Software Glitches in History

Exploring the Most Infamous Software Glitches in History provides insights into some of the most impactful and notorious software failures that have occurred throughout history. Here are several examples:

 

1. Y2K Bug (Year 2000 Problem):

   - As the year 2000 approached, many computer systems stored dates using only the last two digits of the year (e.g., "99" for 1999). Concerns arose that when the year changed to 2000, computers would interpret it as 1900 due to the two-digit representation. This led to fears of widespread system failures in critical infrastructure, finance, and other sectors. While extensive preparations and fixes mitigated most issues, the Y2K bug remains one of the most infamous software glitches.

 

2. Ariane 5 Flight 501:

   - In 1996, the maiden flight of the Ariane 5 rocket ended in catastrophic failure just 40 seconds after liftoff. The rocket's guidance system experienced an overflow error in the inertial reference system software. This error occurred due to a software component designed for the Ariane 4, which had different flight parameters. The failure resulted in the rocket's self-destruct mechanism being triggered, leading to the loss of the payload.

 

3. Therac-25 Radiation Therapy Machine:

   - The Therac-25 was a medical linear accelerator used for radiation therapy in the 1980s. It suffered from a series of software-related accidents that resulted in patients receiving massive overdoses of radiation, leading to severe injuries and deaths. The accidents were caused by race conditions and inadequate error handling in the software, which allowed the machine to deliver lethal doses of radiation to patients.

 

4. Patriot Missile Failure (Gulf War):

   - During the Gulf War in 1991, a Patriot missile defense system failed to intercept an incoming Scud missile launched by Iraq, resulting in the destruction of a U.S. Army barracks and multiple casualties. The failure was attributed to a software flaw in the system's internal clock, which caused inaccuracies to accumulate over time. As a result, the Patriot system failed to track and intercept the incoming missile.

 

5. Heartbleed Bug:

   - In 2014, the Heartbleed bug was discovered in the OpenSSL cryptographic software library, which is widely used to secure internet communications. The bug allowed attackers to exploit a vulnerability in the implementation of the Transport Layer Security (TLS) protocol, potentially exposing sensitive data such as passwords, private keys, and other cryptographic information. The widespread use of OpenSSL meant that millions of websites and services were vulnerable to exploitation.

 

These examples highlight the significant impact that software glitches can have on various aspects of society, from critical infrastructure and healthcare to military defense and cybersecurity. They underscore the importance of rigorous software testing, thorough code reviews, and robust error handling practices in preventing and mitigating the effects of software failures.

 

Read More

Debugging 101: Strategies for Squashing Software Bugs

Description:

Debugging is the process of identifying and fixing errors, or "bugs," in software code. It's an essential skill for developers and programmers to ensure their programs function correctly and efficiently. "Debugging 101" suggests an introductory level of understanding, making it suitable for beginners or those looking to improve their debugging skills.

 

Strategies for Squashing Software Bugs:

 

1. Identifying the Bug:

   - Understand the symptoms and behavior of the bug. Reproduce the issue to gain insights into its triggers and manifestations.

 

2. Isolating the Bug:

   - Narrow down the scope of the problem. Determine which parts of the code are affected by the bug and focus your attention there.

 

3. Reading the Code:

   - Thoroughly review the relevant code sections. Look for logic errors, syntax mistakes, or unexpected behaviors that could be causing the bug.

 

4. Using Debugging Tools:

   - Leverage debugging tools provided by the programming environment or IDE (Integrated Development Environment). These tools allow you to step through the code, inspect variables, and track program flow during execution.

 

5. Adding Logging Statements:

   - Insert logging statements strategically within the code to track the program's execution flow and monitor the values of variables at different stages. Logging helps identify the point at which the program deviates from the expected behavior.

 

6. Testing and Regression Testing:

   - Perform thorough testing to ensure that the bug fixes do not introduce new issues or regressions into the codebase. Regression testing involves retesting previously working parts of the software to verify that changes haven't affected their functionality.

 

7. Seeking Help and Collaboration:

   - Don't hesitate to seek assistance from colleagues, online communities, or forums when troubleshooting difficult bugs. Collaborating with others can provide fresh perspectives and insights into potential solutions.

 

8. Documenting the Fix:

   - Once the bug is resolved, document the steps taken to identify and fix it. Clear documentation helps future developers understand the problem and its solution, facilitating smoother maintenance and development processes.

 

9. Learning from Mistakes:

   - Treat each debugging experience as a learning opportunity. Analyze the root causes of bugs and identify patterns or common pitfalls to avoid in future coding endeavors.

 

By employing these strategies, developers can effectively debug software applications, improve code quality, and enhance overall development productivity. Debugging is not only a technical skill but also a mindset that emphasizes problem-solving, attention to detail, and persistence in the pursuit of software excellence.

Examples of each:

 

Description:

Debugging is a critical skill for software developers, enabling them to identify and fix errors in their code. "Debugging 101" suggests an introductory approach, making it suitable for beginners or those looking to refine their debugging techniques.

 

Strategies for Squashing Software Bugs:

 

1. Identifying the Bug:

   - Example: You notice that clicking a specific button in your web application consistently crashes the program or produces unexpected behavior.

 

2. Isolating the Bug:

   - Example: You determine that the issue only occurs when the button triggers a particular function responsible for updating user preferences.

 

3. Reading the Code:

   - Example: Upon reviewing the code for the function, you notice a conditional statement that incorrectly handles user input, leading to unexpected outcomes.

 

4. Using Debugging Tools:

   - Example: You set breakpoints within the function using your IDE's debugger and step through the code line by line to track the flow of execution and inspect variable values.

 

5. Adding Logging Statements:

   - Example: You insert logging statements before and after critical sections of code to monitor variable values and program flow during runtime, helping pinpoint the source of the issue.

 

6. Testing and Regression Testing:

   - Example: After implementing a potential fix, you conduct comprehensive testing to verify that the button now functions correctly and that other parts of the application remain unaffected.

 

7. Seeking Help and Collaboration:

   - Example: If you encounter difficulties resolving the bug, you seek advice from colleagues or participate in online developer communities to gain insights and potential solutions.

 

8. Documenting the Fix:

   - Example: Once the bug is resolved, you document the steps taken to identify and fix the issue, including any relevant code changes or insights gained during the debugging process.

 

9. Learning from Mistakes:

   - Example: Reflecting on the debugging experience, you identify areas for improvement in your coding practices and strive to incorporate lessons learned into future development projects.

 

By applying these strategies and learning from real-world examples, developers can enhance their debugging skills and effectively resolve software bugs, contributing to the overall quality and reliability of their applications.

 

Read More

Top 10 Common Coding Errors and How to Fix Them

1. Null Pointer Exception:

   - **Description:** Null pointer exceptions occur when you try to access a member or method of an object that's null. It's a common mistake in Java and other languages that support pointers.

   - **Example:** Suppose you have an object reference `obj` that is not initialized properly, and you try to call a method like `obj.someMethod()`. This will result in a null pointer exception.

   - **Fix:** To fix this error, you need to ensure that the object reference is initialized properly before accessing its members or methods.

2. Index Out of Bounds Exception:

   - **Description:** This error occurs when you try to access an element of an array, list, or other data structure at an index that is beyond the bounds of the structure.

   - **Example:** If you have an array `arr` with 5 elements (indices 0 to 4) and you try to access `arr[5]`, you'll get an index out of bounds exception.

   - **Fix:** To fix this error, ensure that the index you're trying to access is within the valid range of the data structure.

3. Infinite Loops:

   - **Description:** Infinite loops occur when the condition controlling the loop never evaluates to false, causing the loop to continue indefinitely.

   - **Example:** In Java, a common example of an infinite loop is `while (true) { ... }` without a break condition.

   - **Fix:** To fix this error, make sure that the loop condition eventually becomes false or add a break statement to exit the loop under certain conditions.

4. Type Mismatch Errors:

   - **Description:** Type mismatch errors occur when you try to assign a value of one data type to a variable of another data type that's not compatible.

   - **Example:** Assigning a string value to an integer variable without proper conversion can result in a type mismatch error.

   - **Fix:** Ensure that the data types of variables match the types of values being assigned to them, or use appropriate type conversion techniques.

5. Division by Zero Errors:

   - **Description:** Division by zero errors occur when you attempt to divide a number by zero, which is undefined in mathematics and most programming languages.

   - **Example:** Dividing a number by zero, such as `int result = 10 / 0;`, will result in a division by zero error.

   - **Fix:** To fix this error, ensure that the denominator is not zero before performing division operations.

6. Syntax Errors:

   - **Description:** Syntax errors occur when the code violates the rules of the programming language's syntax.

   - **Example:** Forgetting to close parentheses, missing semicolons, or using incorrect keywords can all result in syntax errors.

   - **Fix:** Review the code carefully to identify and correct syntax errors according to the rules of the programming language.

7. Memory Leaks:

   - **Description:** Memory leaks occur when a program allocates memory but fails to release it after it's no longer needed, leading to memory consumption over time.

   - **Example:** Forgetting to deallocate dynamically allocated memory in languages like C or C++ can result in memory leaks.

   - **Fix:** Properly manage memory allocation and deallocation using techniques like garbage collection or manual memory management.

8. Logic Errors:

   - **Description:** Logic errors occur when the program performs the wrong computations or produces incorrect results due to flawed logic in the code.

   - **Example:** A logic error could occur in a sorting algorithm that sorts elements in the wrong order or fails to sort them at all.

   - **Fix:** Debug the code to identify and correct logical flaws, such as incorrect conditional statements or algorithmic errors.

9. Concurrent Modification Errors:

   - **Description:** Concurrent modification errors occur in multi-threaded or concurrent programs when one thread modifies a data structure while another thread is iterating over it.

   - **Example:** Modifying a collection while iterating over it using an iterator can result in a concurrent modification error in Java.

   - **Fix:** Use proper synchronization techniques or concurrent data structures to avoid concurrent modification errors in multi-threaded programs.

10. Resource Management Errors:

   - **Description:** Resource management errors occur when the program fails to properly acquire, use, or release system resources like file handles, database connections, or network sockets.

   - **Example:** Failing to close an open file or database connection after its use can lead to resource management errors.

   - **Fix:** Ensure that resources are properly acquired, used, and released in the code using techniques like try-with-resources or explicit resource management.

Each of these examples illustrates a common coding error, explains why it occurs, and provides guidance on how to fix or prevent it. By understanding and addressing these common errors, developers can write more robust and reliable code.

Read More

Solved: ERROR 1045 (28000): Access denied for user 'root'@'localhost' (using password: YES)

Follow the given steps to solve the issue. The commands here are for CentOS 8. The solution is same for other OS as well so modify the commands accordingly.

Step 1: After the installation of MYSQL is finished, enable and start mysqld as given below:

sudo systemctl start mysqld

sudo systemctl enable mysqld

Once, done also check the status of the mysqld to verify whether it is running or not:

sudo systemctl status mysqld

Step 2: Find the temporary password and copy it using the following command:

sudo grep 'temporary password' /var/log/mysqld.log

You will see something like this:

 A temporary password is generated for root@localhost: ;ND0#VvB0*Mt

Copy the temporary password.

Step 3: Type the following command:

mysql -u root -p

Step 4: When prompted to enter password, just paste the copied temporary password and yes you are done with your task. 

Step 5: Then you can change the password for root using the command:

sudo mysql_secure_installation

Read More

Using single Gmail as multiple Gmail addresses | Some hidden secrets of ...

Read More

Steps to install oci8 on centos 8

The following steps is valid for Oracle 11g, you can modify as per your oracle version in a similar fashion.

1. Install the Oracle Instant Client:

   - Download the Oracle Instant Client RPM packages for your architecture from the Oracle website (https://www.oracle.com/database/technologies/instant-client/linux-x86-64-downloads.html). You'll need  oracle-instantclient-basic ,  oracle-instantclient-devel and oracle-instantclient-sqlplus packages.

   - Transfer the downloaded RPM packages to your CentOS 8 system if you downloaded them on a different machine.

Note: for centos, it is better to download “.rpm” file rather than “.zip”

2. Install the Oracle Instant Client RPM packages:

Go to the directory where you downloaded the oracle instant-client files and install those files:

Let’s take example for version oracle instant-client 11.2,

sudo dnf install oracle-instantclient11.2-basic-11.2.0.4.0-1.x86_64.rpm 

sudo dnf install oracle-instantclient11.2-devel-11.2.0.4.0-1.x86_64

sudo dnf install oracle-instantclient11.2-sqlplus-11.2.0.4.0-1.x86_64

To verify whether the Oracle Instant Client "devel" package is installed on your CentOS system, you can use the package management tool rpm or dnf. Here's how you can check for the presence of the Oracle Instant Client devel package:

Using ‘rpm’:

rpm -qa | grep oracle-instantclient-devel

Using ‘dnf’:

dnf list installed | grep oracle-instantclient-devel

 

3. Verify the ORACLE_HOME environment variable:

echo $ORACLE_HOME

Ensure that the ORACLE_HOME environment variable is set correctly and points to the location where you installed the Oracle Instant Client. If it's not set correctly, you can set it as follows:

export ORACLE_HOME=/path/to/instant/client

During the installation process, you may be prompted to provide the path to the Oracle Instant Client library. If prompted, enter the correct path:

Enter the path: instantclient,/usr/lib/oracle/19.20/client64/lib

 

4. Set the environment variables required for OCI8 and PHP:

 

$ export ORACLE_HOME=/usr/lib/oracle/11.2/client64

$ export LD_LIBRARY_PATH=/usr/lib/oracle/11.2/client64/lib

sudo ldconfig

Once you are done with above steps, the environment is set for oci8 installation, follow the bellows steps now,

5. Stop Apache and uninstall older version of OCI8 if any (stopping Apache is very important):

 service httpd stop

 pecl uninstall oci8

 

6. Install php-pear and php devel:

 sudo yum install php-pear php-devel

 pear download pecl/oci8

7. The next commands depend on the version of oci8 downloaded above.

$ tar xvzf oci8-2.2.0.tgz

$ cd oci8-2.2.0/

$ phpize

$ export PHP_DTRACE=yes

$ sudo dnf install libnsl

$ sudo dnf install epel-release

$ setenforce 0

 

8. Make sure of the instantclient path below... mine was version 11.2 so it was located in this folder... Also make note some tutorials ask for the ORACLE_HOME folder which theoretically is /usr/lib/oracle/11.2/client64 but if its instantclient then put the lib folder underneath it (worked for me at least:)

$ ./configure --with-oci8=instantclient,/usr/lib/oracle/12.2/client64/lib/

$ make

$ make install

$ sudo pecl install oci8-3.3.0 instantclient,$ORACLE_HOME/lib

$ sudo systemctl restart httpd

$ sudo systemctl restart php-fpm

$ sudo systemctl restart mysqld 

9. NOW an .so file built in: /usr/lib64/php/modules/oci8.so

10. check whether oci8 has been successfully installed or not:

php -m | grep oci8

The steps may not be needed in most of the cases. If indeed, it is required in your case go through these steps as well (though it is suggested to first try running before implementing the below steps):

# THIS STEP NOT NEEDED if SELinux disabled on your server/box, but if SELinux is enabled run: setsebool -P httpd_execmem 1

# NOW add:   extension=oci8.so    at the bottom of your php.ini file (probably in /etc/php.ini)

# Add extension_dir=/usr/lib64/php/modules/

Read More

Steps to install HTTPD, PHP, MYSQL and PHPMYADMIN in CentOS 8

Steps to install httpd in CentOS 8

1. sudo yum install dnf
2. sudo dnf update
3. sudo dnf install httpd
4. sudo systemctl start httpd
5. sudo systemctl enablr httpd
6. sudo systemctl enable httpd
7. sudo firewall-cmd --add-service=http --permanent
8. sudo firewall-cmd --reload
9. sudo systemctl status httpd
10. sudo dnf update

Steps to install PHP in CentOS 8

1. sudo dnf update
2. sudo dnf install epel-release
3. sudo dnf install https://rpms.remirepo.net/enterprise/remi-release-8.rpm
4. sudo dnf module enable php:remi-8.2
5. sudo dnf module reset php
6. sudo dnf module enable php:remi-8.2
7. sudo dnf module list php
8. sudo dnf install php php-cli php-fpm php-mysqlnd php-pdo php-gd php-xml
9. php -v

Steps to install MYSQL in CentOS 8

1. sudo dnf update
2. sudo dnf install https://dev.mysql.com/get/mysql80-community-release-el8-    3.noarch.rpm
3. sudo dnf module enable mysql:8.0
4. sudo dnf update
5. sudo dnf install mysql-server
6. sudo systemctl start php-fpm
7. sudo systemctl enable php-fpm
8. sudo systemctl restart httpd
9. sudo systemctl start mysqld
10. sudo systemctl enable mysqld

Steps to install phpmyadmin in CentOS 8

1. Sudo dnf install epel-release
2. sudo dnf update
3. yum -y update
4. yum -y install phpmyadmin
5. dnf --enablerepo=remi install phpMyAdmin
6. sudo vi /etc/httpd/conf.d/phpMyAdmin.conf

Make sure the phpMyAdmin.conf file looks similar to this:

Alias /phpMyAdmin /usr/share/phpMyAdmin

Alias /phpmyadmin /usr/share/phpMyAdmin

 

<Directory /usr/share/phpMyAdmin/>

   AddDefaultCharset UTF-8

   <IfModule mod_authz_core.c>

      # Apache 2.4

      <RequireAny>

         Require all granted

      </RequireAny>

   </IfModule>

   <IfModule !mod_authz_core.c>

      # Apache 2.2

      Order Deny,Allow

      Deny from All

      Allow from 127.0.0.1

      Allow from ::1

   </IfModule>

</Directory>

 

<Directory /usr/share/phpMyAdmin/setup/>

7. sudo systemctl restart httpd

8. You can verify the phpmyadmin installation by opening URL:

http://your_server_ip/phpMyAdmin

Alternative way to install phpmyadmin on CentOS 8

1. sudo dnf update
2. sudo dnf install tar
3. sudo dnf install wget
4. wget https://files.phpmyadmin.net/phpMyAdmin/5.1.3/phpMyAdmin-5.1.3-all-languages.tar.gz
5. tar xzf phpMyAdmin-5.1.3-all-languages.tar.gz
6. sudo mv phpMyAdmin-5.1.3-all-languages /usr/share/phpMyAdmin
7. sudo mkdir /etc/phpMyAdmin
8. sudo cp /usr/share/phpMyAdmin/config.sample.inc.php /etc/phpMyAdmin/config.inc.php
9. sudo chmod 660 /etc/phpMyAdmin/config.inc.php
10. sudo chown -R apache:apache /etc/phpMyAdmin
11. sudo vi /etc/phpMyAdmin/config.inc.php
12. add to config.inc.php,

                $cfg['blowfish_secret'] = 'a1b2c3d4e5f6g7h8i9j0';

13. sudo vi /etc/httpd/conf.d/phpMyAdmin.conf

Your phpMyAdmin.conf should be similar to given below,

Alias /phpMyAdmin /usr/share/phpMyAdmin

Alias /phpmyadmin /usr/share/phpMyAdmin

 

<Directory /usr/share/phpMyAdmin/>

   AddDefaultCharset UTF-8

   <IfModule mod_authz_core.c>

      # Apache 2.4

      <RequireAny>

         Require all granted

      </RequireAny>

   </IfModule>

   <IfModule !mod_authz_core.c>

      # Apache 2.2

      Order Deny,Allow

      Deny from All

      Allow from 127.0.0.1

      Allow from ::1

   </IfModule>

</Directory>

 

<Directory /usr/share/phpMyAdmin/setup/>

14. sudo systemctl restart httpd

 

Note: "vi" command used above is an editor. I hope you know how to use it.

To insert, press i

To exit without saving, press esc then :q! and then enter

To exit along with saving, press esc then :wq! then enter

Read More