In this blog post, we will explore the programming languages that students must learn and master during their time at university to enhance their job prospects and stand out in the tech job market.

1. Java:
   Java remains one of the most widely used programming languages across various industries. Its versatility, platform independence, and strong object-oriented foundations make it an excellent choice for students. Proficiency in Java opens doors to a wide range of job opportunities as a Java developer, software engineer, or application developer. Many companies, including multinational corporations, rely on Java for their projects, making it a valuable skill set to possess.
2. Python:
   Python has gained significant popularity in recent years due to its simplicity, readability, and extensive libraries. It is widely used in web development, data science, artificial intelligence, and automation. Mastery of Python can lead to exciting career paths as a data analyst, machine learning engineer, or web developer. Its growing demand.
3. JavaScript:
   JavaScript is the language of the web, making it indispensable for front-end and full-stack web development. With the rise of e-commerce and online platforms.

The post Essential Programming Languages for Better Job Prospects first appeared on Pakzilla.

In my case, my PC was not having Java installed. So I went with OpenJDK from Eclipse foundation. So by performing the following steps, it solved the problem.

• Download AdoptOpenJDK, I selected .msi version for my x64 PC.
• On the Custom Setup screen, select “Set JAVA_Home variable” and “JavaSoft (Oracle) registery keys”
  

• Let the installer setup JAVA_HOME and PATH system variables

• Give a restart to your PC (better do it with Windows :p)
• Verify in command prompt to see if this JDK version is reflecting

• Run your application.

The post Launcher4j – This application requires a Java Runtime Environment 1.6.0 first appeared on Pakzilla.

The user chooses those options until the user wills to quit the program. In other words the termination of the program is in the hands of the user. Here is an example of a simple menu driven program from an application designed for LESCO.

LESCO L1; // class LESCO

Bool LESCO::ProcessMenu( )
{
    cout<<"\t\t\tChoose an Option:\n 1) Login in as a Employee(Press 1) 2) Login as a customer(Press 2)
 3) Quit(Press 3) \n\nYour Option:\t";

    int option;
    cin>>option;
    cout<<endl<<endl<<endl;
    if(option == 1)
    {
        // Your code here return
       // return false to continue loop and return true to break the loop
    }
    if(option == 2)
    {
        // Your code here return
        // return false to continue loop and return true to break the loop
    }
    if(option == 3)
    {
        return true; // Option 3 is quit option the loop will break and menu will not be shown again
    }
}


int main()
{

    while(L1.ProcessMenu()=0)
    {
    }
}

The post How to write menu driven programs in a loop? first appeared on Pakzilla.

Visual Studio is an IDE (Integrated Development Environment), it’s not just
an editor, but you get debugging support, intellisense, refactoring tools and
much more. As a beginner, you will be learning the basic concepts of
languages and their use which might have chunks of basic projects which will
check your understanding of algorithms and syntaxes. To aid these, an IDE
gives you more tools to help you through tasks that are mundane. For
example, if I want to rename a variable, my tools can do a safe rename.
Meaning it actually goes through my codebase and makes sure the rename
happens across multiple files and to variables. It is apparent that Visual
Studio gives you a wide platform to code tirelessly which again is very
beneficial for a beginner to just focus on the logic and concept rather than
diving into the complexity of coding standards. Following are some features
of Visual Studio to support students:

● Custom or dynamic debugging and code analysis, which helps in
identifying the mistakes and enhancing the quality of code.
● It has fast navigation of code system which helps to find types easily and identify
where they’re referenced within the code or not.
● Advanced IntelliSense has prediction algorithm for
helping with the navigation of the codes.
● Live unit testing helps to automatically run impacted unit tests.

Whereas a text editor has no such tools and the developer has to write code
very vigilantly. The question arises whether the use of Visual Studio(IDE) is
beneficial for the developers in their career ahead? The answer is No. It is
true that Visual Studio is valuable for beginners but as a developer later you
should learn how to work without it, learn how you can compile the files,
how to use tools, how to write a program with only a simple text editor.
Remember that maybe someday you will have to work in an environment
without Visual Studio.
But Visual Studio is after all, a tool that will make your life easier and will
allow you to save time, so as a newcomer it’s worth learning and as long as
you can understand it and use it well.

