DEV Community: Pasquale De Lucia

Save Money with GitHub's Package Manager

Pasquale De Lucia — Wed, 25 Feb 2026 20:44:52 +0000

Who wouldn't want to save some money? Today, I'll show you how to do just that, specifically when it comes to managing private npm packages.

Typically, npm's package manager charges a monthly fee for publishing private packages. While this might work for some companies, it can be a burden for smaller teams or personal projects. Thankfully, GitHub, the world's most popular Git platform, offers a solution that's both powerful and free.

Recently, I needed a way to publish a private npm package without incurring any costs. Using GitHub Actions and GitHub Package Manager, I successfully achieved this. Here's a step-by-step guide to help you do the same.

Prerequisites Before you begin, ensure you have:

A GitHub repository containing your NPM package.

A minimal configuration of the package.json file.

A GitHub account with permissions to create repositories and manage packages.

Node.js and npm installed locally for development.

Configure the package.json File Modify your package.json file to indicate that you'll be using GitHub Package Manager. Update the name field to include your GitHub username as the scope:

{
  "name": "@your-username/your-package",
  "version": "1.0.0",
  "description": "A private package published on GitHub Package Manager",
  "repository": {
    "type": "git",
    "url": "https://github.com/your-username/your-repo.git"
  },
  "publishConfig": {
    "registry": "https://npm.pkg.github.com/@your-username"
  }
}

Be sure to replace your-username and your-repo with your actual GitHub username and repository name.

Generate an Access Token on GitHub To publish your package, you'll need a personal access token with the appropriate permissions.

Go to GitHub Account Settings.

Create a Personal Access Token (classic) with the following permissions:

write:packages

read:packages

repo (if the repository is private).

Save the token in a secure location, such as a password manager.

Configure GitHub Actions Create a workflow to automate the process of building and publishing your package. Add the following YAML file to .github/workflows/publish.yml in your repository:

name: Build and Deploy

on:
  push:
    branches:
      - release

jobs:
  publish-gpr:
    runs-on: ubuntu-latest
    permissions:
      packages: write
      contents: read
    steps:
      - uses: actions/checkout@v2
      - uses: actions/setup-node@v1
        with:
          node-version: 20
          registry-url: https://npm.pkg.github.com/
          scope: '@your-username'
      - uses: pnpm/action-setup@v3
        with:
          version: 9.10.0
      - run: pnpm install
      - run: pnpm publish:build
      - run: npm publish
        env:
          NODE_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}

This workflow will trigger whenever you push changes to the release branch and will automatically publish your package to GitHub Package Manager.

Test the Workflow Commit and push the .github/workflows/publish.yml file to the release branch. If everything is set up correctly:

GitHub Actions will trigger the workflow.

The package will be published to GitHub Package Manager.

You'll find the package in the Packages tab of your repository.

Install the Published Package To use the package in another project, add an .npmrc file to the project with the following content:

@tuo_username:registry=https://npm.pkg.github.com/
//npm.pkg.github.com/:_authToken=YOUR_TOKEN
engine-strict=true

Run the npm command to install the package:

npm install @your-username/your-package
Don't forget to replace YOUR_TOKEN with the token created in Step 3.

Conclusion
Publishing private npm packages with GitHub Package Manager is a cost-effective and streamlined alternative to traditional npm services. By leveraging GitHub Actions, you can fully automate the process, saving both time and resources.

This approach not only eliminates the need for paid npm private packages but also integrates seamlessly into GitHub's ecosystem, where your code, versioning, and packages are all managed in one place.

If you encounter any issues or have questions, feel free to leave a comment. Happy coding! 🚀

Save Money with GitHub's Package Manager

Pasquale De Lucia — Mon, 18 Nov 2024 13:23:07 +0000

Who wouldn’t want to save some money? Today, I’ll show you how to do just that, specifically when it comes to managing private npm packages.

Typically, npm’s package manager charges a monthly fee for publishing private packages. While this might work for some companies, it can be a burden for smaller teams or personal projects. Thankfully, GitHub, the world’s most popular Git platform, offers a solution that’s both powerful and free.

Recently, I needed a way to publish a private npm package without incurring any costs. Using GitHub Actions and GitHub Package Manager, I successfully achieved this. Here’s a step-by-step guide to help you do the same.

1. Prerequisites

Before you begin, ensure you have:

A GitHub repository containing your NPM package.
A minimal configuration of the package.json file.
A GitHub account with permissions to create repositories and manage packages.
Node.js and npm installed locally for development.

