DEV Community: Hazar nenni

An In-Depth Look at Hono.js for Cloud-Native Development

Hazar nenni — Sat, 08 Jun 2024 14:10:09 +0000

In the ever-evolving landscape of web development, frameworks and libraries come and go, each promising to make our lives easier and our applications more efficient. One such rising star in the realm of cloud-native development is Hono.js. Known for its minimalistic approach, Hono.js is gaining traction among developers who need a lightweight, yet powerful tool for building modern web applications.

What's Hono.js

Hono.js is a minimalist web framework designed to help developers create fast and efficient cloud-native applications. The framework's name, Hono, is derived from the Japanese word "炎" (pronounced as "hono"), meaning "flame", symbolizing the framework’s focus on speed and performance.

Key Features of Hono.js

Minimal FootPrint To demonstrate the minimal footprint, let's compare the size of Hono.js with another popular framework:

This illustrates how Hono.js is significantly smaller, which can lead to faster load times and reduced resource usage.

Performance-Oriented

A basic benchmark test comparing Hono.js and Express.js:

Running a performance test using a tool like ab (ApacheBench) can show how Hono.js handles more requests per second due to its optimized performance.

Cloud-Native Ready

Deploying a Hono.js app to a cloud platform like AWS Lambda:

This code prepares a Hono.js application to be deployed as a serverless function on AWS Lambda using the serverless-http package.

TypeScript Support

Creating a Hono.js application with TypeScript:

By using TypeScript, you get type safety and improved developer experience.

Install Hono.js

You may visit: hono-npm

This example demonstrates the simplicity and elegance of Hono.js. The framework's intuitive API allows developers to quickly set up routes and handlers without unnecessary complexity.

Real-World Use Cases

Microservices

Example: Building a microservice for user authentication:

APIs

Example: Creating a simple REST API for managing tasks:

Edge Computing

Example: Deploying a Hono.js function to Cloudflare Workers:

Serverless Applications

Example: Creating a serverless function for AWS Lambda:

Hono.js represents a new wave of minimalist web frameworks designed to meet the needs of modern cloud-native applications. Its lightweight design, combined with a focus on performance and extensibility, makes it an excellent choice for developers looking to build fast, efficient, and scalable applications. As cloud-native development continues to grow in importance, Hono.js is poised to become a valuable tool in the developer’s toolkit.

Whether you're building a small microservice or a large-scale application, Hono.js offers the right balance of simplicity and power to help you achieve your goals. Give it a try and experience the blazing speed and efficiency of Hono.js for yourself. 🧠 👩🏼‍💻

The Power of Symfony in DevOps

Hazar nenni — Sun, 03 Dec 2023 09:41:52 +0000

Symfony is a potent PHP framework known for its flexibility and robust architecture, making it a popular choice in web development. Its seamless compatibility with DevOps practices underscores its relevance in modern development workflows. This blog post will explore the DevOps side of Symfony development, covering essential topics such as continuous integration, deployment strategies, and monitoring.

Continuous Integration with Symfony:

- Setting the Foundation:

- Building Pipelines:

- Versioning and Dependency Management:

Deployment Strategies for Symfony:

Gain an understanding of various deployment strategies, such as the blue-green deployment method, which entails using two identical environments (blue and green) and redirecting traffic between them during the deployment process.
- Automated Deployment with CI/CD:

- Zero-Downtime Deployment:

Monitoring Symfony Applications:

What is Monitoring:
Acknowledge the critical role of monitoring in pinpointing performance bottlenecks, detecting errors, and maintaining the overall well-being of your Symfony application.

Monitoring Tools:
Opt for and set up a monitoring tool such as New Relic. Refer to the tool's documentation for guidance on installing and configuring it seamlessly within your Symfony application.

Issue Management:
Establish alert mechanisms within the monitoring tool to promptly receive notifications for specific events, such as elevated response times or heightened error rates. Configure automated actions or notifications to the development team, fostering a proactive approach to issue resolution.

By embracing DevOps practices, Symfony developers can greatly improve the efficiency, reliability, and scalability of their projects through continuous integration, well-defined deployment strategies, and robust monitoring. Symfony continues to lead in the evolving DevOps landscape, providing a strong foundation for developing and deploying modern, high-performance web applications. 🧠👩‍💻

