My 2023 📅 Tech Toolbox 📦 : What i learned in 2023

Ajnash-ibn-umer — Sat, 23 Dec 2023 10:00:47 +0000

2023 has been a big year for me😃, especially at work. It's my second year as a Full Stack and Node.js developer, and I've learned a bunch of new things👨🏻‍🎨.

In this article, I want to share the cool technologies I learned in 2023 🎤 . Some are not so new, but they've become super important for my job.

GraphQL📈

GraphQL, developed by Facebook in 2012 and shared as an open-source tool in 2015, stands out as one of my favorite technologies learned this year. It's been a game-changer in reducing my backend workload for creating APIs.

Before GraphQL, building APIs for various platforms like web, Android, and iOS meant dealing with different API requirements for each—quite a headache. But with GraphQL, things got simpler. It acts like a language that helps client-side developers easily pick and choose the data they need from APIs. This means we can avoid sending too much or too little data, solving issues like over-fetching and under-fetching.

However, as much as I love GraphQL, it's still evolving and has its limitations. For instance, it doesn't support file uploads yet, which has been a significant challenge. Also, learning GraphQL can be a bit tough, and there are some limits to the support it provides for additional software. Despite these challenges, its advantages make it an incredible tool for developers.

Nest.js 🪹

Nest.js is a newer framework built on top of the widely-used Express.js for Node.js development. As a backend developer, I used to rely heavily on Express.js, but it has its limitations. Switching to Nest.js offered a solution.

What's great about Nest.js is that it retains all the functionality of Express.js while adding more features. Its documentation is thorough, making it developer-friendly. Plus, it seamlessly integrates with databases like MongoDB, MySQL, and more. Its ecosystem is vast, allowing easy integration with various other technologies.

However, there are a couple of challenges. Nest.js has a steeper learning curve compared to other Node.js frameworks. Additionally, it primarily operates in TypeScript, which might require some adjustment for developers more familiar with JavaScript. These factors stand as the main drawbacks I encountered with Nest.js

AWS ☁️

AWS, also known as Amazon Web Services, is a widely recognized cloud computing platform. It's been around since 2006, offering over 200 services. Learning all these services in a year is quite a task. So, in 2023, I started my journey with AWS by focusing on essential services like Elastic Cloud Compute, S3 Bucket, Lightsail, and Elastic Beanstalk. I've been continuously learning more about AWS services.

Cloud computing is a big deal, and AWS is a significant player. I strongly recommend learning AWS or its alternatives like GCP, Microsoft Azure, or DigitalOcean for developers. The future of technology is leaning heavily on the capabilities of the cloud, making these skills essential for any developer.

Next.js 🕸️

Next.js is a framework built for React, helping create full-stack web apps. You use React Components for building interfaces and leverage Next.js for extra features and improvements.

Initially launched in 2016, Next.js released version 13 in 2023, packed with new features like the app Directory, React Server Components (RSC), Automatic Static Optimization (ASO), Edge Runtime, Improved Image Component (next/image), and Font Optimization (@next/font).

Personally, Next.js is my top choice among frontend frameworks. It's easier to learn compared to others like Angular or Ember, and it comes with loads of features like SSR (Server-Side Rendering), SSG (Static Site Generation), and more.

WebRTC 📟

WebRTC, short for Web Real-Time Communication, is a free project that enables instant audio, video, and data sharing directly through web browsers and mobile apps. It's like giving your web setup direct communication superpowers.

It's commonly used for direct client-to-client communication, bypassing the need for a server. WebRTC relies on a swift protocol called UDP, making it lightning-fast.

For a personal project, I delved into WebRTC, especially for crafting a video call app. However, despite its serverless communication between two clients, it still requires a signaling server to facilitate their connection.

But WebRTC comes with its challenges. It has a steep learning curve, making it a bit tough to grasp. Also, being in a developmental stage, it lacks extensive community support and a mature ecosystem. These drawbacks can make navigating and troubleshooting a bit tricky for developers.

Conclusion 🫂

In 2023, I immersed myself in various technologies, many of which were driven by job requirements. Amidst them, five technologies stood out as my favorites. Alongside these, I explored others like Firebase, Algolia, Bun.js, Fastify, and more.

Learning isn't a destination; it's an ongoing journey. While I've gained a good grasp of these technologies, I don't consider myself a pro. In the ever-evolving world of technology and science, staying updated is key. Learning should be a routine for all developers, including myself. My goal for the next year is to continue enhancing my skills and staying current.

I'd love to hear your thoughts on this article! Feel free to share your learnings from 2023. Let's keep the conversation about growth and learning alive

Understanding Value Types and Reference Types in JavaScript

Ajnash-ibn-umer — Sun, 19 Mar 2023 10:48:57 +0000

When working with JavaScript, understanding the difference between value types and reference types is essential for writing efficient and effective code. This blog post will provide an overview of these two data types and explain how they differ in terms of memory allocation and variable assignment. By the end of this post, you will have a clear understanding of the benefits and limitations of each data type and be able to make informed decisions about how to use them in your own code. Whether you're a beginner or an experienced JavaScript developer, this post will provide valuable insights into one of the most fundamental aspects of the language.

In JavaScript, data types can be classified into two categories: value types and reference types. Understanding the difference between these two types is crucial for writing efficient and effective code.

Value types are simple data types such as numbers, strings, and booleans. When a value type is assigned to a variable, the variable stores a copy of the value itself. This means that any changes made to the variable do not affect the original value. For example:

let num1 = 5;
let num2 = num1;
num2 = 10;
console.log(num1); // Output: 5
console.log(num2); // Output: 10

In this example, num1 is assigned the value 5. When num2 is assigned the value of num1, it creates a copy of the value stored in num1. Any changes made to num2 do not affect the value of num1.

Reference types, on the other hand, are objects such as arrays and functions. When a reference type is assigned to a variable, the variable stores a reference to the object in memory, rather than a copy of the object itself. This means that any changes made to the object through one variable will also affect the object as accessed through other variables. For example:

let obj1 = {
    name: 'John',
    age: 20,

}
let obj2 = obj1;
obj2["position"]="developer"
console.log(obj1); // { name: 'John', age: 20, position: 'developer' }
console.log(obj2); // { name: 'John', age: 20, position: 'developer' }

In this example, obj1 is an object with two elements. When obj2 is assigned the value of obj1, it creates a reference to the same object in memory. When obj2 is modified by adding an element, it also modifies obj1 since both variables reference the same object in memory.

In conclusion, understanding the difference between value types and reference types is crucial in writing efficient JavaScript code. By optimizing memory usage and avoiding common pitfalls, developers can write better code and build more effective applications.

DEV Community: Ajnash-ibn-umer