2. Configure the package.json File

Modify your package.json file to indicate that you’ll be using GitHub Package Manager. Update the name field to include your GitHub username as the scope:

{
  "name": "@your-username/your-package",
  "version": "1.0.0",
  "description": "A private package published on GitHub Package Manager",
  "repository": {
    "type": "git",
    "url": "https://github.com/your-username/your-repo.git"
  },
  "publishConfig": {
    "registry": "https://npm.pkg.github.com/@your-username"
  }
}

Be sure to replace your-username and your-repo with your actual GitHub username and repository name.

3. Generate an Access Token on GitHub

To publish your package, you’ll need a personal access token with the appropriate permissions.

Go to GitHub Account Settings.
Create a Personal Access Token (classic) with the following permissions:
- write:packages
- read:packages
- repo (if the repository is private).
Save the token in a secure location, such as a password manager.

4. Configure GitHub Actions

Create a workflow to automate the process of building and publishing your package. Add the following YAML file to .github/workflows/publish.yml in your repository:

name: Build and Deploy

on:
  push:
    branches:
      - release

jobs:
  publish-gpr:
    runs-on: ubuntu-latest
    permissions:
      packages: write
      contents: read
    steps:
      - uses: actions/checkout@v2
      - uses: actions/setup-node@v1
        with:
          node-version: 20
          registry-url: https://npm.pkg.github.com/
          scope: '@your-username'
      - uses: pnpm/action-setup@v3
        with:
          version: 9.10.0
      - run: pnpm install
      - run: pnpm publish:build
      - run: npm publish
        env:
          NODE_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}

This workflow will trigger whenever you push changes to the release branch and will automatically publish your package to GitHub Package Manager.

5. Test the Workflow

Commit and push the .github/workflows/publish.yml file to the release branch. If everything is set up correctly:

GitHub Actions will trigger the workflow.
The package will be published to GitHub Package Manager.
You’ll find the package in the Packages tab of your repository.

6. Install the Published Package

To use the package in another project, add an .npmrc file to the project with the following content:

@tuo_username:registry=https://npm.pkg.github.com/
//npm.pkg.github.com/:_authToken=YOUR_TOKEN
engine-strict=true

Run the npm command to install the package:

npm install @your-username/your-package

Don’t forget to replace YOUR_TOKEN with the token created in Step 3.

Conclusion

Publishing private npm packages with GitHub Package Manager is a cost-effective and streamlined alternative to traditional npm services. By leveraging GitHub Actions, you can fully automate the process, saving both time and resources.

This approach not only eliminates the need for paid npm private packages but also integrates seamlessly into GitHub’s ecosystem, where your code, versioning, and packages are all managed in one place.

If you encounter any issues or have questions, feel free to leave a comment. Happy coding! 🚀

BRUNO the new http client

Pasquale De Lucia — Tue, 03 Sep 2024 15:23:48 +0000

Today I want to tell you about a new http client that I recently discovered, but that impressed me very much, to use as an alternative to the very popular Postman.

I report directly from their site some information

Bruno is a Fast and Git-Friendly Opensource API client, aimed at revolutionizing the status quo represented by Postman, Insomnia and similar tools out there.

Bruno stores your collections directly in a folder on your filesystem. They use a plain text markup language, Bru, to save information about API requests.

This allows you to be able to share bruno collections with the rest of the team very easily using any version control of your choice, such as git.

As we can see, it is open source software, and this allows us to have control over how our data is handled or otherwise know how the software works.

Speaking of data, since the software saves all data in a local folder on one's pc, one can well understand how the developers care about privacy. In this way we are masters of our data and not only that, it saves us money in subscriptions to work in teams.

To help us migrate from other similar services, it gives us the ability to import our collections from Postam, Insomnia and OpenAPI V3 Spec.

Of course a also a downside, but one that does not touch most of you readers, which is that it is not yet possible to make calls in GRPC, a protocol that I have recently started using within some microservices.

Honestly, I've now definitely switched to using Bruno to test my bees, and I'm not hanging on at all.

Web Components Debut: My First Dive In

Pasquale De Lucia — Thu, 07 Dec 2023 17:46:33 +0000

Recently, I had the opportunity to explore web components for the first time in my web development career. This adventure was inspired by @maxart2501's speech at Codemotion Milan 2023 and a new work challenge that required the implementation of a third-party payment method.

I fully understood their extraordinary potential, particularly the ability to create cross-framework components, eliminating the need to develop custom libraries for each framework.