Docker Best Practices.

Hazar nenni — Sun, 15 Oct 2023 18:50:15 +0000

Docker has revolutionized application deployment, but to use its full potential, you need to follow best practices. Here's a concise guide with examples for efficient containerization.

1. Start with Official Images:
Use official images as a base. For instance, if you're working with Node.js, start with node:14-alpine.

2. Optimize Your Dockerfile:
Minimize your image size by chaining commands together:

3. Use .dockerignore:
Create a .dockerignore file to exclude unnecessary files during build:

4. Multi-Stage Builds:
For production images, use multi-stage builds to reduce image size:

5. Environment Variables:
Use environment variables for configurations, e.g., for a Node.js app:

6. Health Checks:
Add a health check instruction to your Dockerfile:

7. Resource Constraints:
Define resource constraints in your Docker-Compose file:

8. Logging and Monitoring:
Use tools like Docker logs, ELK stack, or Prometheus for comprehensive logging and monitoring.

9. Container Registries:
Push your custom images to a private registry:

10. Versioned Images:
Tag your images for versioning:

These best practices will help you create efficient, secure, and maintainable Docker containers, improving your development and deployment workflows. 💻

Getting Started with GraphQL: A Beginner's Guide

Hazar nenni — Sun, 03 Sep 2023 11:05:17 +0000

Do you find yourself exhausted, from dealing with API endpoints and the unnecessary retrieval of data in your applications? If so GraphQL could be the solution you've been seeking. In this guide, for beginners we will walk you through the fundamentals of GraphQL, its principles. Provide you with a roadmap to get started with this groundbreaking technology.

What's GraphQl

GraphQL is a data query language and server side runtime that's source. It allows you to define a type system, for your data and execute queries on your API. Originally developed by Facebook in 2012 it was made available as source in 2015.

In contrast to APIs that have fixed endpoints returning data structures GraphQL provides clients the ability to request precisely the data they require without any excess or shortage. This adaptability makes it an ideal match, for web and mobile applications.

Core Concepts

Before we dive into the steps lets get a grasp of some principles of GraphQL.

Schema:
The schema serves as the backbone of any GraphQL API. It outlines the data types that can be requested and their relationships. These types consist of objects (such, as User or Post). Scalars (like String, Int, Boolean).
Queries:
Clients employ queries to ask for data, from the GraphQL server. A query mirrors the structure of the response data. Can encompass fields, nested structures and arguments.
Mutations:
Fundamentally different, queries retrieve information while mutations apply alterations. Within this scope are actions like record formation, alteration, and destruction.
Resolvers:
In charge of collecting essential details, resolvers serve as vital components in data retrieval processes. Linked to various data sources like databases and RESTful APIs, the GraphQL schema serves as a connection point.

You may visit the docs for more details by accessing to this link:
Queries and Mutataions

Getting started

We'll dive into the realm of GraphQL and craft a fundamental server and client together.

Server-Side

Choose a Server: You can use various server libraries and frameworks to set up a GraphQL server. Popular choices include Apollo Server, Express with Express-GraphQL, and more. Install your chosen server package using npm or yarn.

Define Your Schema: Create a schema that defines your data types (e.g., User, Post) and their relationships. This is usually done using GraphQL's schema definition language (SDL).

Set Up Resolvers: Integrate resolver functions within each field of your schema. Each function retrieves data from its designated source.

Start the Server: Once you've outlined the schema and resolvers, your GraphQL server begins organically connecting to clients via APIs.

Client-Side

Choose a Client Library: Similar to the server, you can select from various GraphQL client libraries like Apollo Client, Relay, or urql. Install your chosen client package.

Set Up Queries: Define your desired data from the server employing GraphQL queries. Within your JavaScript code for e.g, you can embed queries using GraphQL-tag.

Execute Queries: Use your client library to execute queries against your GraphQL server. This will return the requested data

Render Data: Next, display the data in user interface components. Featured frontend frameworks like React, Vue.js, and Angular are skillfully integrated by most GraphQL client libraries.