The post Is Visual Studio a good option for a beginner? first appeared on Pakzilla.

char * Sentence; // Has a sentence “Happy Birthday to you”
char * word; // Has a word “Birthday”
int length; // length of word
//Step 1: Converting the First Letter of word into Upper or Lower case
int index = -1;
char Upper = 0, Lower = 0;
if (word[0] <= 90) {
  Lower = word[0] + 32;
} else {
  Upper = word[0] - 32;
}
int Indices[10];
for (int i = 0; i < 10; i++)
  Indices[i] = -1;
int I = 0;
for (int a = 0; sentence[a] != '\0'; a++) {
  if (sentence[a] == Upper || sentence[a] == Lower || sentence[a] ==
    word[0]) {
    index = a;
    Indices[I] = a;
    I++;
  }
}
//Step 2: Now For Each of these Index Positions, see if there is a match
I = 0;
while (Indices[I] != -1) {
  int indx = Indices[I];
  if (indx != -1) {
    indx++;
    int found = 1;
    for (int j = 1; j < length; j++) {
      if (sentence[indx] == word[j]) {
        indx++;
        found++;
      }
    }
    if (found == length) {
      return true;
    }
  }
  I++;
}
return false;
}

The post How to find substring of a string in C++? first appeared on Pakzilla.

In this case if the code of any team member is not up to the standards eventually it will be very difficult to understand and maintain it. So every programmer must follow these following rules:

1. Camel Casing: First characters of all words, except the first word are Upper Case and
   other characters are lower case. Use Camel casing for methods and variable names. For
   example,

void FeetAndInchesToMetersAndCent()
{
    //Keep all first letters capital for Functions

    int sumOfQuizzes;      //keep first letter small for first word in variables
    int sumOfAssignments;

}

2. Identifiers for constant should be in uppercase letters. For example,

const double CONVERSION = 2.54;
const int NO_OF_STUDENTS = 20;
const char BLANK = ' ';

3. Use Meaningful, descriptive words to name variables. Do not use abbreviations.

string address
int salary

// not recommended
string addr
int sal

4. Use TAB for indentation. Do not use SPACES. Define the Tab size as 4. Curly braces (
   {} ) should be in the same level as the code outside the braces.

if (beta >= 10)
{
    int alpha = 10;
    beta = beta + alpha;
    cout << alpha << ' ' << beta << endl;
}

5. Good and meaningful comments make code more maintainable. However,

• Do not write irrelevant comments for each line of code, every variable declared and above every function.
• You can use // or /// for comments. Using /* … */ should be avoided
• Write comments only when required. Good readable code will require very less comments. Moreover, If all variable and method names are meaningful, it will eventually make the code very readable and will need less comments
• Do not write unnecessary comments if the code is easily understandable and readable without comment. The disadvantage of having a lot of comments is, if you change the code and forget to change the comment, it will lead to more confusion and difficulty.
• Short lines of comments will enhance the elegancy of code. But if the code is not readable and there are less comments, that is considered as bad programming practice.
• If you have to use some complex or weird logic for any reason, document it very well with sufficient comments.

The post Good programming practices in Software Engineering first appeared on Pakzilla.

MVVM stands for Model, View, View Model.

Why MVVM?

• Makes the code more understandable with every class like adapters, model, View Model in a separate package.
• Makes the code maintainable for the long run because the repository class will be handling all API and Room data.
• Makes the code testable.
• Making changes, adding new features is easy because everything will be organized in a separate package so, it will be easy to make changes.

Model: The model is responsible for managing the application data and implements the business logic. It responds to the request of the view and also responds to the controller’s instructions to manipulate the data.

View: It represents the UI of the application in which we define our components like button, Text View, etc. The view can be a fragment or activity. View role in this pattern is to observe a View Model observable to get data to update UI elements accordingly.

View Model:  It is used to communicate between view and model and also prepares observable(s) that can be observed by a View.

Live Data: Live Data is a data holder and it is used to observe the changes of a particular view and then update the view when it is active.

Repository: The Repository is a simple Java class that is used to communicate between database | web server and View Model basically, in the repository class we fetch data from the server or the database, and View Model requests for the data that will be used for the View.

This is how we implement in the Android Studio:

In this project, we will make a Note App in which users can add a note, update the note and delete the note with the help of Room and MVVM.

Step 1: Add dependencies in build.gradle file
def lifecycle_version = "2.3.0"
// ViewModel
implementation "androidx.lifecycle:lifecycle-viewmodel:$lifecycle_version"
// LiveData
implementation "androidx.lifecycle:lifecycle-livedata:$lifecycle_version"

I am using MVVM with a Room so add room dependencies also

def room_version = "2.2.6"

//room
implementation "androidx.room:room-runtime:$room_version"
annotationProcessor "androidx.room:room-compiler:$room_version"

Step 2:  Create a model class

In model class I will have three entities title, description, priority, and id will be auto-generated.

@Entity(tableName = "note_table")
  public class Note {
    @PrimaryKey(autoGenerate = true)
    private int id;
    private String title;
    private String description;
    private int priority;
    public Note(String title, String description, int priority) {
        this.title = title;
        this.description = description;
        this.priority = priority;
    }
    public void setId(int id) {
        this.id = id;
    }
    public int getId() {
        return id;
    }
    public String getTitle() {
        return title;
    }
    public String getDescription() {
        return description;
    }
    public int getPriority() {
        return priority;
    }
  }
 

Step 3:  Create a Room Database Interface

In this class, we will create Database object. We have to turn this class into skeleton (which means we can’t create multiple instances of this database)

 


@Database(entities = {Note.class}, version = 1)
public abstract class NoteDatabase extends RoomDatabase {
    private static NoteDatabase instance; 
   

    public abstract NoteDao noteDao();

    public static synchronized NoteDatabase getInstance(Context context) {
        if (instance == null) {
            instance = Room.databaseBuilder(context.getApplicationContext(),
                    NoteDatabase.class, "note_database")
                    .fallbackToDestructiveMigration()
                    .addCallback(roomCallback).build();
        }
        return instance;
    }
}

Step 4:  Create a Room Dao class

In this class, we write all our queries for CRUD operation. Live Data will use to observe the object.

 @Dao
    public interface NoteDao {

        @Insert
        void insert(Note note);
        @Update
        void update(Note note);
        @Delete
        void delete(Note note);

        @Query("DELETE FROM note_table")
        void deleteAllNotes();

        @Query("SELECT * FROM note_table ORDER BY priority DESC")
        LiveData<List> getAllNotes();
    }
 

Step 5:  Create a Repository class

In this class, we create a repository class object and we will access the repository methods.

 public class NoteRepository {

    private NoteDao noteDao;
    private LiveData<List> allNotes;

    public NoteRepository(Application application) {
        NoteDatabase database = NoteDatabase.getInstance(application);
        noteDao = database.noteDao();
        allNotes = noteDao.getAllNotes();
    }


    public void update(Note note) {
        new UpdateNoteAsyncTask(noteDao).execute(note);
    }

    public void delete(Note note) {
        new DeleteNoteAsyncTask(noteDao).execute(note);
    }

    public void deleteAllNotes() {
        new DeleteAllNotesAsyncTask(noteDao).execute();
    }

    public LiveData<List> getAllNotes() {
        return allNotes;
    }

    public void insert(Note note) {
        new InsertNoteAsyncTask(noteDao).execute(note);
    }

    private static class InsertNoteAsyncTask extends AsyncTask {
        private NoteDao noteDao;
        private InsertNoteAsyncTask(NoteDao noteDao) {
            this.noteDao = noteDao;
        }
        @Override
        protected Void doInBackground(Note... notes) {
            noteDao.insert(notes[0]);
            return null;
        }
    }

//it is static so its dosen't have to be reference to repository itself otherwise it will cause mem leak
    private static class UpdateNoteAsyncTask extends AsyncTask {
        private NoteDao noteDao;//to make data operation
        private UpdateNoteAsyncTask(NoteDao noteDao) {
            this.noteDao = noteDao;//since the class is static we cant access rep notedao so we are usinng constructor
        }
        @Override
        protected Void doInBackground(Note... notes) {
            noteDao.update(notes[0]);//not single node
            return null;
        }
    }

    private static class DeleteNoteAsyncTask extends AsyncTask {
        private NoteDao noteDao;
        private DeleteNoteAsyncTask(NoteDao noteDao) {
            this.noteDao = noteDao;
        }
        @Override
        protected Void doInBackground(Note... notes) {
            noteDao.delete(notes[0]);
            return null;
        }
    }
    private static class DeleteAllNotesAsyncTask extends AsyncTask {
        private NoteDao noteDao;
        private DeleteAllNotesAsyncTask(NoteDao noteDao) {
            this.noteDao = noteDao;
        }
        @Override
        protected Void doInBackground(Void... voids) {
            noteDao.deleteAllNotes();
            return null;
        }
    }

}

Step 6:  Create a View Model class

In this class, we create a repository class object and we will access the repository methods.

 public class NoteViewModel extends AndroidViewModel {

        private NoteRepository repository;
        private LiveData<List> allNotes;

        public NoteViewModel(@NonNull Application application) {
            super(application);

            repository = new NoteRepository(application);
            allNotes = repository.getAllNotes();
        }

        public void insert(Note note) {
            repository.insert(note);
        }
        public void update(Note note) {
            repository.update(note);
        }
        public void delete(Note note) {
            repository.delete(note);
        }
        public void deleteAllNotes() {
            repository.deleteAllNotes();
        }
        public LiveData<List> getAllNotes() {
            return allNotes;
        }

    }
 

Step 7:  Create an Activity(View) class      (Last Step)

In this class, we create a view model class object and we will access the methods of view model class.

 public class MainActivity extends AppCompatActivity {

    private NoteViewModel noteViewModel;//for communicating with ViewModel.
    public static final int ADD_NOTE_REQUEST = 1;
    public static final int EDIT_NOTE_REQUEST = 2;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        //initalize the view model
        //noteViewModel = new ViewModelProvider(this ).get(NoteViewModel.class);

        FloatingActionButton floatingActionButton=findViewById(R.id.add_note);
        floatingActionButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent intent = new Intent(MainActivity.this, AddEditNoteActivity.class);
                startActivityForResult(intent, ADD_NOTE_REQUEST);
            }
        });

        RecyclerView recyclerView=findViewById(R.id.recycler_view);
        recyclerView.setLayoutManager(new LinearLayoutManager(this));
        recyclerView.setHasFixedSize(true);

        final NoteAdapter adapter = new NoteAdapter();
        recyclerView.setAdapter(adapter);

        noteViewModel = new ViewModelProvider(this,
                ViewModelProvider.AndroidViewModelFactory.getInstance(this.getApplication())).get(NoteViewModel.class);


        //bcz this return live data
        //it will update only when app in foreground

        //this will be called when ever live data changes in our data
        //update recyclerview
        //when ever changes are made in the table our adapter will be updated with new list of notes


        noteViewModel.getAllNotes().observe(this, new Observer<List>() {
            @Override
            public void onChanged(List notes) {


                adapter.setNotes(notes);
            }
        });



        new ItemTouchHelper(new ItemTouchHelper.SimpleCallback(0,
                ItemTouchHelper.LEFT | ItemTouchHelper.RIGHT) {
            @Override
            public boolean onMove(RecyclerView recyclerView, RecyclerView.ViewHolder viewHolder, RecyclerView.ViewHolder target) {
                return false;
            }
            @Override
            public void onSwiped(RecyclerView.ViewHolder viewHolder, int direction) {
                noteViewModel.delete(adapter.getNoteAt(viewHolder.getAdapterPosition()));
                Toast.makeText(MainActivity.this, "Note deleted", Toast.LENGTH_SHORT).show();
            }
        }).attachToRecyclerView(recyclerView);


        adapter.setOnItemClickListener(new NoteAdapter.OnItemClickListener() {
            @Override
            public void onItemClick(Note note) {
                Intent intent = new Intent(MainActivity.this, AddEditNoteActivity.class);
                intent.putExtra(AddEditNoteActivity.EXTRA_ID, note.getId());
                intent.putExtra(AddEditNoteActivity.EXTRA_TITLE, note.getTitle());
                intent.putExtra(AddEditNoteActivity.EXTRA_DESCRIPTION, note.getDescription());
                intent.putExtra(AddEditNoteActivity.EXTRA_PRIORITY, note.getPriority());
                startActivityForResult(intent, EDIT_NOTE_REQUEST);
            }
        });

    }


    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);

        if (requestCode == ADD_NOTE_REQUEST && resultCode == RESULT_OK) {
            String title = data.getStringExtra(AddEditNoteActivity.EXTRA_TITLE);
            String description = data.getStringExtra(AddEditNoteActivity.EXTRA_DESCRIPTION);
            int priority = data.getIntExtra(AddEditNoteActivity.EXTRA_PRIORITY, 1);
            Note note = new Note(title, description, priority);
            noteViewModel.insert(note);
            Toast.makeText(this, "Note saved", Toast.LENGTH_SHORT).show();
        }

        else if (requestCode == EDIT_NOTE_REQUEST && resultCode == RESULT_OK) {
            int id = data.getIntExtra(AddEditNoteActivity.EXTRA_ID, -1);
            if (id == -1) {
                Toast.makeText(this, "Note can't be updated", Toast.LENGTH_SHORT).show();
                return;
            }
            String title = data.getStringExtra(AddEditNoteActivity.EXTRA_TITLE);
            String description = data.getStringExtra(AddEditNoteActivity.EXTRA_DESCRIPTION);
            int priority = data.getIntExtra(AddEditNoteActivity.EXTRA_PRIORITY, 1);
            Note note = new Note(title, description, priority);
            note.setId(id);//without this update will not happen
            noteViewModel.update(note);
            Toast.makeText(this, "Note updated", Toast.LENGTH_SHORT).show();
        }

        else {
            Toast.makeText(this, "Note not saved", Toast.LENGTH_SHORT).show();
        }
    }


    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        MenuInflater menuInflater = getMenuInflater();
        menuInflater.inflate(R.menu.main_menu, menu);
        return true;
    }
    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        switch (item.getItemId()) {
            case R.id.delete_all_notes:
                noteViewModel.deleteAllNotes();
                Toast.makeText(this, "All notes deleted", Toast.LENGTH_SHORT).show();
                return true;
            default:
                return super.onOptionsItemSelected(item);
        }
    }
}

For complete project:

https://github.com/bilal96aslam/MVVM

The post How to implement MVVM architecture in Android? first appeared on Pakzilla.

There are times when reading data from the DataTables is simply too slow, particularly when dealing with thousands of data rows. To address this slowness of data, DataTables’ server-side processing feature provides a method to let all the “heavy loading” be done by a database engine on the server-side 

Simple query to get data from server

 $listing = DB::table('table_name')->get();
//Records around 50K

Pass your query result to DataTable object in PHP Laravel

return DataTables::of($listing)->make();

HTML DataTable

<table class="YOURTABLE mdl-data-table table-striped table-hover dataTable" cellspacing="0" width="100%" role="grid" style="width: 100%;">
<thead>
<tr>
<th>First</th>
<th>Second</th>
<th>Third</th>
<th>Forth</th>
</tr>
</thead>
<tbody>
</tbody>
</table>

Configuration

Lazy Loading in DataTables is enabled through use of the serverSide option. Simply set it to true and DataTables will operate in server-side processing mode. In JS file–

var url = '/fetch-list';
    $('.YOURTABLE').DataTable({
        processing: true,
        serverSide: true,
        destroy: true,
        ajax: url,
        dom: 'Bfrtip',
        "columnDefs": [
            { "searchable": false, "targets": 6 }
        ],
        buttons: [
            'pageLength', 'csv', 'excel', 'pdf', 'print'
        ],
        "lengthMenu": [[10, 25, 50, -1], [10, 25, 50, 100]],
        "pagingType": "full_numbers",
        "columns": [
            {"data": "FIRST"},
            {"data": "SECOND"},
            {"data": "THIRD"},
            {"data": "FOURTH"}
]
    });

The post DataTables Lazy Loading using PHP Laravel first appeared on Pakzilla.

(Currently, only Mac shortcuts are available. Windows and Linux shortcuts coming soon.)

Must-Know Shortcuts:

Never-ever-ever forget these shortcuts.

Frequently Used Shortcuts:

You will surely need these quite often.

Useful Shortcuts:

These can help you level up your development workflow.

View And Add Shortcuts in Android Studio

By going to Settings >> Keymap A window will popup showing All the Editor Actions with the their name and shortcuts. Some of the Editor Actions do not have shortcuts. So right click on that and add a new shortcut to that.

The post Android Studio Useful Shortcuts first appeared on Pakzilla.

1. $ df command – Shows the amount of disk space used and available in file systems.
2. $ du command – Display the amount of disk space used by the specified files and for each sub-directory.
3. $ btrfs fi df /device/ – Show disk space usage information for a btrfs based mount point/file system.
4. Pass the -h option to see output in human readable format size in gigabytes or terabytes or megabytes: like $ df -h
5. Display output using inode usage instead of block usage like $ df -i
6. Pass the -T option to display the type of each file systems listed such as ext4, btrfs, ext2, nfs4, fuse, cgroup, cputset etc. like $ df -T
7. Pass -t TYPE to only see specific file system liek $ df -t ext3
8. To list all but exclude ext2 filesystem pass the -x TYPE option. like $ df -x ext2
9. Pass the -a or –all option to the df command to show all file system. like $ df -a
10. For btrfs filesystem use the btrfs fi df command to see space usage information for a mount point. The syntax is: btrfs filesystem df /path/ $btrfs fi df /dev/path

df COMMAND OUTPUT

You can pass the output format defined by ‘valid field name’ as follows:
$ df --output=field1,field2,...
$ df --output=source,used,avail /data/

Clear disk space on CentOS

Following are quick commands to clear disk space on CentOS 6 or CentOS 7 servers.

$ yum -y install yum-utils

1- Trim Log Files

Following command will truncate any *.log files on the volume /var that are either older than 7 days and greater than 50M or older than 30 days.

$ find /var -name "*.log" \( \( -size +50M -mtime +7 \) -o -mtime +30 \) -exec truncate {} --size 0 \;

2- Clean Yum Cache

$ yum clean all
$ rm -rf /var/cache/yum # Remove orphaned data 
$ rm -rf /var/tmp/yum-* # Delete regular user cache

3- Remove Orphan Packages

# Check existing orphan packages
$ package-cleanup --quiet --leaves --exclude-bin 
# confirm removing
$ package-cleanup --quiet --leaves --exclude-bin | xargs yum remove -y 

4- Remove out dated kernels

# Keeps only latest two kernels, Note: reboot first in order to boot up from # latest kernel.
$ package-cleanup --oldkernels --count=2

5- Remove Composer cache & WP CLI cached WordPress downloads

# WordPress new setup site cache
$ rm -rf /root/.wp-cli/cache/*
$ rm -rf /home/*/.wp-cli/cache/*

# Remove Composer cache
$ rm -rf /root/.composer/cache
$ rm -rf /home/*/.composer/cache

6- Remove core dumps

#If some severe failures with PHP and core dumps enabled
$ find -regex ".*/core\.[0-9]+$" -delete

7-  Remove error_log files

$find /home/*/public_html/ -name error_log -delete

8- Remove Node.js caches

$ rm -rf /root/.npm /home/*/.npm /root/.node-gyp /home/*/.node-gyp /tmp/npm-*

9- Cannot find what is filling up disk space

if you having a hard time trying to audit disk utilization on your Linux system?. If you cannot find what is using the space up with du -sh * . A very useful option that might help you find out what is using up space is ncdu Install it.

$ sudo yum install ncdu  # For CentOS 
$ sudo dnf install ncdu  # For Fedora
$ sudo apt-get install ncdu # For Ubuntu/Debian

Once the package is installed on your OS, simply run:

$ ncdu /dir/

Ncdu also provide a number of options to manipulate files and folders – Navigation, sorting, and even deleting:

• up, k – used to move the cursor up
• down, j – used to move the cursor down
• right, enter, l > – Open selected directory
• left, <,h  – This opens parent directory
• n – order by name (press again for descending order)
• s – Order by file size (press again for descending order)
• d – Delete selected file or directory
• g – Show percentage and/or graph
• t – Toggle dirs before files when sorting.
• c – Toggle display of child item counts.
• b – Spawn shell in the current directory.
• i  – Show information about the selected item
• r – Refresh/recalculate the current directory.
• q – Quit ncdu

The post Clean Up Disk Space on CentOS first appeared on Pakzilla.