You might think that the need for cross-framework components is rare, especially if you work in an environment where only one framework is used. However, many companies find themselves running multiple frameworks simultaneously, often with duplicate code to replicate the same widgets in different applications. Also, when considering open source libraries intended for use by third parties, the ability to support a wide range of frameworks becomes a significant advantage.

In my specific case, I am currently developing an open source library that I will soon share with the community (so stay tuned if you are interested). The decision to adopt web components was motivated by a desire to support as many frameworks as possible without having to know them all and without having to write specific code for each.

While this flexibility is certainly a strength, it is important to note that there is a disadvantage to using web components. Because everything is written in HTML, CSS, and vanilla JavaScript, it is not possible to take full advantage of the advanced features of some frameworks. However, this trade-off may be acceptable, especially when aiming to maximize compatibility and ease of use in a heterogeneous context.

I do not want to impose a specific perspective on the use of web components, but rather to offer a new perspective when approaching the development of something new. The ability to create cross-framework components can be a valuable ally in certain contexts, and my experience with web components has opened new perspectives in my approach to web development.

HELP

It should be acknowledged that if a large amount of data is to be transmitted to the web component, the approach is not particularly elegant, and the end result in the HTML looks as follows:

Currently, the only method I have identified for passing a complex object to my web component is to use JSON.stringify() to convert the object to a string and then parse the object within the web component using JSON.parse().

SMALL EXAMPLE

I prefer to avoid repeating common instructions on creating web components, since there are already numerous guides on the subject. Below, I present an example of an essential but working web component, designed as a starting point for anyone wishing to use it as a base:

class CustomComponent extends HTMLElement {
  static get observedAttributes() {
    return ['title']
  }

  attributeChangedCallback(name, oldValue, newValue) {
    switch (name) {
      case 'title':
     this.shadowRoot.querySelector('.component').innerHTML = newValue
        break
    }
  }

  constructor() {
    super()

    this.attachShadow({ mode: 'open' })

    this.shadowRoot.innerHTML = `
      <style>
      </style>  

      <div class="component">
      </div>
    `
  }

  get title() {
    return this.getAttribute('title')
  }

  set title(newValue) {
    this.setAttribute('title', newValue)
  }
}

customElements.define('custom-component', CustomComponent)

To integrate it, simply import the .js file into your web platform and use the new HTML tag <custom-component title="Section title"></custom-component>.

Verdaccio: to create npm packages locally

Pasquale De Lucia — Tue, 21 Nov 2023 13:35:56 +0000

Perhaps many of you have already heard of Verdaccio, but today I want to share my recent discovery of this tool that has greatly improved my workflow with npm libraries.

While working with npm libraries and looking for effective ways to test them, I realized that, apart from tools like Storybook, my only option was to publish the library and test it from the published package. However, this practice was not always the ideal solution.

Recently, while contributing to an open-source project called @QwikDev/RoadlPlan, I made the discovery of Verdaccio, an amazing tool that has transformed the way I manage npm libraries.

Verdaccio allows you to create a local private NPM registry without requiring any complicated configuration. It also comes with a small internal database and has the ability to act as a proxy for other registries, such as npmjs.org.

This feature allows you to publish your library on the local Verdaccio server. Once the testing process is complete, you can move directly to publishing the final version to npm, greatly simplifying your workflow.

The installation of Verdaccio is incredibly simple, and it personally took me only a few minutes to get up and running and start taking full advantage of its capabilities.

I would like to know your experience with Verdaccio. Are you already familiar with it? If yes, are you still using it or have you opted for alternatives? If you have not tried it yet, I encourage you to consider integrating Verdaccio into your workflow to optimize npm library management.

How to create a fade animation css with Qwik

Pasquale De Lucia — Wed, 15 Nov 2023 22:35:24 +0000

Fade animation adds a distinctive touch to the user experience on your site. By taking advantage of CSS transitions and IntersectionObserver in Qwik, you can achieve a smooth effect when elements enter the viewport.

On my personal site, I implemented a fade effect using CSS transitions and the IntersectionObserver in Qwik. You can take a look at the animation at this link.

First, we define within the component the signals that will be useful for us to monitor the HTML element and its CSS properties. Inside the useVisibleTask$ hook, we insert the Observer.

export default component$(() => {
  ...
  const sectionRef = useSignal<Element>();
  const sectionIsVisible = useSignal<boolean>(true);

  useVisibleTask$(() => {
    if (sectionRef.value) {
      const observer = new IntersectionObserver(([entry]) => {
        sectionIsVisible.value = entry.isIntersecting;
        if (sectionIsVisible.value) {
          observer.disconnect();
        }
      });

      observer.observe(sectionRef.value);
    }
  });
  ...
});