Congratulations! Just starting to dive into GraphQL's depths? By venturing further, you will find the incredible versatility and strength it holds for building innovative web and mobile applications.
👩‍💻💡🧠

Mastering Concurrency: Unveiling the Power of Goroutines in Go.

Hazar nenni — Tue, 22 Aug 2023 16:57:07 +0000

In the realm of programming languages, Go shines as a standout contender when it comes to handling concurrency. Its unique approach to concurrency, centered around goroutines and channels, has enabled developers to build highly responsive and efficient applications. In this blog post, we'll delve into the world of concurrency in Go, exploring the concepts of goroutines and channels and showcasing how they unlock new dimensions in your code.

🔸 Concurrency vs. Parallelism: Understanding the Difference

Before we dive into the specifics of goroutines, it's crucial to understand the distinction between concurrency and parallelism. Concurrency is the ability to execute multiple tasks seemingly at the same time, even if the tasks are not physically executing simultaneously. Parallelism, on the other hand, involves the simultaneous execution of multiple tasks on separate processors or cores. Go's concurrency model is built around managing and coordinating concurrent tasks effectively.

🔸 Meet Goroutines: Lightweight Concurrency

At the heart of Go's concurrency model are goroutines. A goroutine is a lightweight, independently executing function that runs concurrently with other goroutines. Unlike traditional threads, which are relatively heavy and can lead to performance overhead, goroutines are incredibly lightweight and can be spawned in the thousands without bogging down your system.

Creating a goroutine is as simple as adding the keyword go before a function call. This marks the function to be executed as a goroutine, allowing other parts of your program to continue executing concurrently.

func main() {
    go printNumbers()
    // Other code...
}

func printNumbers() {
    for i := 1; i <= 5; i++ {
        fmt.Println(i)
    }
}

🔸 Synchronization with Channels
Concurrency isn't just about running multiple tasks—it's also about coordinating their interactions. This is where channels come into play. Channels are communication mechanisms that allow goroutines to send and receive data in a synchronized manner. They facilitate safe data sharing and synchronization between goroutines.

func main() {
    ch := make(chan int)

    go sendData(ch)
    receiveData(ch)
}

func sendData(ch chan int) {
    for i := 1; i <= 5; i++ {
        ch <- i
    }
    close(ch)
}

func receiveData(ch chan int) {
    for num := range ch {
        fmt.Println("Received:", num)
    }
}

In the above example, the sendData function sends integers through the channel, and the receiveData function receives and prints them. The range loop gracefully terminates when the channel is closed.

🔸 Concurrency Patterns and Best Practices

While goroutines and channels form the backbone of Go's concurrency model, there are various concurrency patterns and best practices to consider:

Fan-Out, Fan-In: Distribute work among multiple goroutines (fan-out) and then consolidate the results (fan-in).
Select Statement: Use the select statement to wait on multiple channels simultaneously, allowing for non-blocking operations.
Context Handling: Utilize the context package to manage the lifecycle of goroutines and handle cancellations.

Go's concurrency model is a game-changer in the world of programming. By embracing goroutines and channels, you can write highly concurrent, responsive, and efficient applications that make the most of modern multi-core processors. Whether you're building web servers, distributed systems, or data processing pipelines, Go's concurrency features empower you to tackle complex challenges with elegance and efficiency. So, take the leap into the world of goroutines and unlock the true potential of concurrent programming in Go. 👩‍💻 🧠

Getting Started with Go: A Quick Guide.

Hazar nenni — Sat, 19 Aug 2023 17:50:50 +0000

Go, also known as Golang, is a statically typed, compiled programming language designed for simplicity, efficiency, and ease of use. Developed by Google, it has gained significant popularity for its clean syntax, strong standard library, and excellent support for concurrency. Whether you're a seasoned programmer or just starting your coding journey, this guide will help you take your first steps in the world of Go programming.

🖥 Installation:
The first step is to install the Go programming language on your system. Visit the official Go Downloads page https://go.dev/dl/ and download the installer suitable for your operating system. Follow the installation instructions to set up Go on your machine.

⚙ Setting Up Your Workspace:
Go has a unique way of organizing your projects. You'll want to set up your workspace properly. It uses a GOPATH environment variable to specify the root of your workspace. Create a directory structure like this:

├── src
│   └── yourApp
├── bin
└── pkg

👩‍💻 Your First Go Program:

While learning a new programming language, the iconic "Hello, World!" 🙌🏻 program serves as the inaugural step.
So, Create a file named main.go inside the src/yourapp directory. Open the file in a text editor and write a simple code :

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

To run your program, open a terminal, navigate to the myapp directory, and execute:

go run main.go

Go Basics:

Packages:
Go programs are composed of packages. Each file belongs to a package, and the 'main' package is required for executable programs.
Imports:
Use the import statement to include packages from the Go standard library or external packages.
Functions:
Functions are the building blocks of a Go program. The 'main' function is the entry point for executable programs.
Variables and Types:
Declare variables with their type explicitly. Go has basic types like int, string, float64, and more.
Control Flow:
Go supports familiar control flow statements like if, for, and switch.

📌 Concurrency:
One of Go's standout features is its built-in support for concurrency using Goroutines and Channels. Goroutines are lightweight threads, and channels allow safe communication between them.

🔍 Exploring the Standard Library:
Go comes with an extensive standard library that covers everything from file handling to networking. Familiarize yourself with the official Go Documentation to leverage these powerful tools.

With its clean syntax, strong standard library, and emphasis on concurrency, Go is a fantastic language for both beginners and experienced developers.
Explore the official documentation, engage with the community, and start building amazing applications with Go!.
🧠 👩‍💻

The benefits of using version control systems.

Hazar nenni — Mon, 27 Mar 2023 11:35:01 +0000

In any project where multiple people are working together, keeping track of changes and collaborating effectively is key to success. Version control systems help with this by keeping track of changes and allowing for collaboration in a way that's efficient and organized.
In this blog, we'll explore the benefits of using version control systems. Whether you're a software developer, a writer, or a designer, version control systems are an important tool that can help you manage your work more effectively.

What is version control system ?

A version control system (VCS) is a software tool that helps developers manage changes to code or other digital assets over time. It allows developers to track changes to a project, collaborate with others on the same codebase, and maintain different versions of the codebase over time.

In a VCS, developers can create "commits" to save changes to the code and add comments to describe those changes. They can also create "branches" to work on different versions of the code in parallel, merge those branches together, and roll back changes if necessary. This makes it easier to collaborate on code with others and manage changes to the project over time.

Examples of VCS Tools:

Benefits of using VCS:

Here are some of the benefits of using version control systems:

Collaboration: VCS allows multiple developers to work on the same codebase simultaneously, without overwriting each other's changes. Developers can work on their own branches, merge changes, and review each other's work.
Automation: VCS can be integrated with other tools, such as continuous integration (CI) and continuous deployment (CD), to automate the build, test, and deployment process.
History tracking: VCS keeps track of all changes made to the codebase, including who made the change, when it was made, and why. This allows developers to review the history of the project and understand the evolution of the code.
Branching and merging: VCS allows developers to create different branches of the codebase, which can be worked on independently. Branches can be merged back into the main codebase when the work is complete.
Code reviews: VCS makes it easy to review code changes and provide feedback. This helps ensure that the code is of high quality and meets the project's requirements.

Overall, version control systems are essential for modern software development, providing a way to manage complexity, reduce errors, and improve collaboration among developers.💻

Create An API Using Laravel

Hazar nenni — Tue, 10 Jan 2023 16:41:01 +0000

What is Laravel?

Laravel is a PHP framework developed by Taylor Otwell. It is a set of PHP files that will facilitate programming, thanks to its elegant and expressive syntax.
It provides MVC implementation that helps you organizing your code for easier maintenance.
You will be able to create modern web application, including such things such as APIs or web services.

RESTful APIs :

There are many types of APIs but we will focus on RESTful APIs.
Well, API (Application Programming Interface) is a set of protocols and tools that allows applications to communicate and exchanges multiple data and services. While REST stands for Representational State Transfer.
The picture bellow may explain more about RESTful API and how it works :

👇🏻👇🏻👇🏻

STEP1 : Install Laravel

