DEV Community: Afzal Imdad

Identity and Access Management in 2026: The Future of Secure Authentication

Afzal Imdad — Tue, 20 Oct 2026 03:52:03 +0000

Identity and Access Management in 2026: The Future of Secure Authentication

Published: Sunday, June 7, 2026

As we navigate the complex landscape of digital identity and access management in 2026, it's clear that the traditional password-based approach is no longer sufficient. With the Identity and Access Management (IAM) market exceeding $50 billion and Gartner predicting that 90% of multi-factor authentication (MFA) will be performed via FIDO by 2027, it's evident that passwordless authentication is becoming the new enterprise baseline. In this article, we'll explore the current state of IAM, the benefits of passwordless authentication, and provide practical guidance on implementing secure authentication solutions in your organization.

The Evolution of Identity and Access Management

The IAM market has undergone significant transformations in recent years, driven by the increasing need for secure and seamless user experiences. As more organizations adopt cloud-based services and mobile applications, the traditional perimeter-based security approach is no longer effective. In response, IAM solutions have evolved to incorporate advanced authentication methods, such as biometric authentication, behavioral analysis, and artificial intelligence (AI)-powered risk assessment.

Passwordless Authentication: The Future of Secure Access

Passwordless authentication is a game-changer for organizations seeking to enhance security and improve user experience. By eliminating the need for passwords, organizations can reduce the risk of phishing attacks, password sprawl, and credential reuse. Instead, users can authenticate using alternative methods, such as:

Biometric authentication (e.g., fingerprint, facial recognition, or voice recognition)
Behavioral analysis (e.g., device fingerprinting, location-based authentication)
Token-based authentication (e.g., smart cards, one-time passwords)

To demonstrate the simplicity of passwordless authentication, let's consider an example using the FIDO2 protocol:

// FIDO2 authentication example
const fido2 = require('fido2');

// Create a new FIDO2 client
const client = new fido2.Client();

// Register a new user
client.register({
  username: 'john.doe',
  displayName: 'John Doe',
  attestation: 'none',
  authenticatorSelection: {
    authenticatorAttachment: 'platform',
    userVerification: 'required',
  },
}, (err, registration) => {
  if (err) {
    console.error(err);
  } else {
    console.log('Registration successful!');
  }
});

This example illustrates the registration process for a new user using the FIDO2 protocol. The fido2 library provides a simple and intuitive API for implementing passwordless authentication in your application.

Implementing Secure Authentication Solutions

To implement secure authentication solutions in your organization, follow these best practices:

Conduct a risk assessment: Identify potential vulnerabilities and threats to your organization's assets.
Choose the right authentication method: Select an authentication method that balances security and usability, such as passwordless authentication or MFA.
Implement a robust authentication framework: Use a standardized framework, such as OAuth 2.0 or OpenID Connect, to ensure secure authentication and authorization.
Monitor and analyze authentication events: Use logging and analytics tools to detect and respond to potential security threats.

The Role of Artificial Intelligence in IAM

AI is playing an increasingly important role in IAM, enabling organizations to detect and respond to security threats in real-time. AI-powered IAM solutions can analyze user behavior, identify patterns, and predict potential security risks. For example, AI-powered risk assessment can help organizations detect and prevent phishing attacks by analyzing user behavior and identifying suspicious activity.

Conclusion

In conclusion, identity and access management is a critical aspect of modern cybersecurity, and passwordless authentication is the future of secure access. By understanding the benefits and challenges of passwordless authentication, organizations can implement secure authentication solutions that balance security and usability. As we continue to navigate the complex landscape of IAM in 2026, it's essential to stay informed about the latest trends and best practices in secure authentication.

Call to Action

If you're interested in learning more about passwordless authentication and IAM, we encourage you to share your thoughts and experiences in the comments below. Follow us for more articles on cybersecurity, AI, and emerging technologies, and stay up-to-date with the latest news and trends in the industry. Together, let's shape the future of secure authentication and create a more secure and seamless user experience for all.

Empowering the Future: Top Energy Software Development Trends to Watch in 2026

Afzal Imdad — Tue, 20 Oct 2026 03:51:37 +0000

Empowering the Future: Top Energy Software Development Trends to Watch in 2026

Published: Saturday, June 6, 2026

As we navigate the complexities of the 21st century, the energy sector is undergoing a profound transformation. On Saturday, June 6, 2026, it's essential to recognize the pivotal role that software development plays in shaping the future of energy production, distribution, and consumption. The intersection of energy and technology has given rise to innovative solutions that not only enhance efficiency but also contribute to a more sustainable world. In this article, we'll delve into the top energy software development trends that are redefining the industry and explore how companies like Computools are leading the charge.

The Digital Transformation of Energy

The energy sector is no stranger to digital transformation. Over the years, we've seen a significant shift towards the adoption of digital technologies to optimize energy production, reduce waste, and improve customer experiences. This trend is expected to continue in 2026, with a greater emphasis on leveraging advanced technologies like Artificial Intelligence (AI), Machine Learning (ML), and the Internet of Things (IoT). For instance, AI-powered predictive maintenance can help identify potential issues in energy infrastructure before they occur, reducing downtime and increasing overall efficiency.

# Example of AI-powered predictive maintenance using Python
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split

# Load data
data = pd.read_csv('energy_data.csv')

# Split data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(data.drop('target', axis=1), data['target'], test_size=0.2, random_state=42)

# Train random forest classifier
rf = RandomForestClassifier(n_estimators=100, random_state=42)
rf.fit(X_train, y_train)

# Make predictions
predictions = rf.predict(X_test)

The Rise of Renewable Energy Sources

Renewable energy sources like solar, wind, and hydroelectric power are becoming increasingly important in the global energy mix. As technology improves and costs decrease, we can expect to see a significant increase in the adoption of renewable energy sources in 2026. Energy software development will play a critical role in this transition, enabling the efficient integration of renewable energy sources into the grid and optimizing energy distribution.

# Example of renewable energy source integration using Python
import numpy as np

# Define renewable energy sources
solar = np.array([100, 120, 150, 180, 200])  # Solar energy production in kW
wind = np.array([50, 60, 70, 80, 90])  # Wind energy production in kW

# Calculate total renewable energy production
total_renewable_energy = solar + wind
print(total_renewable_energy)

Cybersecurity in Energy Software Development

As the energy sector becomes increasingly reliant on digital technologies, cybersecurity is becoming a major concern. Energy software development companies must prioritize security to protect against potential threats and ensure the integrity of the energy infrastructure. This includes implementing robust security protocols, conducting regular security audits, and investing in employee training and awareness programs.

# Example of cybersecurity measures using Python
import hashlib

# Define password hashing function
def hash_password(password):
    return hashlib.sha256(password.encode()).hexdigest()

# Hash password
password = "energy123"
hashed_password = hash_password(password)
print(hashed_password)

The Role of AI in Energy Software Development

Artificial Intelligence (AI) is revolutionizing the energy sector, from predictive maintenance to energy trading. AI-powered algorithms can analyze vast amounts of data, identify patterns, and make predictions, enabling energy companies to optimize their operations and reduce costs. In 2026, we can expect to see even more innovative applications of AI in energy software development, such as AI-powered energy storage systems and AI-driven demand response programs.

# Example of AI-powered energy trading using Python
import pandas as pd
from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import train_test_split

# Load data
data = pd.read_csv('energy_trading_data.csv')