The code within the useVisibleTask$ hook is executed client-side only and creates an IntersectionObserver that updates the value of the sectionIsVisible signal. This signal will then be used to apply the animation.

In the HTML file, we reference the element we want to animate using the signal sectionRef. With sectionIsVisible, we update the CSS classes.

First, we define these two classes in the global.css file:

Without Tailwind:

animation {
  opacity: 0;
  transition-property: opacity;
  transition-delay: 150ms;
  transition-duration: 700ms;
  transition-timing-function: cubic-bezier(0.4, 0, 1, 1);
}

animation.isVisible {
  opacity: 1;
}

With Tailwind:

.animation {
  @apply opacity-0 transition-opacity ease-in duration-700 delay-150;
}

.animation.isVisible {
  @apply opacity-100;
}

Now we can edit the HTML element to which we want to apply the transition:

<section
  ref={sectionref}
  class={"animation " + sectionIsVisible.value && "isVisible"}
>
  <h2>FADE IN</h2>
</section>

This way, when the HTML element enters the viewport, it will do so through an animation.

Further explore the possibilities for advanced customization and create an engaging user experience.

The complete and slightly more complex code is available in this repository.

Diving into the Open Source Realm: My Qwik Journey Begins! 🚀🌐

Pasquale De Lucia — Sat, 11 Nov 2023 16:52:56 +0000

🚀 Excited to announce my open source debut with Qwik! My first pull request has been accepted and I couldn't be happier. 🎉

I have long pondered how I could contribute to open source projects, often putting it off because of fears regarding the approach and potential challenges. These weeks, I finally overcame those uncertainties by immersing myself in communities and opening issues on various open source projects. Today, I celebrate the creation and acceptance of my first pull request on Qwik, fixing a cache-related bug during development.

I would like to express my gratitude to @gioboa for his invaluable support during the pull request opening process. Your guidance was crucial.

This represents only the beginning of a broader journey in the open source universe. I am ready to face future challenges with determination and anticipation. 🌐💻

Empower Your Development Journey: A Guide to Essential Free Developer Tools

Pasquale De Lucia — Fri, 10 Nov 2023 16:02:17 +0000

Embarking on a new development project is an exciting endeavor, but it often comes with budget considerations. In this guide, we unveil a curated collection of essential free developer tools that serve as a robust foundation for launching projects without an initial financial commitment. From efficient code management to seamless hosting, data storage, and design, these tools empower you to kickstart your development journey with confidence and creativity,all without breaking the bank. Let's explore the world of cost-effective solutions that elevate your projects to new heights.

GitHub

GitHub is the ideal platform for code versioning, also offering the ability to manage private repositories. This tool is essential for tracking code changes and collaborating efficiently with other developers.

Vercel

Vercel is perfect for hosting both the front end and back end of your project. It supports a wide range of frameworks (you can find the complete list here), making it a versatile solution for comprehensive project deployment.

Supabase

Supabase provides an extraordinary space to store project data. With 500MB of database space and 1GB of file storage, it provides a solid foundation for managing project data. Its user-friendly interface makes it an excellent option for anyone in need of a reliable database without initial costs.

Trigger.dev

Trigger.dev is a tool that offers usable jobs for various projects. With 5000 monthly executions, support for 2 users, and 10 jobs, it provides a practical solution for process automation without significant financial burdens.

Miro

Miro is a magical environment dedicated to system design, offering tools such as diagrams and arrows for visualizing and planning projects. Its versatility makes it an essential ally for the creative and organizational process.

Unsplash

Unsplash is a valuable resource for finding usable images in projects, respecting copyright. Its extensive library of high-quality images makes it an ideal starting point for visually enriching any project.

VSCode

Visual Studio Code is an extremely flexible and feature-rich editor. Its wide range of extensions and ease of customization make it a popular choice among developers seeking a highly adaptable development environment.

Figma

Figma offers allows developers and designers to create, prototype, and collaborate on projects with ease. Its cloud-based platform enables real-time collaboration, making it an invaluable asset for teams working on the visual aspects of a project

Notion

Notion is a versatile tool for documentation and work organization. With advanced collaboration features and an intuitive structure, it offers a comprehensive digital environment for information management and project planning.

Discord

