DEV Community: Sibi🥱

Must know concepts of JS to make life simple

Sibi🥱 — Fri, 03 Nov 2023 20:13:17 +0000

Promises and Async/Await:

Handling asynchronous operations in JavaScript will be a pain, especially using callbacks. If one uses callbacks he'll find himself in callback hell. To avoid that, we use

Promises - A way to handle asynchronous operations in JavaScript.
Async/await - It simplifies working with Promises. It makes asynchronous code look synchronous.
async function fetchData() { try { let response = await fetch('https://api.example.com/data'); let data = await response.json(); console.log(data); } catch (error) { console.error(error); } }

Modules in JavaScript:

Modules are an alternative of commonJS which is a feature of ECMA script that allows us to organize code into reusable and maintainable units by exporting and importing modules.
export export function myFunction() { // Your code here }
import import { myFunction } from (path of the export file)

Event Handling:

Handling user interactions and events like adding event listeners to buttons or forms.
const button = document.querySelector('#myButton'); button.addEventListener('click', () => { // Your event handling code here });

map() Function:

The map() function is a powerful and commonly used array method in JavaScript. It allows you to transform each element of an array by a function and create a new array based on the result.
const numbers = [1, 2, 3, 4, 5]; // map function to double each number const doubledNumbers = numbers.map((number) => { return number * 2; });
console.log(doubledNumbers); // Output: [2, 4, 6, 8, 10]

Mastering A Framework

Sibi🥱 — Tue, 22 Aug 2023 10:37:00 +0000

Learning a new framework can be both exciting and challenging for any web developer. Whether you're a backend-focused developer like yourself or someone well-versed in front-end technologies, approaching a new framework can seem like a daunting task. However, with the right mindset and strategy, you can master a new framework effectively. In this blog post, we'll explore a step-by-step approach to learning a new framework.

Understand the Basics:

Before diving into the new framework, take some time to understand its fundamental concepts. Familiarize yourself with its core components, architecture, and the problem it aims to solve. This foundation will help you grasp the framework's purpose and structure.

Explore Documentation:

Documentation is your best friend when it comes to learning a new framework. Dive into the official documentation provided by the framework's creators. This resource will give you insights into the framework's features, syntax, and usage. Follow tutorials and guides to build small projects, gradually increasing the complexity.

Hands-on Coding:

Theory alone won't make you proficient in a new framework. Start coding as soon as you understand the basics. Begin with simple exercises and gradually move to more complex projects. Apply the concepts you've learned to practical scenarios to solidify your understanding.

Build a Project:

One of the most effective ways to learn a new framework is to build a project from scratch. Choose a project idea that aligns with your interests and showcases the framework's capabilities. This hands-on experience will teach you problem-solving and application of the framework's features in a real-world context.

Study Existing Projects:

To gain deeper insights, study open-source projects built with the framework. Analyze their code structure, design patterns, and best practices. This will expose you to different ways of using the framework and improve your coding skills.

Experiment and Tinker:

Don't be afraid to experiment with the framework. Try out different approaches, refactor your code, and explore advanced features. Learning often involves making mistakes, so embrace them as opportunities for growth.

Online Communities:

Engage with the framework's community. Join forums, discussion boards, and social media groups dedicated to the framework. Here, you can ask questions, share your progress, and learn from others' experiences.

Pair Programming:

Consider pair programming with a colleague or a friend who's familiar with the framework. Collaborative coding can expose you to new techniques, debugging strategies, and different viewpoints.

Stay Updated:

Frameworks evolve over time, so it's important to stay updated with the latest releases, features, and best practices. Follow the framework's official channels and subscribe to newsletters or blogs that provide updates.

Teach Others:

Once you've gained proficiency, consider sharing your knowledge. Write blog posts, create tutorials, or give talks about your experience with the new framework. Teaching others not only solidifies your understanding but also contributes to the developer community.

Learning a new framework requires dedication, patience, and a willingness to embrace challenges. By following these steps and maintaining a growth-oriented mindset, you'll find yourself becoming adept at using the framework in no time. Happy learning!

Building Backends with Node.js and MongoDB

Sibi🥱 — Fri, 18 Aug 2023 16:52:01 +0000

As a seasoned backend Node.js developer, I understand the importance of creating robust and efficient applications. In this blog post, we will delve into the world of Node.js and MongoDB, exploring best practices and techniques that can help you build powerful and scalable backend systems.

To develop a Robust project the foundation needs to be strong, for that the general practice of creating a node project is shared below step-by-step

Create a project folder like "nodeBasic" and cd into the directory.
Run "npm init" and setup the project.
Now type "npm i express" to add express in your dependency
In the directory create index.js file and follow along with the code below.

const express = require('express');
const app = express();

app.get('/api/users', (req, res) => {
  const users = ['User 1', 'User 2', 'User 3'];
  res.json(users);
});

const PORT = 3000;
app.listen(PORT, () => {
  console.log(`Server listening on port ${PORT}`);
});

Express.js, a minimal and flexible web application framework for Node.js, simplifies the process of building APIs. Its middleware architecture, routing capabilities, and extensibility make it a go-to choice for backend developers.

Now to connect the Mongo db we are going to use the most famous ODM "Mongoose"
To install it type "npm i mongoose"
Then follow along the code in the index.js file to connect the mongo db

const mongoose = require('mongoose');

mongoose.connect('mongodb://{localhost:PORT}/nodeBasic')
  .then(() => console.log('Connected to MongoDB'))
  .catch(error => console.error('Error connecting to MongoDB:', error));

Node.js and MongoDB form a powerful duo for backend development. With Node.js's event-driven architecture and MongoDB's flexibility, you can create highly responsive and scalable applications. By utilizing frameworks like Express.js, you can design elegant APIs that cater to your application's needs. As you embark on your backend journey, remember to prioritize code quality, security, and performance to build a foundation that stands the test of time.

Thank you for joining me on this exploration of backend development with Node.js and MongoDB. If you found this blog post helpful, stay tuned for more insights and tips in the future!