# Split data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(data.drop('target', axis=1), data['target'], test_size=0.2, random_state=42)

# Train random forest regressor
rf = RandomForestRegressor(n_estimators=100, random_state=42)
rf.fit(X_train, y_train)

# Make predictions
predictions = rf.predict(X_test)

Conclusion

The energy software development landscape is evolving rapidly, driven by technological advancements, growing concerns about sustainability, and the need for increased efficiency. As we move forward in 2026, it's essential to stay ahead of the curve and leverage the latest trends and technologies to shape the future of energy production, distribution, and consumption. By embracing innovation, prioritizing security, and investing in AI-powered solutions, energy companies can unlock new opportunities, reduce costs, and contribute to a more sustainable world.

Call to Action

Join the conversation and share your thoughts on the top energy software development trends to watch in 2026. What are your predictions for the future of energy software development? How can we work together to create a more sustainable and efficient energy sector? Comment below, share this article with your network, and follow us for more insights and updates on the latest energy software development trends.

AI-Powered Web Development: The Future of Building Websites

Afzal Imdad — Tue, 20 Oct 2026 03:51:09 +0000

AI-Powered Web Development: The Future of Building Websites

Published: Friday, June 5, 2026

As we navigate the ever-evolving landscape of web development in 2026, it's becoming increasingly clear that Artificial Intelligence (AI) is poised to revolutionize the way we build websites. With the rise of AI-powered coding tools, developers can now focus on high-level creative decisions, while automated systems handle the tedious and time-consuming tasks. In this article, we'll explore the current state of AI-powered web development, its benefits, and how you can get started with this exciting technology.

Introduction to AI-Powered Web Development

AI-powered web development involves using machine learning algorithms and natural language processing to automate various aspects of web development, such as coding, testing, and deployment. This technology has the potential to significantly improve the efficiency, accuracy, and speed of web development projects. By leveraging AI-powered tools, developers can focus on the creative and strategic aspects of web development, while leaving the mundane tasks to the machines.

Benefits of AI-Powered Web Development

The benefits of AI-powered web development are numerous. Some of the most significant advantages include:

Increased Efficiency: AI-powered tools can automate repetitive tasks, such as coding and testing, allowing developers to focus on higher-level tasks.
Improved Accuracy: AI-powered systems can detect and fix errors more accurately and quickly than human developers.
Faster Deployment: AI-powered tools can automate the deployment process, reducing the time it takes to get a website up and running.
Enhanced Creativity: By automating mundane tasks, developers can focus on the creative and strategic aspects of web development, leading to more innovative and effective solutions.

Getting Started with AI-Powered Web Development

To get started with AI-powered web development, you'll need to familiarize yourself with the various tools and technologies available. Some popular AI-powered web development tools include:

Codex: A cloud-based platform that uses AI to automate coding tasks.
GitHub Copilot: A tool that uses AI to suggest code and automate coding tasks.
Adobe XD: A user experience design platform that uses AI to automate design tasks.

Here's an example of how you can use GitHub Copilot to automate coding tasks:

// Example of using GitHub Copilot to automate coding tasks
function helloWorld() {
  // Use GitHub Copilot to suggest code
  const suggestedCode = /* GitHub Copilot suggestion */;
  console.log(suggestedCode);
}

Real-World Applications of AI-Powered Web Development

AI-powered web development has numerous real-world applications, including:

Website Building: AI-powered tools can be used to build entire websites, from design to deployment.
E-commerce Development: AI-powered tools can be used to automate tasks such as product catalog management and order processing.
Content Management: AI-powered tools can be used to automate content creation, editing, and publishing.

Challenges and Limitations of AI-Powered Web Development

While AI-powered web development has the potential to revolutionize the industry, there are also challenges and limitations to consider. Some of the most significant challenges include:

Job Displacement: The automation of web development tasks could lead to job displacement for some developers.
Dependence on Technology: The reliance on AI-powered tools could lead to a lack of understanding of underlying technologies.
Security Risks: The use of AI-powered tools could introduce new security risks, such as vulnerabilities in automated code.

Conclusion

AI-powered web development is a rapidly evolving field that has the potential to revolutionize the way we build websites. By leveraging AI-powered tools, developers can focus on high-level creative decisions, while automated systems handle the tedious and time-consuming tasks. While there are challenges and limitations to consider, the benefits of AI-powered web development make it an exciting and worthwhile technology to explore. As we move forward in 2026, it's clear that AI-powered web development will play a significant role in shaping the future of the web.

Call to Action

If you're interested in learning more about AI-powered web development, we encourage you to explore the various tools and technologies available. Share your thoughts and experiences with AI-powered web development in the comments below. Follow us for more articles on web development and AI-powered technologies. Let's work together to shape the future of the web!

Embracing the Future of UI Frameworks: Trends and Best Practices for 2026

Afzal Imdad — Tue, 20 Oct 2026 03:50:29 +0000

Embracing the Future of UI Frameworks: Trends and Best Practices for 2026

Published: Thursday, June 4, 2026

As we navigate the ever-evolving landscape of software development in 2026, it's essential to stay ahead of the curve when it comes to UI frameworks. With the increasing demand for seamless user experiences, AI integration, and accessibility, developers must be equipped with the latest trends and best practices to create cutting-edge applications. In this article, we'll delve into the current state of UI frameworks, exploring the most significant trends and providing practical advice on how to leverage them for success.

The Rise of AI-Integrated UI Frameworks

Artificial intelligence (AI) is revolutionizing the way we approach UI design and development. By incorporating AI-powered tools and libraries, developers can create more intuitive and personalized user experiences. For instance, AI-driven UI components can adapt to user behavior, providing real-time feedback and suggestions. To get started with AI-integrated UI frameworks, consider exploring popular libraries like TensorFlow.js or Brain.js, which offer a range of pre-built components and tools for AI-powered UI development.

// Example of using TensorFlow.js for AI-powered UI development
import * as tf from '@tensorflow/tfjs';

// Load a pre-trained model for sentiment analysis
const model = await tf.loadLayersModel('https://example.com/model.json');

// Use the model to analyze user input and provide real-time feedback
const userInput = document.getElementById('user-input');
const feedback = document.getElementById('feedback');

userInput.addEventListener('input', async (event) => {
  const input = event.target.value;
  const prediction = await model.predict(input);
  feedback.textContent = `Sentiment: ${prediction}`;
});

Accessibility: A Critical Component of Modern UI Frameworks

Accessibility is no longer an afterthought in UI design; it's a fundamental aspect of creating inclusive and user-friendly applications. In 2026, developers must prioritize accessibility features like screen reader support, high contrast modes, and keyboard navigation. To ensure your UI framework is accessible, utilize tools like Lighthouse or WAVE to identify and address potential issues.

<!-- Example of using ARIA attributes for accessibility -->
<button aria-label="Submit form" aria-describedby="submit-description">
  Submit
</button>
<div id="submit-description" aria-hidden="true">
  This button submits the form and sends a confirmation email.
</div>

Enterprise Performance: Optimizing UI Frameworks for Large-Scale Applications

As applications grow in complexity and scale, UI frameworks must be optimized for enterprise performance. This involves leveraging techniques like code splitting, lazy loading, and caching to minimize latency and ensure seamless user experiences. To achieve enterprise-grade performance, consider using UI frameworks like React or Angular, which offer built-in optimization features and tools.

// Example of using code splitting with React
import React, { useState, useEffect } from 'react';