Discord, originally designed for gaming communities, has evolved into a versatile platform ideal for seamless collaboration with others. Offering a suite of powerful features such as chat, video calls, and screen sharing, provides a comprehensive and easy-to-use environment for effective communication and collaboration.

These tools provide a solid foundation for anyone looking to kickstart a project without the need for initial investment. By leveraging this combination of resources, you can address crucial aspects such as code management, hosting, data storage, and design, all without any initial costs.

The Essential Top 10 VSCode Extensions You Shouldn't Miss

Pasquale De Lucia — Thu, 09 Nov 2023 08:51:09 +0000

Visual Studio Code (VSCode) is a dynamic code editor with a plethora of extensions catering to various developer needs. While I personally use far more than just 10 extensions, in this article, I've chosen to focus on what I consider to be the essential ones. The selection reflects a curated list that spans intelligent code completion, formatting, collaborative tools, and more. As we dive into the top 10, keep in mind that this is just the tip of the iceberg, and the VSCode extension landscape is rich with possibilities. Feel free to explore beyond these recommendations and craft an environment that resonates with your unique coding style and preferences. Let's embark on a journey to enhance your coding experience with these indispensable extensions.

Tabnine

Turbocharge your coding with AI-driven precision. Enjoy accurate, context-aware code suggestions that adapt to your unique style, enhancing efficiency and productivity.

Prettier

Prettier is a code formatter extension that automates the process of code styling, ensuring a consistent and aesthetically pleasing look across your entire codebase.

GitLens

GitLens is a feature-rich extension that enhances your Git experience within Visual Studio Code, providing detailed insights into your code's history, authors, and changes, empowering you to navigate and understand your repository with ease.

Live Share

Live Share facilitates real-time collaboration among developers by enabling them to share their development environments, making pair programming and collaborative coding sessions seamless and productive.

ESLint

ESLint is a powerful static code analysis tool that helps identify and fix issues in your JavaScript code, promoting best practices and maintaining code quality.

Project Manager

Project Manager is a handy extension that simplifies project navigation by allowing you to organize and switch between different projects effortlessly, streamlining your workflow.

Code Runner

Code Runner enables you to run code snippets or entire files in various programming languages directly within Visual Studio Code, making it a versatile tool for quick testing and debugging.

Better comments

Better Comments enhances code readability by allowing you to categorize and visually distinguish different types of comments in your code, making it easier to understand and maintain.

Turbo console log

Turbo Console Log accelerates the debugging process by providing a quick and easy way to insert console log statements into your code, saving you time during development.

Indent rainbow

Indent Rainbow adds color to your code by highlighting different levels of indentation, making it visually intuitive to navigate and understand the structure of your files.

Strumenti Essenziali per Ogni Sviluppatore Web

Pasquale De Lucia — Wed, 08 Nov 2023 07:30:48 +0000

L’ecosistema degli strumenti per lo sviluppo web è in costante evoluzione, e ogni professionista dovrebbe essere attrezzato con le migliori risorse per massimizzare la produttività e la qualità del proprio lavoro. In questo articolo, elencheremo alcuni degli strumenti imprescindibili che ogni sviluppatore web dovrebbe avere a disposizione.

Visual Studio Code

Visual Studio Code è un IDE eccezionale che offre un’ampia gamma di estensioni. La sua flessibilità e personalizzazione lo rendono una scelta ideale per qualsiasi sviluppatore. È possibile adattarlo alle proprie esigenze, rendendolo un ambiente di sviluppo altamente personalizzato.

Prettier

Prettier è un’utile estensione di Visual Studio Code che semplifica la formattazione del codice. Puoi anche stabilire regole condivise con il tuo team utilizzando husky per mantenere una formattazione uniforme. Assicurati di attivare l’opzione “Format on save” nelle impostazioni di VS Code per massimizzare l’utilità di questa estensione.

GitKraken

GitKraken è un client Git che offre una chiara rappresentazione visuale delle tue repository. Questo strumento semplifica il controllo delle versioni e la collaborazione con il tuo team. La versione free non include le repository private, ma è facile trovare alternative.

Oh My Zsh

Se stai ancora utilizzando un terminale standard, Oh My Zsh potrebbe cambiarlo per sempre. Questo strumento per Zsh consente di personalizzare l’aspetto e le funzionalità del terminale in modo grafico. Aggiungi nuove funzionalità e migliora l’esperienza di sviluppo.

Insomnia

Insomnia è un eccellente client per testare le API, un’alternativa a Postman. La sua leggerezza, il carattere open-source e i prezzi competitivi lo rendono una scelta saggia per la gestione delle API e il debug.

Notion

Tool molto potente che semplifica la scrittura di documenti, l’organizzazione del lavoro, la gestione delle note e tanto altro. Esplora le sue molteplici funzionalità per migliorare la tua produttività.
Uno degli usi principale per cui la uso è scrivere la documentazione per i miei progetti.

Figma

Lo sviluppo web non riguarda solo il codice, ma anche il design. Figma è uno strumento di progettazione grafica ampiamente utilizzato. È gratuito, facile da imparare e offre molte funzionalità integrate per il design web.

Spotify

Anche se non è uno strumento direttamente legato allo sviluppo, la musica può migliorare notevolmente la tua concentrazione e la tua creatività durante le sessioni di codifica. Quindi, non esitare a mettere un po’ di musica in sottofondo per rendere il lavoro più piacevole.

Questi strumenti sono solo l’inizio per un sviluppatore web. Esplora ulteriori risorse e personalizza il tuo set di strumenti in base alle tue esigenze specifiche. La giusta combinazione di strumenti può fare la differenza nella tua produttività e nella qualità del tuo lavoro.

I started using Qwik...

Pasquale De Lucia — Sun, 05 Nov 2023 23:32:26 +0000

I embarked on my Qwik journey and wish to share my initial experiences in using it to build my personal website. In this article, I won't delve into the intricate technical details of the framework; instead, I'll focus solely on my first impressions.

Let's begin with a critical aspect – the learning curve. As Miško Hevery, the creator, emphasized during the Milan Codemotion 2023 conference, an event I had the privilege to attend

if you're familiar with React, you're already acquainted with Qwik

Indeed, the pages are written in JSX, or for those, like myself, who use TypeScript, in TSX. This makes Qwik feel like a well-established and easily learnable platform.

In just about eight hours, equivalent to a full workday, and with the assistance of Tailwind, I created a blank Qwik project, designed my first page, and constructed the initial components. It became quite addictive, driving me to create more pages. In a remarkably short span, with minimal reference to Qwik's documentation (although I recommend perusing it, as it contains some intriguing insights), I effortlessly fashioned a showcase website. I even found myself losing track of time while crafting playful kitten animations.

Another aspect that I found notably commendable, besides the initial humor during Qwik's setup, was the guidance provided by the terminal in its development mode, particularly in relation to SEO. Thanks to this guidance, my very first Google Lighthouse audit yielded a perfect 100/100 SEO score.

In the upcoming days, you will be able to access the site I've developed at this web address. Spotting a Qwik-powered site is easy - just look for the "Made with Qwik" label in the footer. Since my previous site is hosted on Firebase, I'll endeavor to continue using it for publishing, instead of Vercel (which I've been using recently). I found a helpful guide directly on the Qwik website.

Finally, but certainly not less important, are performance considerations. I can't offer a comprehensive evaluation until the site is published, as the documentation explains that development performance may differ from production. Nonetheless, the development stage is already promising, and I eagerly anticipate the opportunity to test it in a production environment.

One drawback, however, is the limited availability of packages for use with Qwik. Currently, if you require something that isn't included in the framework, you'll need to build it from the ground up. Is this limitation a result of Qwik being a brand new framework, or might it continue to be overlooked by the community in the future? Only time will reveal the answer. Personally, I'm optimistic that Qwik has a bright future, as it possesses significant potential, and with time, the community will begin to contribute more actively.

In summary, my initial encounter with this genuinely innovative framework left a positive impression. I'll certainly continue to use it for simple projects until it achieves greater stability and garners increased community support. The concept I admire most about Qwik is its resumability, which offers incredible loading times for users.

With that said, all that remains is to be patient, observe its growth, and, why not, continue to utilize it in the future!

UPDATE

I recently launched my website, and I'm genuinely excited about the results. Surprisingly, I achieved excellent scores on Google Lighthouse with virtually no effort. You can see the details in the screenshot below:

One aspect that I found particularly commendable is the npm run qwik add command, which makes adding various integrations and deployment options incredibly straightforward. So far, I've successfully tried both Firebase and Vercel deployments, and I must say that both work exceptionally well. I am extremely pleased with the work done by the entire Qwik team.

Creare un bot Telegram utilizzando NodeJs

Pasquale De Lucia — Fri, 03 Nov 2023 11:00:37 +0000

In questo articolo puoi scoprire come creare un bot per telegram. Divertiti e crea qualcosa di strabiliante!