Forem: Emdadul Islam

What is Science, Computer Science, and Engineering?

Emdadul Islam — Wed, 22 May 2024 05:38:22 +0000

There's such a great conflict that people sometimes say that computer science is not even a science. Is that true? Then what's actually the difference between science and computer science?

Also, what actually is engineering?

Title: A Beginner's Guide to Command-Line File and Directory Manipulation

Emdadul Islam — Sun, 03 Mar 2024 04:10:43 +0000

In the realm of command-line interfaces, understanding basic commands for file and directory manipulation is a fundamental skill. Whether you're navigating through your file system or creating, modifying, and deleting files and directories, these commands empower users to efficiently manage their digital workspace. In this guide, we'll explore essential command-line commands and create a cheat sheet for quick reference.

Navigation Commands:

pwd (Print Working Directory):
- Displays the full path of the current working directory.

pwd

ls (List):
- Lists the contents of the current directory.

ls

cd (Change Directory):
- Change into an existing directory.

   cd directory-name

cd .. (Move Backward):
- Move back one directory level (to the parent directory).

   cd ..

cd directory/sub-directory:
- Change forward through multiple directories.

   cd directory/sub-directory

cd ../.. (Move Backward Multiple):
- Move backward through multiple directories.

   cd ../..

File and Directory Manipulation:

mkdir (Make Directory):
- Create a new directory.

   mkdir directory-name

touch:
- Create a new file.

   touch file-name

echo "text" > file:
- Overwrite a file with specified text.

   echo "text" > file

echo "text" >> file:
- Append text to the end of a file.
```
echo "text" >> file
```
cat file-a > file-b:
- Overwrite content of file-b with content of file-a.
```
cat file-a > file-b
```
cat file-a >> file-b:
- Append content of file-a to content of file-b.
```
cat file-a >> file-b
```
mv source-file target-file:
- Move/rename source-file to target-file.
```
mv source-file target-file
```
mv source-dir target-dir:
- Move/rename source-directory to target-directory.
```
mv source-dir target-dir
```
rm file:
- Delete a file.
```
rm file
```
rm -r directory:
- Delete a non-empty directory.
```
rm -r directory
```
rmdir directory:
- Delete an empty directory.
```
rmdir directory
```
cp file-a > file-b:
- Copy content of file-a into file-b (overwrite).
```
cp file-a > file-b
```
cp -r dir-a dir-b:
- Copy content of dir-a into dir-b (overwrite).
```
cp -r dir-a dir-b
```

Additional Commands:

clear:
- Clear the command line.
```
clear
```

Conclusion:

Mastering these basic command-line operations provides a solid foundation for navigating and managing files and directories in a terminal environment. Always exercise caution, double-check your commands, and remember that certain actions, such as deletion, can be irreversible. With this cheat sheet, you're well on your way to becoming proficient in command-line file and directory manipulation. Happy coding!

Mongoose Cheat Sheet

Emdadul Islam — Sat, 01 Apr 2023 07:21:39 +0000

If you're working with Mongoose, the popular object data modelling (ODM) library for MongoDB in Node.js, having a quick reference guide or "cheat sheet" can be incredibly helpful. In this blog post, we provide a concise summary of some of the most commonly used Mongoose methods and syntax, organized by category, to help you work more efficiently and effectively with this powerful ODM.

Schema definition

const { Schema } = require('mongoose');

const userSchema = new Schema({
  name: String,
  email: { type: String, unique: true },
  age: Number,
  isAdmin: { type: Boolean, default: false },
  createdAt: { type: Date, default: Date.now }
});

Model definition

const mongoose = require('mongoose');
const userSchema = require('./userSchema');

const User = mongoose.model('User', userSchema);

Creating a document
const user = new User({
  name: 'John Doe',
  email: 'johndoe@example.com',
  age: 30
});

user.save();

Finding documents

// Find all documents
const users = await User.find();

// Find documents that match a query
const admins = await User.find({ isAdmin: true });

// Find a single document by ID
const user = await User.findById(userId);

Updating documents

// Update a single document by ID
await User.findByIdAndUpdate(userId, { name: 'Jane Doe' });

// Update multiple documents that match a query
await User.updateMany({ isAdmin: true }, { isAdmin: false });

Deleting documents

// Delete a single document by ID
await User.findByIdAndDelete(userId);

// Delete multiple documents that match a query
await User.deleteMany({ isAdmin: false });

Validation

const userSchema = new Schema({
  name: { type: String, required: true },
  email: { type: String, required: true, unique: true },
  age: { type: Number, min: 18 },
  isAdmin: { type: Boolean, default: false },
  createdAt: { type: Date, default: Date.now }
});

In Mongoose, you can define relationships between models using references or subdocuments.

*Using references:
*
To define a relationship between two models using references, you can use the ref property in a field definition. The ref property specifies the name of the target model. Here's an example:

const userSchema = new mongoose.Schema({
  name: String,
  posts: [{
    type: mongoose.Schema.Types.ObjectId,
    ref: 'Post'
  }]
});

const postSchema = new mongoose.Schema({
  title: String,
  content: String,
  author: {
    type: mongoose.Schema.Types.ObjectId,
    ref: 'User'
  }
});

In this example, we have two models: User and Post. The User model has a field called posts, which is an array of ObjectId values that reference Postdocuments. The Post model has a field called author, which is an ObjectIdvalue that references a User document.

To populate the posts field of a User document with the corresponding Post documents, you can use the populate() function:

const user = await User.findById(userId).populate('posts');

This will retrieve the User document with the specified _id value and then retrieve the Post subdocument with the specified postId value.

Push local repository to another user remote repository

Emdadul Islam — Sat, 24 Dec 2022 16:11:40 +0000

To push changes from your local repository to another user's repository, you will need to have push access to that repository. If you do not have push access, you will need to ask the owner of the repository to grant you access.

If you have push access to the repository, you can follow these steps:

Clone the repository to your local machine using git clone and the repository's URL.

git clone https://github.com/user/repo.git

Change into the repository's directory.

cd repo

Make the necessary changes and commit them to your local repository.

Add the remote repository as a remote for your local repository. Replace user and repo with the appropriate values.

git remote add upstream https://github.com/user/repo.git

Push your changes to the remote repository.

git push upstream

Alternatively, you can also use a GUI client for Git such as GitHub Desktop or GitKraken to push changes to a remote repository.

How to create a REACT app

Emdadul Islam — Mon, 19 Dec 2022 00:10:10 +0000

To create a React application, you will need to have Node.js and npm (or yarn) installed on your computer. Once you have those tools, you can create a new React app by using the create-react-app command line utility. Here's an example:

npx create-react-app my-app

This will create a new directory called my-app inside your current directory, and it will generate all the necessary files for a basic React app. Once the app is created, you can navigate to the app directory and start the development server by running the following commands:

cd my-app
npm start

Alternatively, if you're using yarn, you can use the following commands:

cd my-app 
yarn start

This will start the development server and open the React app in your default web browser. You can then start building your React app by editing the files in the src directory.