const Dashboard = () => {
  const [data, setData] = useState([]);

  useEffect(() => {
    import('./data.json').then((data) => {
      setData(data.default);
    });
  }, []);

  return (
    <div>
      {data.map((item) => (
        <div key={item.id}>{item.name}</div>
      ))}
    </div>
  );
};

Best Practices for Implementing UI Frameworks in 2026

To ensure success with UI frameworks in 2026, follow these best practices:

Stay up-to-date with the latest trends and technologies: Attend conferences, participate in online forums, and explore new libraries and tools to stay ahead of the curve.
Prioritize accessibility and inclusivity: Incorporate accessibility features and test your applications with assistive technologies to ensure usability for all users.
Optimize for enterprise performance: Leverage techniques like code splitting, lazy loading, and caching to minimize latency and ensure seamless user experiences.
Leverage AI-powered tools and libraries: Explore AI-driven UI components and libraries to create more intuitive and personalized user experiences.

Conclusion

In conclusion, the future of UI frameworks is exciting and rapidly evolving. By embracing trends like AI integration, accessibility, and enterprise performance, developers can create cutting-edge applications that provide seamless user experiences. Remember to stay up-to-date with the latest trends and technologies, prioritize accessibility and inclusivity, optimize for enterprise performance, and leverage AI-powered tools and libraries to succeed in the world of UI frameworks.

Call to Action

We'd love to hear from you! Share your thoughts on the future of UI frameworks in the comments below. What trends and technologies are you most excited about? How do you prioritize accessibility and inclusivity in your applications? Join the conversation and let's shape the future of UI frameworks together. Don't forget to follow us for more articles on software development, AI, and emerging technologies.

Revolutionizing Ecommerce: Top DevOps Automation Tools for High-Performance Engineering in 2026

Afzal Imdad — Sun, 31 May 2026 06:56:25 +0000

As we approach the midpoint of 2026, ecommerce platforms are under increasing pressure to deliver high-performance, scalable, and secure experiences. With the rise of machine learning, generative AI, and advanced reasoning models, the ecommerce landscape is evolving rapidly. On this Sunday, May 31, 2026, developers and technical teams are looking for ways to optimize their ecommerce platforms, making DevOps automation a critical topic of discussion. In this article, we will explore the importance of DevOps automation in ecommerce platform development, highlighting the top tools and strategies for achieving high-performance engineering.

Introduction to DevOps Automation

DevOps automation is the practice of automating the processes between software development and IT operations teams. By leveraging DevOps automation, ecommerce platforms can achieve sub-second load times, driving revenue and customer satisfaction. According to recent trends, high-performance engineering is a direct driver of revenue, and in 2026, sub-second load times are the baseline for enterprise competition.

Top DevOps Automation Tools for Ecommerce

There are several DevOps automation tools available for ecommerce platform development. Some of the top tools include:

Jenkins: An open-source automation server that enables teams to automate the build, test, and deployment process.
Docker: A containerization platform that allows teams to package, ship, and run applications in containers.
Kubernetes: An container orchestration system that automates the deployment, scaling, and management of containerized applications.
Ansible: An open-source automation tool that enables teams to automate the deployment, configuration, and management of infrastructure and applications.

Here is an example of how to use Ansible to automate the deployment of an ecommerce application:

- name: Deploy ecommerce application
  hosts: web
  become: yes

  tasks:
  - name: Install dependencies
    apt:
      name: "{{ item }}"
      state: present
    loop:
      - python3
      - pip3

  - name: Clone repository
    git:
      repo: https://github.com/username/ecommerce-app.git
      dest: /var/www/ecommerce-app

  - name: Install requirements
    pip:
      requirements: /var/www/ecommerce-app/requirements.txt

This example demonstrates how to use Ansible to automate the deployment of an ecommerce application, including installing dependencies, cloning the repository, and installing requirements.

Strategies for Implementing DevOps Automation

Implementing DevOps automation requires a strategic approach. Here are some strategies for implementing DevOps automation in ecommerce platform development:

Continuous Integration/Continuous Deployment (CI/CD): Automate the build, test, and deployment process to ensure that code changes are quickly and reliably delivered to production.
Infrastructure as Code (IaC): Manage infrastructure configuration through code, allowing teams to version control and automate infrastructure changes.
Monitoring and Logging: Implement monitoring and logging tools to provide visibility into application performance and errors.

Here is an example of how to use Terraform to implement IaC for an ecommerce platform:

provider "aws" {
  region = "us-west-2"
}

resource "aws_instance" "web" {
  ami           = "ami-abc123"
  instance_type = "t2.micro"
}

resource "aws_rds_instance" "db" {
  instance_class = "db.t2.micro"
  engine          = "postgres"
}

This example demonstrates how to use Terraform to manage infrastructure configuration for an ecommerce platform, including creating an EC2 instance and an RDS instance.

Best Practices for DevOps Automation

Here are some best practices for DevOps automation in ecommerce platform development:

Automate everything: Automate as many processes as possible to reduce manual errors and increase efficiency.
Use version control: Use version control systems to track changes to code and infrastructure configuration.
Monitor and log: Implement monitoring and logging tools to provide visibility into application performance and errors.

Conclusion

In conclusion, DevOps automation is a critical component of ecommerce platform development in 2026. By leveraging top DevOps automation tools and strategies, ecommerce platforms can achieve sub-second load times, driving revenue and customer satisfaction. Remember to automate everything, use version control, and monitor and log to ensure high-performance engineering. As we move forward in 2026, it's essential to stay up-to-date with the latest trends and technologies in DevOps automation to remain competitive in the ecommerce landscape.

Call to Action

If you're interested in learning more about DevOps automation in ecommerce platform development, we encourage you to share your experiences and ask questions in the comments below. Additionally, follow us for more articles and tutorials on DevOps automation, machine learning, and ecommerce development. Let's work together to revolutionize the ecommerce landscape with high-performance engineering!

Unlocking the Power of AI: Mastering the Skills Behind AI Tools in Software Development 2026

Afzal Imdad — Sat, 30 May 2026 11:25:56 +0000

Unlocking the Power of AI: Mastering the Skills Behind AI Tools in Software Development 2026

Published: Saturday, May 30, 2026

As we approach the end of May 2026, it's essential for software developers to focus on mastering the skills behind AI tools to stay competitive in the market. With the rapid advancements in AI technology, developers need to be equipped with the right skills to leverage AI for software development. In this article, we'll explore the importance of mastering AI skills, the current state of AI in software development, and provide practical tips and strategies for developers to improve their skills.

Introduction to AI in Software Development

AI has revolutionized the software development industry, enabling developers to build more efficient, scalable, and intelligent applications. However, as AI tools become more prevalent, it's crucial for developers to understand the skills behind these tools. Simply using AI tools without mastering the underlying skills can lead to limitations and constraints in software development. By mastering AI skills, developers can unlock the full potential of AI and create innovative applications that transform industries.

The Current State of AI in Software Development

The current state of AI in software development is characterized by the increasing use of autonomous AI agents that build entire features with minimal human intervention. This "Vibe Coding" era has transformed the way developers work, enabling them to focus on higher-level tasks and leaving the mundane tasks to AI. However, this shift also requires developers to acquire new skills, such as understanding AI algorithms, data structures, and software engineering principles.

Example: Using AI for Code Review

For instance, AI-powered code review tools can help developers identify bugs and improve code quality. However, to effectively use these tools, developers need to understand the underlying algorithms and data structures used by the AI. Here's an example of how to use AI for code review using Python:

import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split

# Load the code review dataset
df = pd.read_csv("code_review_data.csv")

# Split the data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(df.drop("label", axis=1), df["label"], test_size=0.2, random_state=42)

# Train a random forest classifier to predict code quality
rf = RandomForestClassifier(n_estimators=100, random_state=42)
rf.fit(X_train, y_train)

# Use the trained model to predict code quality
y_pred = rf.predict(X_test)

This example illustrates how AI can be used for code review, but it also requires developers to understand the underlying algorithms and data structures used by the AI.

Mastering AI Skills for Software Development

Mastering AI skills requires a combination of technical knowledge, practical experience, and soft skills. Here are some tips and strategies for developers to improve their AI skills:

Learn the fundamentals of AI: Start by learning the basics of AI, including machine learning, deep learning, and natural language processing.
Practice with real-world projects: Apply AI concepts to real-world projects to gain practical experience and build a portfolio of work.
Stay up-to-date with industry trends: Follow industry leaders, attend conferences, and participate in online forums to stay current with the latest AI trends and technologies.
Develop soft skills: Develop essential soft skills, such as communication, teamwork, and problem-solving, to effectively work with AI tools and collaborate with other developers.

Example: Building a Chatbot using Python and NLTK

For instance, building a chatbot using Python and NLTK requires developers to understand the fundamentals of natural language processing and machine learning. Here's an example of how to build a simple chatbot:

import nltk
from nltk.stem import WordNetLemmatizer
from nltk.tokenize import word_tokenize

# Initialize the NLTK library
nltk.download("wordnet")
nltk.download("punkt")

# Define a function to preprocess user input
def preprocess_input(input_text):
    tokens = word_tokenize(input_text)
    lemmatizer = WordNetLemmatizer()
    tokens = [lemmatizer.lemmatize(token) for token in tokens]
    return tokens

# Define a function to respond to user input
def respond_to_input(input_text):
    tokens = preprocess_input(input_text)
    # Use a machine learning model to generate a response
    response = "Hello, how can I assist you?"
    return response

# Test the chatbot
input_text = "Hello, what's your name?"
response = respond_to_input(input_text)
print(response)

This example illustrates how to build a simple chatbot using Python and NLTK, but it also requires developers to understand the underlying concepts of natural language processing and machine learning.

The Future of AI in Software Development

The future of AI in software development is exciting and rapidly evolving. As AI tools become more prevalent, developers will need to acquire new skills to stay competitive. Some of the key trends to watch in 2026 include:

Autonomous AI agents: AI agents that can build entire features with minimal human intervention.
Explainable AI: AI models that can provide transparent and interpretable results.
Human-AI collaboration: The ability of humans and AI to collaborate effectively to build complex applications.

Conclusion

Mastering AI skills is essential for software developers to stay competitive in the market. By understanding the skills behind AI tools, developers can unlock the full potential of AI and create innovative applications that transform industries. As we approach the end of May 2026, it's crucial for developers to focus on mastering AI skills to stay ahead in the industry. We hope this article has provided valuable insights and practical tips for developers to improve their AI skills.

Call to Action

We encourage you to share your thoughts and experiences with AI in software development. What are some of the challenges you've faced when working with AI tools? How have you mastered AI skills to improve your software development workflow? Share your comments below, and let's start a conversation about the future of AI in software development. Follow us for more articles on AI, software development, and technology trends.

Why I chose Zed over Visual Studio Code

Afzal Imdad — Fri, 26 Dec 2025 18:14:34 +0000

I often see mixed reviews about using Zed instead of Visual Studio Code . Some people are extremely enthusiastic about Zed’s speed, while others are dissatisfied because they don’t have the vast plugin ecosystem of VS Code.

In all of this, I would like to share my experience.

In the development world, choosing a code editor is an almost sacred decision, one of those personal preferences that can ignite endless arguments.

For years, Visual Studio Code has been my trusted companion, an undisputed behemoth offering almost unlimited flexibility and power. Yet, recently, I made a choice that might seem like a step backwards to some: I switched to Zed.

And I’ll explain why this decision, for me, was the most logical and productive.

When less is really more

In the past, my work focused primarily on web development with PHP, HTML, CSS, and MySQL, along with teaching. For this reason, I was always looking for tools that could be used on Mac, Windows, and Linux.

Today, more out of passion or the needs of some old clients, I occasionally update existing projects. I no longer need an arsenal of complex tools or features that extend to machine learning or desktop application development.

My primary need is just one: an agile, fast development environment that doesn’t get between me and the code.

Visual Studio Code, with its vast ecosystem of extensions, can do practically anything. But this incredible versatility is also its greatest burden.

Over time, I felt it becoming increasingly “large,” a transatlantic liner where all I needed was a fast motorboat to navigate my projects. Startup was no longer instantaneous, and resource consumption, though optimized, was taking its toll.

This is where Zed came into play.

The difference in performance was obvious from the first moment. Zed is incredibly lightweight and responsive. Opening files, global searches, and the overall fluidity of the interface gave me a sense of immediacy I’d forgotten.

A focused focus on my workflow

Zed’s philosophy seems almost tailored to my needs. Being a relatively new editor, it doesn’t claim to be a “jack of all trades.” Its feature set is essential, clean, and focused on what you really need to write code.

For my tech stack, this simplicity is a strength, not a weakness.

Of course, Zed’s maturity is still a work in progress. The plugin ecosystem, for example, isn’t even close to that of VS Code. I’d like the plugins for PHP, HTML, and CSS to be more complete and refined, perhaps with the same level of development found on Microsoft’s platform.

Become a member
But honestly, this isn’t a problem that’s holding me back. Zed is growing rapidly, and its community is active and promising. I’m confident that, with time, these shortcomings will be overcome.

Zed vs. VS Code: The Differences That Matter

Ignoring for a moment the features we now take for granted (such as debugging, Git integration, or AI assistance), I find these aspects particularly interesting:

Zed:

Speed

, Extremely fast and lightweight, thanks to the use of Rust and GPU rendering.
Minimalism: Clean, distraction-free interface designed for maximum focus on your code.
Collaboration: Natively integrated code sharing and collaborative editing capabi lities.

VS Code:

Flexibility: Highly customizable, although this can lead to a more chaotic environment.
Extensibility: Large and mature ecosystem, with thousands of extensions for almost every need imaginable.
Comprehensiveness: It is a tool that adapts to any language, framework or platform.

The choice of the editor is not a competition, but a question of context

We often fall into the trap of looking for the “best” editor. The truth is, none exists.

The choice should not be dictated only by speed, the beauty of the interface or the number of features, but by the specific use we make of it every day.

VS Code remains an extraordinary tool, and for many developers with different needs than mine, it’s undoubtedly the best choice. But for me, with my focus on web development with PHP, HTML, and CSS, Zed fits the bill perfectly.

It gives me exactly what I need, without frills and with a performance that allows me to focus only on what really matters: my idea and the code.

Conclusion

My switch to Zed is not a rejection of Visual Studio Code, but a conscious choice based on my work context.

Because the perfect editor doesn’t exist. However, there is the perfect editor for the job at hand. And for me, today, that editor is Zed.

Have you also made the switch to Zed or are you considering it? Share your experience in the comments, and if this article was helpful, please give it a thumbs up!

New JavaScript pipeline operator: Transform anything into a one-liner 😲