To install the latest version of Laravel, you need to run the command bellow :

composer create-project --prefer-dist laravel/laravel laravel_api_example

Once your application has been created, you could start the local development server using the Laravel artisan CLI serve :

cd laravel_api_example

php artisan serve

Indeed, you have to set up your database informations in the .env file

STEP2 : Plan your API

Try to make your base URL clear and simple.
In our tutorial we will design API for Events.
📌 NOTE!!!! => Keep verbs out of your base URLs.

Thus, if we would like for example to create an API to get your list of Events, the URL should look like that :

/events

Instead of :

/getEvents

Use of HTTP methods : We use the HTTP verbs as action in RESTful APIs. We could operate on our URLs with HTTP verbs.

Those verbs are : GET, POST, UPDATE, DELETE .

STEP3 : Migrations & Models

Before moving to migration, make sure that you've created a database and added it to the env file, like we've done in step1.

Now, let's start by creating our first model and migration--the Event.
For that, we'll use the following command:

$php artisan make:model Event -m

Note: The -m refers to --migration and it notifies the Artisan to create one for the model.

A migration file will be created in the database/migrations to generate our table. So, we have to modify the migration file to add the attributes that we're gonna work with.

With that done, let's go ahead and migrate by using the command below:

php artisan migrate

Going back to the models part, we'll add the two attributes to the Event model to the $fillable field.

📌 Fillable : It's a protected property that help us to use a short way to insert data. For example, the create function will look like

Event::create($request->all());

This is the model file that we'll end up with :

STEP 4 : Routes & Controllers

On the routes/api.php file, we'll create the essentials endpoints for the application.

📌 Note: All routes in api.php are prefixed with /api by default.

Now that we have set up our application, we can proceed to create the controller that will be composed of the methods for our API, so we'll run the following command:

$php artisan make:controller EventController

Then we'll add all the functions:

Show all the Events:

Show a specific Event:

Adding an Event:

Updating an Event:

Deleting an Event:

=> We've used the HTTP status to indicate whether a request has been successfully completed or not.
There are many HTTP status that we could use, in this blog, i'll explain the ones that have existed in the project:

200 = Request succeeded.
201 = Object created.
204 = No content.
404 = Resource Not found.

STEP 5 : Testing

Make sure that your server is running before moving to the test phase.

$php artisan serve

Then, you could use POSTMAN as a test tool for your API.

Thanks for reading, feedbacks are appreciated. 🦄

Be A Better Web Designer..

Hazar nenni — Fri, 22 Jul 2022 14:38:00 +0000

When you start being interested in becoming a web designer, many beginners often struggle with how to master what they've already learned.

As we all know " practice makes perfect ". Hence, in this blog, we'll explore some websites on which you could apply what you learned and improve your level :

www.frontendmentor.io : This site helps you to solve HTML, CSS, and JAVASCRIPT challenges. The advantage of this website is that it will give you tests based on your level.
www.superherojs.com : A collection of the best articles on creating, testing and maintaining a large JavaScript code.
www.dailyui.co/ : It's a series of daily design challenges inspiration and surprise rewards.
www.adamschwartz.co/magic-of-css/ : The magic of CSS.
www.maintainablecss.com/ : Write CSS without worrying that overzealous, pre-existing styles will cause problems. MaintainableCSS is an approach to writing modular, scalable and of course, maintainable CSS.
www.goodbrief.io/: Randomly generate smart design briefs to practice your design skills, get content for your portfolio and gain experience working off a real design brief.
www.designbetter.co/ : Introducing the best practices, stories, and insights from the world’s top design leaders.
www.html5up.net/ : A great resource for HTML 5 templates. You could modify the template as you wish.
www.refactoringui.com/ : Learn how to design awesome UIs by yourself using specific tactics explained from a developer's point-of-view.

Web design is steadily evolving. You should always keep learning and discovering new design tools and techniques.
{ I hope that you enjoyed the list. 🦄 }

Synchronous and Asynchronous Programming

Hazar nenni — Mon, 18 Jul 2022 12:32:26 +0000

Synchronicity refers to the way our code is executed. We usually have two programming models Synchronous and Asynchronous ( aka sync & async ).
Those models are used to build APIs , event-based architectures and helps to decide how to handle long-running tasks.
📌 It's important to choose when and which method to use.
In this blog, we'll discover when we should apply async programming and when using the sync method is the best option.

let’s start by identifying the difference between asynchronous and synchronous programming.

In Synchronous programming, code is executed sequentially. This means that tasks are processing one at a time, if one task is not completed the other once are blocked.

However, Asynchronous programming guarantee that all tasks will be carried out in parallel. Which means that your code will continue to be executed no matter the status of the previous tasks.

When to use sync programming:
When it comes to sync programming it's relatively complex. It may over-complicate things and makes it hard to deal with code.
On the other hand, it's fairly clear method, its code is easier to write and doesn’t require tracking and measuring process flows (as async does). It could be appropriate for a shopping app, for example.

When to use async programming:
Async programming is ideal when we aim to create projects with a huge number of iterations. Thus, steps doesn't require to have fixed sequences, it assures that the process of developing is growing simultaneously.

Conclusion
When it comes to choosing async or sync methods, none of them is inherently better. You just need to pick the most optimal solution for your project requirements.

👩‍💻🧑‍💻🧠 ..

Non-Technical Skills Every Developer Needs 🖥💡

Hazar nenni — Wed, 02 Feb 2022 11:56:38 +0000

Every developer felt lost when they started learning to code in the beginning, but coding is a skill and skills have to be practiced.
So many people think that technical skills are the most important factor needed to be a successful developer and skip over the non-technological ones that are equally valuable. Truth is, they are only one aspect of it. Indeed, there are several non-technical abilities that we should place importance on them.

Here are some of the essential non-technical skills for every developer to start working on :

1. Passion for coding

Passion is energy. Feel the power that comes from focusing on what excites you.
-Oprah Winfrey

When people love what they do, they will definitely bring out the best in them to produce better quality work. If a developer is really committed to their job and enjoys spending time programming even outside work, there will be no power that could stop them from being the most successful ones in their fields. However, lack of passion doesn't make you a bad developer, but it'll always keep you going, motivated, and making smart decisions despite all the problems that you may face during your career.

2. There's nothing called dummy questions

I had this thing once I started learning to code. I remember my first day as a web developer intern. I was so proud and a bit nervous. The only question that kept coming to my mind that day was:" am I ready? do I have the required skills? " because I've always had imposter syndrome. I didn't want anyone to uncover that my knowledge and skills weren't high.
So each time I faced a problem and something that blocked me, I kept trying to solve it without asking for help. I was afraid of people's reactions who were more experienced than me.
It was only in my head!! 😶
No single person can know everything. Also, your questions aren't stupid; they show that you're interested and always open to new ideas. There is nothing wrong with that! It's part of working in your team - to share ideas and help each other.
Seeking knowledge is a good thing. It will help you grow and become a better developer.

3. Patience and Persistence

The road to becoming a great developer has a lot of obstacles, challenges, and even failures. While coding you may spend a lot of time debugging or learning new things that you could apply to your current project.
Thus, it might cause more pressure and stress on you, mostly when the deadline is approaching.
So, you must remain patient and persistent because the price of success is high but really worth it.

4. Time Control

Time management is one of the most critical things and doing it the right way will help you improve in your career. As a developer, it will allow you to perfectly set priorities, allocate time for rest, family, and other activities. For example, you could set long and short time goals to make your life better; you may also collect all your tasks in a to-do list to estimate every task and set deadlines for yourself; hence you can avoid doing them at the last minute, etc...
So, help yourself to achieve your dreams, plan and manage your time, be successful and healthy. 😊

5. Strong Work Ethic

Work ethic refers to the set of values and beliefs based on the ideals of integrity and hard work. This quality makes all the soft skills possible. It includes Teamwork, Discipline, Responsibility, Adaptability, Professionalism, etc. It will make you more productive, give you better opportunities, and help you to excel in your job.

Conclusion

Being a developer is such an amazing thing, there is always new stuff to learn. Those who give importance to soft skills as well as technical competencies enhance opportunities to be effective in their role. ❤️👨‍💻