Afzal Imdad — Fri, 10 Jan 2025 23:51:39 +0000

With the pipeline operator you'll stop writing code like this:

And start writing code like this:

So refreshingly clean — and elegant! All those temporary variables are gone — not to mention the time it took to come up with those names and type them (not everyone types like The Flash, unfortunately).

You may have heard this partially true joke attributed to Phil Karlton: "There are only two hard things in computer science: cache invalidation and naming things".

Using the JavaScript pipeline operator clears out the clutter to boost readability and write data-transforming code (basically all code) in a more intuitive manner.

Verbosity should be avoided as much as possible, and this works so much better to compact code than reusing short-named variables:

Hopefully, almost no one codes like this on a regular basis. It's a pretty horrible technique when done in a large scale; a perfect example showing why we embrace immutability and type systems.

Unlike the pipeline operator, there's no certainty that the variable always contains the value you set at any given point; you'll need to climb up the scope to look for re-assignments. We could have used the _ at an earlier point in the code; the value it has at various points in the code is simply not guaranteed.

Now we're just using an underscore, so without checking out the right-hand side of those re-assignments you can't quickly know what the type of the variable is, unless you have a smart editor like VS Code (although I guess you could say that doesn't matter since they're supposed to be "temporary" — at least until they're not!).

All in all, poor readability. Fragile and Unstable. 5 times harder for someone new to understand. Also, some would say underscores are "ugly", especially in languages like JavaScript where they hardly show up.

Okay, so why don't we just avoid this infestation of temporary underscores, and nest them into one gigantic one-liner?

It's a mess. The underscore is gone, but who in the world can understand this at a glance? How easy is it to tell how the data flows throughout this code and make any necessary adjustments?

Understanding, at a glance — this is what we should strive for with every line of code we write.

The pipeline operator greatly outshines every other method, giving us both freedom from temporary variables and readability. It was designed for this.

Here the % only exists within this particular pipeline.

Method chaining?

Who hasn't used and combined heavily popular array methods like map, filter, and sort? Very hard to avoid in applications involving any form of list manipulation.

This is actually great. There aren't any temporary variables or unreadable nesting here either and we can easily follow the chain from start to finish.

The formatting lets us easily add more methods at any point in the chain; feature-packed editor like VS Code can easily swap the processing order of two methods, with the Ctrl + Up and Ctrl + Down shortcuts.

There's a reason why libraries like core http and jQuery are designed like this:

The problem with method chaining is that, we simply can't use it everywhere. If the class wasn't designed like that we're stuck and out in the cold.

It doesn't work very well with generator methods, async/await and function/method calls outside the object, like we saw here:

But all this and more work with the pipeline operator; even object literals and the async import function.

Could have been F# pipes

We would have been using the pipeline operator very similarly to F# pipes, with the above turning out like this instead:

There was an alternative design. But you can already see how this makes for an inferior alternative: Only single-function arguments are allowed and the operation is more verbose. Unless the operation is already a single-argument function call.

Its weird handling of async/await was also a key reason why it got rejected -- along with memory usage concerns. So, forget about F# pipes in JS!

Use the pipeline operator right now

Yes you can — with Babel.

Babel has a nice habit of implementing features before they're officially integrated in the language; it did this for top-level await, optional chaining, and many others. The pipeline operator couldn't be an exception.

Just use the @babel/plugin-proposal-pipeline-operator plugin and you're good to.

It's optional of course — but not for long.

Prettier the code formatter is already prepared.

Even though we can't say the same about VS Code or Node.js:

Right now there's even speculation that % won't be the final symbol passed around in the pipeline; let's watch and see how it all plays out.

Final thoughts

It's always great to see new and exciting features come to the language. With the JavaScript pipeline operator, you'll cleanse your code of temporary variables and cryptic nesting, greatly boosting code readability, efficiency, and quality.

Every Crazy Thing JavaScript Does

Just when you thought you knew all the quirks. Avoid painful bugs and save valuable time with Every Crazy Thing JavaScript Does, a captivating guide to the subtle caveats and lesser-known parts of JavaScript.

Get a free copy here today.

React 19 is here! Let's learn it!

Afzal Imdad — Thu, 24 Oct 2024 07:42:11 +0000

In February this year, React announced the release of version 19, finally updating a version number that had been static for two years (React 19 is Coming, What's New?). Andrew Clark, a member of the React team, confirmed that the new version would be released in March or April.

As they say, "deadlines are the first productivity driver." Here we are at the end of April, and the new version, 19.0.0-Beta, has just been released right on schedule.

Although it's only a Beta version, it has already generated considerable excitement within the community:

Dan commented: "they did what."
Andrew Clark commented: "React 19: Never forwardRef again."
Josh W. Comeau commented: "Lots of nice quality-of-life improvements here!"

The only disappointment is, as confirmed by React member Lauren, that the React Compiler has been delayed again. It was originally named "React Forget," a fitting title given its delays.

The features of the 19.0.0-Beta release include:

An Actions feature
Three new hooks
A new API
Simplified usage of ref and context
Various supportive updates and enhanced server-side capabilities

Let's delve into each of these.

Follow me:

Github: https://github.com/afzalimdad9
Medium: https://medium.com/@afzalimdad9

Actions

Actions are not a specific API but a general term for methods that simplify data handling in requests. A valid Actions setup should simplify asynchronous operations, allowing developers to focus more on business logic rather than state management.

Here's an example to illustrate the role of Actions. Suppose we have a form where users can update their name. Previously, we might use useState to manually manage form state, error state, and submission status. The code might look something like this:

function UpdateName() {
  const [name, setName] = useState("");
  const [error, setError] = useState(null);
  const [isPending, setIsPending] = useState(false);
  const handleSubmit = async () => {
    setIsPending(true);
    const error = await updateName(name);
    setIsPending(false);
    if (error) {
      setError(error);
      return;
    }
    redirect("/path");
  };
  return (
    <div>
      <input value={name} onChange={(event) => setName(event.target.value)} />
      <button onClick={handleSubmit} disabled={isPending}>
        Update
      </button>
      {error && <p>{error}</p>}
    </div>
  );
}

With React 19's Actions, this situation is optimized. We can now use the useTransition hook to handle form submissions, which automatically manages the pending state, making our code much cleaner:

function UpdateName() {
  const [name, setName] = useState("");
  const [error, setError] = useState(null);
  const [isPending, startTransition] = useTransition();
  const handleSubmit = async () => {
    startTransition(async () => {
      const error = await updateName(name);
      if (error) {
        setError(error);
        return;
      }
      redirect("/path");
    });
  };
  return (
    <div>
      <input value={name} onChange={(event) => setName(event.target.value)} />
      <button onClick={handleSubmit} disabled={isPending}>
        Update
      </button>
      {error && <p>{error}</p>}
    </div>
  );
}

In the handleSubmit function, the logic for the asynchronous request is encapsulated within the callback passed to startTransition. When startTransition is invoked, React immediately sets isPending to true, indicating that the transition (request) is underway. React then performs the startTransition callback asynchronously in the background. Once the request is complete, React automatically switches isPending back to false.

This functionality binds isPending to the disabled attribute of the submit button, so the button automatically becomes disabled during the request, preventing double submissions.

Summarizing React's conventions for Actions:

Naming Convention: Functions using asynchronous transitions can be referred to as "Actions."
Pending State: Actions automatically manage the pending state of data submissions. When a request is initiated, the pending state is automatically activated, and it resets once the final state updates. This ensures users receive feedback while data is submitted and the pending state is cleared after the request completes.
Optimistic Updates: Actions support optimistic updates, displaying the correct submission result to users while the request is pending. If the request ultimately fails, the optimistic update automatically reverts to its original state.
Error Handling: Actions include built-in error handling. When a request fails, you can use error boundaries to display error messages.
Form Support: elements now support passing functions to action and formAction attributes. By passing a function to the action attribute, you can handle form submissions with Actions, automatically resetting the form after submission. This simplifies the process of handling forms, making it more intuitive and efficient.

Three New Hooks

Why discuss Actions first? Because based on Actions, React 19 introduces three new hooks, each designed to simplify the complex handling of state by developers.

useOptimistic

The main purpose of useOptimistic is to allow us to assume success in asynchronous operations and update the state accordingly while waiting for the actual results.

Here's a basic usage example:

import { useOptimistic } from 'react';
function AppContainer() {
 const [optimisticState, addOptimistic] = useOptimistic(
 state,
 // updateFn
 (currentState, optimisticValue) => {
 // merge and return new state
 // with optimistic value
 }
 );
}

In this setup:

state: Initial state and the state returned when no operations are in progress.
updateFn(currentState, optimisticValue): A pure function that takes the current state and the optimistic value passed by addOptimistic, returning the merged optimistic state.
optimisticState: The optimistic state. If no operations are in progress, it equals state; otherwise, it equals the result of updateFn.
addOptimistic: A function for triggering optimistic updates, accepting an optimisticValue of any type and passing it to updateFn.

useOptimistic has a wide range of applications, such as form submissions, liking, bookmarking, deleting, and other scenarios that require immediate feedback.

Here's an example of optimistic updating for data deletion:

import React, { useState } from 'react';
import { useOptimistic } from 'react';
function AppContainer() {
    // Default data
  const [state, setState] = useState([
    { id: 1, name: 'Item 1' },
    { id: 2, name: 'Item 2' },
    { id: 3, name: 'Item 3' },
  ]);
    // Define the update function, which updates the state based on the current state and the optimistic value (the ID of the item to be deleted)
  const updateFn = (currentState, optimisticId) => {
    return currentState.filter(item => item.id !== optimisticId);
  };
  const [optimisticState, addOptimistic] = useOptimistic(state, updateFn);
    // Delete item
  const deleteItem = async (itemId) => {
    // Optimistically update the UI first
    addOptimistic(itemId);
    // Simulate API request delay
    setTimeout(() => {
      // Assume this is the API delete call, update the actual state after completion
      setItems(currentItems => currentItems.filter(item => item.id !== itemId));
    }, 2000);
  };
  return (
    <div>
      <h1>Optimistically Deleting Items</h1>
      <ul>
        {optimisticState.map(item => (
          <li key={item.id}>
            {item.name} <button onClick={() => deleteItem(item.id)}>Delete</button>
          </li>
        ))}
      </ul>
    </div>
  );
}
export default AppContainer;

useActionState

useActionState, formerly known as useFormState, has a new name in version 19, and its return parameters have changed (oddly, React has not yet updated the useActionState documentation, do they think developers don't read documentation? 🐶).

Here is the latest basic usage of useActionState:

const [state, action, pending] = useActionState(fn, initialState, permalink?);

The return parameters include:

state: Represents the current state. At the first render, it equals the initial state initialState. After an operation, it will be the most recent result.
action: This is a function used to perform operations. When this function is called, it will trigger the execution of fn and update the state.
pending: This is a new parameter, a boolean value indicating whether an operation is currently being performed. If an operation is in progress, it is true; otherwise, it is false.

The parameters are:

fn: This is a function that is triggered when the action is called, subsequently returning a new value.
initialState: This is the initial value, set to null if there is no initial value.
permalink: This is an optional string parameter, typically used in conjunction with server actions.

Here's an example of using useActionState with form action to implement name update functionality. If the update fails, an error
is displayed on the page; if successful, the page redirects to the updated page:

import { useActionState } from 'react';
function ChangeName({ name, setName }) {
  // Using useActionState to create a state associated with form operations
  const [error, submitAction, isPending] = useActionState(
    // First parameter: Form operation function
    async (previousState, formData) => {
      // Define the logic for form operations here
      // This function will be called upon form submission
      // It receives two parameters:
      // - previousState: The previous state, initially null, then the return value of the last operation
      // - formData: A form data object, can retrieve form fields using formData.get("name")
      const error = await updateName(formData.get("name"));
      // If there is an error during the operation, return the error message
      if (error) {
        return error;
      }
      // If the operation is successful, perform a redirection
      redirect("/path");
    }, 
    // Second parameter: Initial state, set here as null since the initial state is not crucial
    null
  }
  // Return the form along with related state and actions
  return (
    <form action={submitAction}>
      <input type="text" name="name" defaultValue={name} />
      <button type="submit" disabled={isPending}>
        Submit
      </button>
      {/* Display error messages if any */}
      {error && <p>{error}</p>}
    </form>
  );
}

useFormStatus

useFormStatus is used to retrieve status information about form submissions. Its basic usage is as follows:

const { pending, data, method, action } = useFormStatus();

Where:

pending: A boolean value indicating whether the parent <form> is currently submitting. If true, the form is in the process of being submitted; otherwise, it is false.
data: An object implementing the FormData interface, containing data from the parent <form> that is currently being submitted. If there is no ongoing submission or no parent <form>, it is null.
method: A string value indicating the HTTP method used by the parent <form>, which can be either get or post.
action: A reference to the function passed to the parent <form>'s action attribute. If there is no parent <form>, this property is null.

For example, developers can retrieve form status using useFormStatus in a form action:

import { useFormStatus } from "react-dom";
import action from './actions';
function Submit() {
  const status = useFormStatus();
  return <button disabled={status.pending}>Submit</button>
}
export default function App() {
  return (
    <form action={action}>
      <Submit />
    </form>
  );
}

This approach may feel both familiar and new. If it reminds you of context, you're on the right track. You can consider useFormStatus as a replacement for some of the capabilities of the context provider, but with a more streamlined syntax.

It's important to note two things about using useFormStatus:

The useFormStatus Hook must be called within components that are rendered inside a <form>.
useFormStatus only returns the status information of the parent <form>, not any other in the same component or its child components.

A New API - use

Previously categorized among hooks, the use has now been documented under APIs in React 19, thus becoming a new API.

use is used to read values from resources within a component, where the resource could be a Promise or a context.

Here's how it typically works:

import { use } from 'react';
function MessageComponent({ messagePromise }) {
  const message = use(messagePromise);
  const theme = use(ThemeContext);
  // …
}

use is mainly intended for higher-level frameworks like Next.js. For instance, it's recommended to use async…await instead of use if data fetching occurs in server components in Next.js. If fetching happens in client components, it's suggested to create a Promise in server components and pass it to client components as props.

use can also be used alongside Suspense boundaries. If a component calling use is wrapped in a Suspense boundary, the specified fallback will be displayed. Once the Promise resolves, the fallback is replaced by the returned data. If the Promise is rejected, the nearest error boundary's fallback will be displayed.

Simplified ref and context Usage

If you primarily utilize React's client-side capabilities, the changes discussed in this section will likely be of most interest to you.

Ref Discards forwardRef

Remember the dread of being dominated by forwardRef? With React 19, we can finally discard forwardRef. From now on, refs can be passed as props.

For example, suppose we have a functional component TextInput, a simple input box that accepts a placeholder attribute for placeholder text. Now, we want to obtain a reference to the input box in the parent component to focus on it when necessary. Here's how you could write it:

import React, { useRef } from 'react';
// Define a function component TextInput
function TextInput({ placeholder, ref }) {
  return <input placeholder={placeholder} ref={ref} />;
}
// Parent component
function ParentComponent() {
  // Create a ref to store the input box's reference
  const inputRef = useRef(null);
  // In some event handler, obtain the input box's reference and focus on it
  const focusInput = () => {
    inputRef.current.focus();
  };
  return (
    <div>
      {/* 
        Pass the inputRef to the TextInput component,
        allowing the ref to be used internally within the TextInput
      */}
      <TextInput placeholder="Enter your name" ref={inputRef} />
      <button onClick={focusInput}>Focus Input</button>
    </div>
  );
}
export default ParentComponent;

Isn't this mentally less burdensome than using forwardRef?

Context as Provider

Starting in React 19, developers can directly use <Context> as a provider, rather than using <Context.Provider>.

Suppose we have a ThemeContext used to manage theme information. In React 19, we can use <ThemeContext> as a provider like this:

import React, { createContext } from 'react';
// Create a theme context
const ThemeContext = createContext('');
// App component as the theme provider
function App({ children }) {
  return (
    <ThemeContext value="dark">
      {children}
    </ThemeContext>
  );
}

In the future, Context.Provider will be deprecated and removed.

Other Updates

This release also includes various supportive features and enhancements to server-side capabilities that are less commonly used in pure client-side React development, hence they are summarized briefly:

Server components and server actions are becoming stable features. These concepts are well-known to those familiar with Next.js/Remix but are not typically used by those who do not use these frameworks.
useDeferredValue has been updated to include a second parameter, optionally used to specify an initial value. The new usage of useDeferredValue is now: const value = useDeferredValue(deferredValue, initialValue?);
Support for writing document metadata directly in React code, i.e., writing <title>, <link>, and <meta> tags in page components will automatically add them to the application's <head>:

function BlogPost({post}) {
  return (
    <article>
      <h1>{post.title}</h1>
      <title>{post.title}</title>
      <meta name="author" content="Josh" />
      <link rel="author" href="<https://twitter.com/joshcstory/>" />
      <meta name="keywords" content={post.keywords} />
      <p>
        Eee equals em-see-squared...
      </p>
    </article>
  );
}

Support for writing stylesheets directly in React code, i.e., <link rel="stylesheet" href="…"> tags written in page components will automatically be added to the <head>.
Support for writing <script async="" src="…"> tags, which will also automatically be added to the <head>.
Support for preloading resources, which will also automatically be added to the <head>:

import { prefetchDNS, preconnect, preload, preinit } from 'react-dom'
function MyComponent() {
  preinit('https://.../path/to/some/script.js', {as: 'script' }) // loads and executes this script eagerly
  preload('https://.../path/to/font.woff', { as: 'font' }) // preloads this font
  preload('https://.../path/to/stylesheet.css', { as: 'style' }) // preloads this stylesheet
  prefetchDNS('https://...') // when you may not actually request anything from this host
  preconnect('https://...') // when you will request something but aren't sure what
}

Conclusion

To conclude, let me quote Huang Xuan: "Probably the single most critical principle I've learned from React is to be fearless in defining new conceptual abstractions and never compromise on the accuracy and composability of these definitions."

About Me

Full-stack engineer, Next.js open-source craftsman, AI advent proponent.

This year, I am committed to the development of open-source projects in the Next.js and Node.js domains and to sharing knowledge in these fields.

Follow me:

Github: https://github.com/afzalimdad9
Medium: https://medium.com/@afzalimdad9

Next-Auth in App Router of Next.js

Afzal Imdad — Tue, 20 Aug 2024 15:32:17 +0000

Next.js has recently released a stable version of App Router enriched with in-built support for layouts, templates, routing, loading, and error handling.

The current version of Next-Auth documentation is published with examples of the Page Router of Next.js. This document share approach to setting up Next.js with the Next-Auth App Router.

What is covered in this document?

Setup of Next.js app with app router.
Install Next-Auth.
Configuration of Github Provider.
Add Handler for Next-Auth
Sign in and Sign out using next-auth.
Use session in the Server Components
Use of session in the Client Components.

Set up the Next.js app with the App router.

Follow this document to create a basic next.js app with an app router.

Next.js app with App router.

Install Next-Auth

npm install next-auth

Configuration of Github Provider

Create a GitHub App first, providing you a client Id and Secret. Add a file auth.js in the lib folder.

Note: Generate a secret to add as NEXTAUTH_SECRET, it must be added in the auth options.

openssl rand -base64 32

// output
// mQ46qpFwfE1BHuqMC+qlm19qBAD9fVPgh28werwe3ASFlAfnKjM=

next. config.js

/** @type {import('next').NextConfig} */
const nextConfig = {
  images: {
    remotePatterns: [
      {
        protocol: 'https',
        hostname: 'i.imgur.com',
      },
    ],
  },
  env: {
    GITHUB_APP_CLIENT_ID: '919b87qa4sdfs1qdc44f53baf9',
    GITHUB_APP_CLIENT_SECRET: '2aeq98df3f8cwqerc2d03a8360e993c115ba8d5f71de9',
    NEXTAUTH_SECRET: 'mQ46qpFwfE1BHuqMC+qlm19qBAD9fVPgh28werwe3ASFlAfnKjM=',
  },
};

module.exports = nextConfig;

import { NextAuthOptions } from 'next-auth';
import GithubProvider from 'next-auth/providers/github';
export const authOptions: NextAuthOptions = {
  // Secret for Next-auth, without this JWT encryption/decryption won't work
  secret: process.env.NEXTAUTH_SECRET,

  // Configure one or more authentication providers
  providers: [
    GithubProvider({
      clientId: process.env.GITHUB_APP_CLIENT_ID as string,
      clientSecret: process.env.GITHUB_APP_CLIENT_SECRET as string,
    }),
  ],
};

Add Handler for Next-Auth

Create a file route.js in the folder /app/auth/[…nextauth]

Next-Auth Handler

import NextAuth from 'next-auth';
import { authOptions } from '@/app/lib/auth';

const handler = NextAuth(authOptions);
export { handler as GET, handler as POST };

Sign in and Sign out using next-auth

All requests to any of these paths /api/auth/* (signIn, callback, signOut, etc.) will be handled by NextAuth.js.

Once you click the button, log in, and authorize the app, it will get a cookie in the session.

Next-Auth default Sign in page
After successful sign-in.

Next-Auth token

Sign Out

use this link /api/auth/signout to sign out.

Session in API routes.

API route handlers are considered server components. It can be a static or dynamic handler but these are always on the server side.

import { authOptions } from '@/app/lib/auth';
import { getServerSession } from 'next-auth';
import { NextResponse } from 'next/server';

export async function GET(request: Request) {
  const session = await getServerSession(authOptions);
  console.log(session);
  return NextResponse.json({
    id: 1,
  });
}

Output

{
  user: {
    name: 'Rohit Kumar Khatri',
    email: 'er.rohitkumar@outlook.com',
    image: 'https://avatars.githubusercontent.com/u/34018015?v=4'
  }
}

Session in Server Components

It is also similar in all server components. Use the same function as mentioned above.

await getServerSession(authOptions);

Session in Client Components

First, add Session Provider in the Root Layout

'use client';

import { SessionProvider } from 'next-auth/react';
import { ReactNode } from 'react';

export default function NextAuthProvider({
  children,
}: {
  children: ReactNode;
}) {
  return <SessionProvider>{children}</SessionProvider>;
}

import { useSelectedLayoutSegments } from 'next/navigation';
import './globals.css';
import { Inter } from 'next/font/google';
import Footer from '@/app/components/Footer';
import Navbar from '@/app/components/Navbar';
import NextAuthProvider from '@/app/context/NextAuthProvider';
import { ReactNode } from 'react';
const inter = Inter({ subsets: ['latin'] });

export default function RootLayout({ children }: { children: ReactNode }) {
  return (
    <html lang="en">
      <body className={`inter.className`}>
        <NextAuthProvider>
          <div className="w-10/12 m-auto text-center bg-white flex flex-col min-h-screen">
            <div>
              <Navbar />
            </div>
            <div className="grow">{children}</div>
            <Footer />
          </div>
        </NextAuthProvider>
      </body>
    </html>
  );
}

Now use session in any client component.

'use client';

import { useSession } from 'next-auth/react';

export default function ClientComponent() {
  const { data: session, status } = useSession();
  return (
    <div>
      ClientComponent {status}{' '}
      {status === 'authenticated' && session.user?.name}
    </div>
  );
}

Why NextJS Sucks

Afzal Imdad — Tue, 20 Aug 2024 13:44:54 +0000

I’ve used NextJS for static websites because the experience with amplify hosting is so insanely easy. The fact that I go on the AWS console and connect a github repo and it just works, and runs with lambda, and is super cheap (unless I get DDOS’d)… that’s just too good to say no to in some cases.

Even though server side rendering hasn’t been required in years in order for google to index and find your content, the developer experience for toy websites is too good to pass up.

But for a complex SaaS project, I see very few benefits and some serious downsides of NextJS.

NodeJS sucks for SSR

𝐑𝐞𝐚𝐜𝐭 𝐫𝐞𝐧𝐝𝐞𝐫𝐢𝐧𝐠 𝐨𝐧 𝐭𝐡𝐞 𝐬𝐞𝐫𝐯𝐞𝐫 𝐚𝐝𝐝𝐬 𝐚 𝐝𝐢𝐦𝐞𝐧𝐬𝐢𝐨𝐧 𝐨𝐟 𝐜𝐨𝐦𝐩𝐥𝐞𝐱𝐢𝐭𝐲 𝐭𝐨 𝐭𝐡𝐞 𝐚𝐩𝐩𝐥𝐢𝐜𝐚𝐭𝐢𝐨𝐧 𝐛𝐞𝐜𝐚𝐮𝐬𝐞 𝐲𝐨𝐮’𝐫𝐞 𝐦𝐚𝐤𝐢𝐧𝐠 𝐍𝐨𝐝𝐞𝐉𝐒 𝐝𝐨 𝐬𝐨𝐦𝐞𝐭𝐡𝐢𝐧𝐠 𝐢𝐭’𝐬 𝐫𝐞𝐚𝐥𝐥𝐲 𝐛𝐚𝐝 𝐚𝐭 𝐝𝐨𝐢𝐧𝐠.

NodeJs is single threaded. In the ideal case that it’s designed for, requests should be I/O bound. A complex page requiring much SSR will hamstring the ability to serve concurrent requests. Here is a talk by a former coworker of mine on his experience optimizing server side rendering through large demand spikes.

Now, of course, most apps (including yours) are not going to have the same kind of spikes that Walmart has on black Friday. But you always gotta think about what you’re gaining in exchange of what you're giving up. From what I recall, my friend’s Walmart situation ended up boiling down to NodeJS getting hung up on page rendering for too long, then the operating system’s http request queue would expand too large, because they weren’t configured for load shedding, and the servers would become unresponsive as described in that load shedding article.

The autoscaling infrastructure would come to the rescue and constantly spin up new servers, but they spent millions of dollars on that, and still experienced availability loss (users getting a broken experience and having to reload). In order to fix it my friend ended up basically having to inject setTimeouts all over the place when rendering the app.

Now of course there’s ways to avoid all of this such as static site pregeneration, or hosting on serverless. This is part of the reason why serverless is a popular choice for NextJS. But my favorite way of avoiding this particular bit of complexity is just not server-rendering react in nodejs.

Security takes a back seat to coolness

Many nextJS features require allowing the browser to inject inline scripts. Nextjs’s implementation of suspense, and also usage of the appDir feature (which you basically always use), using next/font, and anything you put in your rootLayout all gets injected into the app as inline scripts.

Open up any nextJS website and you'll see a bunch of inline scripts like the screenshot below, from one of my NextJS pages:

Those are a bunch of inline scripts. Inline scripts are bad, because the only actually reliable way to prevent reflected XSS attacks is with content security policy headers that prevent the execution of inline scripts. A strong CSP policy is the golden standard for XSS prevention. And the main thing you need to do from a CSP standpoint is to avoid inline scripts.

If you just instruct the browser to not execute inline scripts, stored XSS is impossible. But if you use any of the NextJS features that require inline scripts, you cannot have a CSP policy to forbid inline scripts. Because of that, you have to settle for something worse, which is allowing only inline scripts that match a certain nonce (computed randomly at load time).

In order to do that with nextJS, you have to write a significant amount of code and jump through hoops (see docs on how to do it if you want your head to spin). Fun side effect of this is, even if you put a CDN in front of your NextJS cluster, there won't be any edge location caching because the nonce has to be different for every session (if it's not, it defeats the purpose of the nonce and you might as well just allow inline scripts).

NextJS doesn’t respect your time

Their API is incredibly unstable and they break it all the time. Basically every 6 months. The upgrade from 13 to 14 was hard.

The hosting infrastructure is much worse

If you host a SPA with a CDN, you can serve 30 million customers a month for a few bucks. If you use NextJS instead, you have a couple of choices:

Go serverless and be vulnerable to insanely massive bills from a simple naive DDOS
Use ECS/EC2 and then have the potential to lose availability because you scale up too slow during a demand spike (related to point 1 above)
Both choices suck. Both choices will cost you a lot more.

In addition, you give up the globally distributed nature of a CDN, which caches files near your users. It also handles caching (based on e-tags) between your user and the edge location. It’s a LOT to give up and I’m convinced that many people who think this is a good idea just don’t know wtf a CDN even is, or all it does for you. They’re like the developer in the hero picture of this article.

Why NextJS Sucks

Afzal Imdad — Tue, 20 Aug 2024 13:44:54 +0000

Even though server side rendering hasn’t been required in years in order for google to index and find your content, the developer experience for toy websites is too good to pass up.

But for a complex SaaS project, I see very few benefits and some serious downsides of NextJS.

NodeJS sucks for SSR

Security takes a back seat to coolness

Open up any nextJS website and you'll see a bunch of inline scripts like the screenshot below, from one of my NextJS pages:

NextJS doesn’t respect your time

Their API is incredibly unstable and they break it all the time. Basically every 6 months. The upgrade from 13 to 14 was hard.

The hosting infrastructure is much worse

If you host a SPA with a CDN, you can serve 30 million customers a month for a few bucks. If you use NextJS instead, you have a couple of choices: