DEV Community: Makepad

Mastering Java and Spring Boot

Idil Saglam — Mon, 15 Jan 2024 20:43:34 +0000

Java is a dominant and preferred programming language for many developers. With the Spring Boot, Java's capabilities have been significantly enhanced, offering a robust framework for building modern, scalable applications.

Java is a high-level programming language renowned for its stability, security, and cross-platform capabilities.

Object-Oriented Programming (OOP): Java's OOP model simplifies complex software development, promoting code reusability, scalability, and maintenance.

Platform Independence: Java's "write once, run anywhere" philosophy is realized through the Java Virtual Machine (JVM), making it a versatile choice for diverse environments.

Rich API and Powerful Development Tools: Java's extensive API and tools like Eclipse and IntelliJ IDEA enhance developer productivity and application performance.

Spring Boot: Simplifying Java Application Development
Spring Boot, a project under the larger Spring framework, revolutionizes Java application development by simplifying the setup and deployment process. It's designed to get your applications up and running as quickly as possible with minimal configuration.

Convention over Configuration: Spring Boot's approach minimizes the need for explicit configuration, reducing development time and potential errors.
Standalone Applications: It enables the creation of standalone, production-grade applications that you can "just run."

Microservices Ready: Spring Boot is an excellent choice for building microservices, offering lightweight components and cloud-ready features.
Key Features of Spring Boot

Auto-Configuration: Spring Boot automatically configures your application based on the added dependencies.
Spring Initializr: A web-based tool that helps in project setup and dependency management.

Actuator: Provides built-in endpoints for monitoring and managing application health.

Building a Simple Application with Java and Spring Boot
To understand the practical implementation, let's create a basic RESTful web service using Java and Spring Boot.

Setting Up: Use Spring Initializr to generate a Maven or Gradle project with required dependencies.
Coding: Develop your application using Spring Boot's easy-to-use annotations and classes.

Running the Application: Run your application with a simple command or through your IDE.
Advantages of Using Java with Spring Boot

Increased Productivity: With less code and easier configuration, developers can focus more on business logic rather than boilerplate code.

Enhanced Performance: Java's performance combined with Spring Boot's optimization features results in high-performance applications.

Community and Support: Both Java and Spring Boot have a large, active community, ensuring a wealth of resources and support.
Conclusion

Java, combined with Spring Boot, offers a powerful duo for building efficient, robust, and scalable applications. Whether you're new to programming or an experienced developer, mastering Java and Spring Boot can significantly elevate your development capabilities, preparing you for the challenges of modern software development.

Reverting Slack's New UI: A Guide for Developers Who Love Control

Kaan Yagci — Tue, 17 Oct 2023 22:02:38 +0000

Hello fellow developers!

Being a software engineer for the past 10 years, I've had my fair share of software updates, upgrades, and UI revamps. Some of them are warmly welcomed, while others make us question, "Why? Just... why?"

Recently, Slack decided to roll out a new UI, and let's say it wasn't my cup of coffee. The new change can be a bit frustrating for many of us juggling between multiple Slack servers (and I'm talking about working with two different companies simultaneously). But fret not, for the developer community is resourceful and never backs down from a challenge.

Thanks to the good folks over at Reddit, I stumbled upon a nifty little trick that helped me revert to the old UI, and I wanted to share this knowledge with all of you, especially if you're in the same boat as me.

Let's dive in!

Step 1: Enable Slack's Developer Menu

Before we begin, ensure that Slack is closed. To enable the developer menu, we need to set an environment variable. Open your terminal and type:

export SLACK_DEVELOPER_MENU=true

Step 2: Launch Slack

Once you've set the environment variable, navigate to your applications and open Slack:

open /Applications/Slack.app

Step 3: Access Developer Console

Here comes the fun part! Once Slack is up and running, you need to open the developer console. For this, simply press:

cmd + option + I

Step 4: The Magic Spell (JavaScript)

With the developer console in front of you, copy and paste the following JavaScript code:

localStorage.setItem(
  "localConfig_v2",
  localStorage
    .getItem("localConfig_v2")
    .replace(
      /\"is_unified_user_client_enabled\":true/g,
      '"is_unified_user_client_enabled": false',
    ),
);

Hit 'Enter', and voila! The old, familiar Slack UI should be back.

Wrapping up

The beauty of the developer community is how quick we are at finding workarounds when things don't go as per our liking. And while I'm sure Slack had its reasons for the UI change, it's great to know that we aren't entirely helpless in such situations.

So, next time you're met with an unappreciated software change, remember this - there's probably a workaround out there. All you need is a little digging and some faith in the community.

Happy coding!

By the way, if you found this useful, drop a comment, share it with your peers, and let's continue making our software lives a bit more comfortable.

Cheers,
Kaan

Note: This method is based on community findings and might not work with future Slack updates. Always back up your important data before making any changes.

Reverting Slack's New UI: A Guide for Developers Who Love Control

Kaan Yagci — Tue, 17 Oct 2023 22:02:38 +0000

Hello fellow developers!

Let's dive in!

Step 1: Enable Slack's Developer Menu

Before we begin, ensure that Slack is closed. To enable the developer menu, we need to set an environment variable. Open your terminal and type:

export SLACK_DEVELOPER_MENU=true

Step 2: Launch Slack

Once you've set the environment variable, navigate to your applications and open Slack:

open /Applications/Slack.app

Step 3: Access Developer Console

Here comes the fun part! Once Slack is up and running, you need to open the developer console. For this, simply press:

cmd + option + I

Step 4: The Magic Spell (JavaScript)

With the developer console in front of you, copy and paste the following JavaScript code:

localStorage.setItem(
  "localConfig_v2",
  localStorage
    .getItem("localConfig_v2")
    .replace(
      /\"is_unified_user_client_enabled\":true/g,
      '"is_unified_user_client_enabled": false',
    ),
);

Hit 'Enter', and voila! The old, familiar Slack UI should be back.

Wrapping up

So, next time you're met with an unappreciated software change, remember this - there's probably a workaround out there. All you need is a little digging and some faith in the community.

Happy coding!

By the way, if you found this useful, drop a comment, share it with your peers, and let's continue making our software lives a bit more comfortable.

Cheers,
Kaan

Note: This method is based on community findings and might not work with future Slack updates. Always back up your important data before making any changes.

Reverting Slack's New UI: A Guide for Developers Who Love Control

Kaan Yagci — Tue, 17 Oct 2023 22:02:38 +0000

Hello fellow developers!

Let's dive in!

Step 1: Enable Slack's Developer Menu

Before we begin, ensure that Slack is closed. To enable the developer menu, we need to set an environment variable. Open your terminal and type:

export SLACK_DEVELOPER_MENU=true

Step 2: Launch Slack

Once you've set the environment variable, navigate to your applications and open Slack:

open /Applications/Slack.app

Step 3: Access Developer Console

Here comes the fun part! Once Slack is up and running, you need to open the developer console. For this, simply press:

cmd + option + I

Step 4: The Magic Spell (JavaScript)

With the developer console in front of you, copy and paste the following JavaScript code:

localStorage.setItem(
  "localConfig_v2",
  localStorage
    .getItem("localConfig_v2")
    .replace(
      /\"is_unified_user_client_enabled\":true/g,
      '"is_unified_user_client_enabled": false',
    ),
);

Hit 'Enter', and voila! The old, familiar Slack UI should be back.

Wrapping up

So, next time you're met with an unappreciated software change, remember this - there's probably a workaround out there. All you need is a little digging and some faith in the community.

Happy coding!

By the way, if you found this useful, drop a comment, share it with your peers, and let's continue making our software lives a bit more comfortable.

Cheers,
Kaan

Note: This method is based on community findings and might not work with future Slack updates. Always back up your important data before making any changes.

Exploring Mobile App Development with React Native

Idil Saglam — Wed, 26 Jul 2023 18:35:09 +0000

In the world of mobile app development, efficient cross-platform solutions are a holy grail. One such technology, React Native, stands out due to its capacity to render natively on both iOS and Android platforms. Invented by Facebook, this JavaScript framework has gained widespread popularity among developers and businesses alike. Here's why.

What is React Native?

React Native is a JavaScript framework for building mobile applications that run natively on both iOS and Android platforms. It’s an offshoot of React, Facebook’s JavaScript library for crafting engaging user interfaces. However, instead of targeting browsers like React does, React Native focuses on mobile platforms. The result? A seamless user experience and code reusability that hastens development timelines and reduces costs.

Building Blocks of React Native

In React Native, the building blocks are the native components. It wraps existing native code for user interface controls and exposes them to JavaScript. As a result, your React Native apps will render using real mobile UI components, not webviews, providing the same look and feel as any other mobile application.

React Native also taps into JavaScript and React, enabling you to compose a rich mobile UI from declarative components. If you're familiar with React, you'll be right at home with React Native.

Why Choose React Native?

One of the key advantages of React Native is Code Reusability. The same team can develop apps for both iOS and Android, leading to significant cost and time savings. More than that, up to 90% of the code can be shared between the two platforms.

React Native also boasts Community Support. As an open-source project, React Native is supported by a vibrant community of developers who continually contribute to making the framework better. This means you can leverage plenty of third-party plugins and libraries.

Performance is another area where React Native shines. Unlike hybrid frameworks that render code via webviews, React Native allows components to be rendered as native platform widgets, leading to improved performance.

Hot Reloading is a distinctive feature that increases development speed. This feature refreshes the UI instantly as developers adjust the code, allowing them to see changes in real time.

React Native in the Real World

Major corporations use React Native. Facebook, of course, uses it for their Ads Manager app. Instagram, after being acquired by Facebook, integrated React Native into their existing native app for push notifications and saved posts.

Other notable mentions include Walmart, which used React Native to improve performance of their app, and Bloomberg, which developed their consumer mobile app using this technology.

Starting with React Native

To start with React Native, you need to have Node.js and npm (node package manager) installed on your computer. Also, install the Expo CLI, which helps you create and manage your React Native projects.

Create a new project with expo init AwesomeProject, navigate into the project using cd AwesomeProject, and start your app with npm start.

Conclusion

React Native is a revolutionary framework that is changing the landscape of mobile app development. Its ability to deliver native-like performance, coupled with significant time and cost savings, makes it an attractive choice for businesses and developers. Whether you are planning to build a new app or thinking about migrating an existing one, React Native could be a great choice.

Demystifying Kubernetes: A Comprehensive Overview

Idil Saglam — Tue, 16 May 2023 12:38:27 +0000

Introduction

In the constantly evolving world of technology, Kubernetes has emerged as a game-changing solution in the realm of container orchestration. The open-source platform, originally developed by Google, is now maintained by the Cloud Native Computing Foundation (CNCF). But what exactly is Kubernetes? This blog post aims to demystify Kubernetes, breaking down its complexities into digestible insights.

What is Kubernetes?

Kubernetes, also known as K8s, is an open-source system designed to automate the deployment, scaling, and management of containerized applications. Containers package an application with all its dependencies, allowing it to run uniformly across different computing environments.

Kubernetes steps in to solve a crucial problem: How do you manage these containers at scale? With Kubernetes, you can efficiently coordinate and automate a vast array of containers, ensuring that your applications run smoothly and reliably, no matter the scale.

Why Kubernetes?

Before the advent of Kubernetes, managing and scaling containerized applications was no simple task. Kubernetes brought several benefits to the table:

1.Scalability: Kubernetes can quickly and efficiently scale out or scale in applications based on demand.

2.High Availability: Kubernetes ensures that your applications are always up and running, reducing the risk of downtime.

3.Portability: With Kubernetes, applications can be run anywhere without needing to change the underlying code. This allows for seamless migration and multi-cloud strategy implementation.

4.Automated Rollouts & Rollbacks: Kubernetes can handle updates and rollbacks automatically, reducing the risk of errors and downtime during these processes.

5.Self-healing: Kubernetes has the ability to detect and replace unhealthy containers, ensuring that the system is functioning correctly at all times.

6.Secret and Configuration Management: Kubernetes allows you to manage and store sensitive information, such as passwords and API keys, securely and deploy configuration changes without rebuilding your container images.

Conclusion

In the fast-paced world of software development, Kubernetes has emerged as a powerful ally. Its robust capabilities in orchestrating and managing containers have revolutionized the way businesses deploy and scale their applications. With its unique features such as scalability, high availability, automated rollouts and rollbacks, and self-healing, Kubernetes ensures that our applications run smoothly and reliably, regardless of scale or complexity.

However, as with any technology, Kubernetes is not a one-size-fits-all solution. It's a complex system that requires a good understanding to exploit its full potential. Therefore, businesses and developers should thoroughly assess their needs and capabilities before diving into Kubernetes.

In conclusion, Kubernetes is more than just a buzzword in the tech industry. It's a powerful tool that has significantly improved how we handle containerized applications, making our digital lives more efficient and reliable. As we move towards an increasingly cloud-native future, Kubernetes' role is set to become even more pivotal, shaping the evolution of software deployment and management.

Creating a Simple Go Application for CRUD Operations with Neo4j and Docker

Idil Saglam — Thu, 30 Mar 2023 12:01:02 +0000

Hi everyone 👋, today we'll create a simple Go application that demonstrates basic CRUD operations using Neo4j 🏢, a popular graph database, and Docker 🐳. This tutorial will guide you through the steps to set up a local Neo4j instance using Docker, connect to it from your Go application using the Neo4j Go driver 🚗, and perform CRUD operations on a sample data set. By the end of this tutorial, you'll have a solid understanding of how to use Neo4j with Go and Docker to build scalable and efficient graph-based applications 🚀. So, let's get started!

Neo4j is a popular graph database that allows users to store, manage, and retrieve data using graph-based queries 📊. Go is a popular programming language for building scalable and efficient applications 🚀. In this tutorial, we'll learn how to create a simple Go project that uses Neo4j and Docker to perform CRUD operations.

Prerequisites

Before we begin, please ensure that you have the following installed on your system:

Docker 🐳
Go (version 1.16 or higher)
The neo4j-go-driver package (version 4 or higher)

Setting up a Neo4j Database with Docker 🐳

First, we need to set up a Neo4j database using Docker 🐳. Open your terminal and execute the following command:

docker run --name neo4j -p 7687:7687 -p 7474:7474 -e NEO4J_AUTH=neo4j/test1234 neo4j:latest
This command will create a new Docker container with a Neo4j database running on port 7687 (for Bolt) and 7474 (for HTTP)🚀. We're also setting the NEO4J_AUTH environment variable to neo4j/test1234 to specify the initial password for the neo4j user.

Creating a New Go Project

Next, we need to create a new Go project. Create a new directory for the project and navigate into it:

mkdir my-neo4j-project
cd my-neo4j-project

Create a new Go module for the project:

go mod init my-neo4j-project

This will create a new go.mod file in the project directory.

Now, let's take a look at the code! 🔍

Import statements

import (
    "fmt"
    "github.com/neo4j/neo4j-go-driver/v4/neo4j"
    "log"
)

The import statements include the necessary packages to interact with Neo4j database and log errors.

Create a person struct

type Person struct {
    ID   int64
    Name string
    Age  int
}

The Person struct represents the structure of a "Person" node in the Neo4j database 🧑. It has an ID, name, and age field.

Write the Main function

func main() {
    // create a new Neo4j driver
    driver, err := neo4j.NewDriver("bolt://localhost:7687", neo4j.BasicAuth("neo4j", "test1234", ""))
    if err != nil {
        log.Fatalf("Failed to create Neo4j driver: %v", err)
    }
    defer driver.Close()

The main function is the entry point of the application. It creates a new Neo4j driver instance by providing the bolt URL and authentication credentials 🔐.

Create a Person

Let's start by creating a new person. We define a createPerson function that takes in the Neo4j driver instance, the person's name, and age as arguments. Inside the function, we create a new session using the driver and then execute a Cypher query to create a new Person node with the given name and age. We then extract the ID of the created node from the result and return a new Person struct with the ID, name, and age.

func createPerson(driver neo4j.Driver, name string, age int) (*Person, error) {
    session := driver.NewSession(neo4j.SessionConfig{})
    defer session.Close()

    result, err := session.Run(
        "CREATE (p:Person {name: $name, age: $age}) RETURN id(p)",
        map[string]interface{}{"name": name, "age": age},
    )
    if err != nil {
        return nil, err
    }

    record, err := result.Single()
    if err != nil {
        return nil, err
    }

    id, ok := record.Values[0].(int64)
    if !ok {
        return nil, fmt.Errorf("invalid ID type")
    }

    return &Person{ID: id, Name: name, Age: age}, nil
}

Get a Person by Name

Next, we define a getPersonByName function that takes in the Neo4j driver instance and a person's name as arguments. Inside the function, we create a new session using the driver and then execute a Cypher query to find a Person node with the given name. We limit the result to one record and extract the ID and age of the node from the result. We then return a new Person struct with the ID, name, and age.

func getPersonByName(driver neo4j.Driver, name string) (*Person, error) {
    session := driver.NewSession(neo4j.SessionConfig{})
    defer session.Close()

    result, err := session.Run(
        "MATCH (p:Person) WHERE p.name = $name RETURN id(p), p.age LIMIT 1",
        map[string]interface{}{"name": name},
    )
    if err != nil {
        return nil, err
    }

    record, err := result.Single()
    if err != nil {
        return nil, err
    }

    id, ok := record.Values[0].(int64)
    if !ok {
        return nil, fmt.Errorf("invalid ID type")
    }

    age, ok := record.Values[1].(int64)
    if !ok {
        return nil, fmt.Errorf("invalid age type")
    }

    return &Person{ID: id, Name: name, Age: int(age)}, nil
}

Get a Person by ID

We also define a getPersonByID function that takes in the Neo4j driver instance and a person's ID as arguments. Inside the function, we create a new session using the driver and then execute a Cypher query to find a Person node with the given ID. We extract the name and age of the node from the result and return a new Person struct with the ID, name, and age.

func getPersonByID(driver neo4j.Driver, id int64) (*Person, error) {
    session := driver.NewSession(neo4j.SessionConfig{})
    defer session.Close()

    result, err := session.Run(
        "MATCH (p:Person) WHERE id(p) = $id RETURN p.name, p.age",
        map[string]interface{}{"id

Update person age

The updatePersonAge function takes in a Neo4j driver object, the ID of the person whose age needs to be updated, and the new age. It then creates a new session using the driver and executes a Cypher query that updates the person's age based on the provided ID. The Cypher query starts with the MATCH keyword, which finds the person node with the given ID. The SET keyword is used to set the person node's age property to the new age provided. Finally, the RETURN keyword is used to retrieve the person node's name and updated age.

Once the Cypher query has executed successfully, the function constructs a Person struct containing the updated ID, name, and age. This Person struct is then returned by the function.

func updatePersonAge(driver neo4j.Driver, id int64, age int) (*Person, error) {
    session := driver.NewSession(neo4j.SessionConfig{})
    defer session.Close()

    result, err := session.Run(
        "MATCH (p:Person) WHERE id(p) = $id SET p.age = $age RETURN p.name, p.age",
        map[string]interface{}{"id": id, "age": age},
    )
    if err != nil {
        return nil, err
    }

    record, err := result.Single()
    if err != nil {
        return nil, err
    }

    name, ok := record.Values[0].(string)
    if !ok {
        return nil, fmt.Errorf("invalid name type")
    }

    newAge, ok := record.Values[1].(int64)
    if !ok {
        return nil, fmt.Errorf("invalid age type")
    }

    return &Person{ID: id, Name: name, Age: int(newAge)}, nil
}

Delete person

The deletePerson function takes in a Neo4j driver object and the ID of the person to be deleted. It creates a new session using the driver and executes a Cypher query that deletes the person node based on the provided ID. The Cypher query starts with the MATCH keyword, which finds the person node with the given ID. The DELETE keyword is used to delete the person node.

If the deletion is successful, the function returns nil. Otherwise, it returns an error indicating that the deletion was unsuccessful.

func deletePerson(driver neo4j.Driver, id int64) error {
    session := driver.NewSession(neo4j.SessionConfig{})
    defer session.Close()

    _, err := session.Run(
        "MATCH (p:Person) WHERE id(p) = $id DELETE p",
        map[string]interface{}{"id": id},
    )
    if err != nil {
        return err
    }

    return nil
}

Putting it All Together

Now that we have defined the necessary functions for CRUD operations, let's put them together in the main function. The main function demonstrates how to create, get, update, and delete a Person node in the Neo4j database.

func main() {
    // create a new Neo4j driver
    driver, err := neo4j.NewDriver("bolt://localhost:7687", neo4j.BasicAuth("neo4j", "test1234", ""))
    if err != nil {
        log.Fatalf("Failed to create Neo4j driver: %v", err)
    }
    defer driver.Close()

    // create a new person
    person, err := createPerson(driver, "Alice", 30)
    if err != nil {
        log.Fatalf("Failed to create person: %v", err)
    }
    log.Printf("Created person: %+v\n", person)

    // get the person by name
    personByName, err := getPersonByName(driver, "Alice")
    if err != nil {
        log.Fatalf("Failed to get person by name: %v", err)
    }
    log.Printf("Found person by name: %+v\n", personByName)

    // get the person by ID
    personByID, err := getPersonByID(driver, person.ID)
    if err != nil {
        log.Fatalf("Failed to get person by ID: %v", err)
    }
    log.Printf("Found person by ID: %+v\n", personByID)

    // update the person's age
    updatedPerson, err := updatePersonAge(driver, person.ID, 35)
    if err != nil {
        log.Fatalf("Failed to update person's age: %v", err)
    }
    log.Printf("Updated person: %+v\n", updatedPerson)

    // delete the person
    err = deletePerson(driver, person.ID)
    if err != nil {
        log.Fatalf("Failed to delete person: %v", err)
    }
    log.Printf("Deleted person with ID %d\n", person.ID)
}

The main function first creates a new Neo4j driver instance and then creates a new person node with the name "Alice" and age 30. It then retrieves the person node by name and ID and prints the results. The function then updates the person's age to 35 and prints the updated person. Finally, it deletes the person node and prints a message indicating that the person was deleted.

Conclusion

In this tutorial, we learned how to create a simple Go application that uses Neo4j and Docker to perform CRUD operations on a sample data set. We first set up a Neo4j database using Docker and then defined the necessary functions for creating, getting, updating, and deleting a Person node in the Neo4j database. We then put these functions together in the main function to demonstrate how to perform CRUD operations on a sample data set.

By the end of this tutorial, you should have a solid understanding of how to use Neo4j with Go and Docker to build scalable and efficient graph-based applications. I hope you found this tutorial helpful, and please feel free to leave any comments or questions below! 👋

Power of Collaboration and Automation 🤖

Idil Saglam — Sat, 18 Mar 2023 15:32:33 +0000

Hello,

As a freelance full-stack developer, I’m always on the lookout for ways to improve my workflow and deliver better results for my clients. One game-changer I’ve come across is the adoption of DevOps practices in modern software development. 🚀

DevOps is all about bringing development and operations teams together, fostering collaboration, and leveraging automation to streamline the entire software development lifecycle. Let’s explore some of the amazing benefits of embracing DevOps: 🌟

1️⃣ Speedy Delivery: DevOps accelerates the process from development to deployment, ensuring quicker releases and helping you stay ahead in the game. ⚡️

2️⃣ Quality Matters: Continuous Integration and Continuous Deployment (CI/CD) pipelines keep your code tested, verified, and integrated, resulting in high-quality releases and fewer pesky bugs. 🐛

3️⃣ Teamwork Makes the Dream Work: By breaking down traditional silos, DevOps encourages seamless communication, shared responsibility, and a culture of continuous improvement. 🤝

4️⃣ Work Smart, Not Hard: Automation tools help eliminate manual tasks, allowing developers and operations teams to focus on more creative and high-value activities. 🧠

5️⃣ Building Resilience: Practices like Infrastructure as Code (IaC) and automated monitoring make it easier to identify and resolve issues quickly, ensuring your applications stay robust and reliable. 💪

The power of DevOps lies in its ability to bridge the gap between development and operations, creating a harmonious, efficient, and effective software development process. 🌉

Have you experienced the magic of DevOps in your projects? I’d love to hear your thoughts and stories in the comments below! 👇

Take a screenshot with Puppeteer

Idil Saglam — Wed, 15 Feb 2023 09:07:48 +0000

In this article, I am going to talk about how to take a screenshot with Puppeteer.

Pre-requisites

To use Puppeteer to take screenshots of web pages, you have to follow these steps:

First, you need to install nodejs and npm.

Before getting any further, please check the official documentation to check your version compatibility.

How to take a screenshot with Puppeteer?

Create a browser instance and a new page.
Adjust the viewport height to take a screenshot of the page.
Declare a variable for the website URL we want to take a screenshot.
To navigate our URL, use the goto() method from the page instance.
To capture a screenshot, call the screenshot method from the page instance by mentioning the output path.
As the screenshot is captured, as a final step, close the browser instance.

The source code for capturing a screenshot:

const puppeteer = require('puppeteer');

(async () => {
  // Creating a browser instance
  const browser = await puppeteer.launch();

  // Creating a new page
  const page = await browser.newPage();

  // Adjusting width and height of the viewport
  await page.setViewport({ width: 1200, height: 600 });

  const url = 'https://dev.to/makepad/use-emojis-in-your-commit-messages-1lag';

  // Open URL in current page
  await page.goto(url);

  // Capture screenshot
  await page.screenshot({
    path: 'demo.png',
  });

  // Close the browser instance
  await browser.close();
})();

You can execute the code by running node index.js in your command line and your output will be similar to this:

This is fine if you want to take a screenshot of the websites with nothing to scroll because the code takes a screenshot of the page as it is displayed.

How can we modify our code to take a full-page screenshot?

To capture a full page, we need to add a fullPage:true option for page.screenshot()

  await page.screenshot({
    path: 'demo.png',
    fullPage: true
  });

After updating our code, the output should be similar to the following:

How to take a screenshot of a particular HTML element?

Right-click any part of the page and choose Inspect. Clicking a specific page element will open that element in the inspector view. After finding the HTML element, you want to take a screenshot of, right-click the highlighted HTML code and click Copy > Copy Selector.

In this example this is the selector that I copied: #main-title > div.crayons-article__header__meta

Let's modify our code !

First, we need to declare a variable for the selector. Then, we will ask the page to wait for our selector. Lastly, as we want to take a screenshot of the element, we need to change await page.screenshot to await html_element.screenshot.

The source code for capturing a screenshot of an HTML element:

const puppeteer = require('puppeteer');

// Declaring a variable for the selector that we copied
const selector = `#main-title > div.crayons-article__header__meta`;

(async () => {
  // Creating a browser instance
  const browser = await puppeteer.launch();

  // Creating a new page
  const page = await browser.newPage();

  // Adjusting width and height of the viewport
  await page.setViewport({ width: 1200, height: 600 });

  const url = 'https://dev.to/makepad/use-emojis-in-your-commit-messages-1lag';

  // Open URL in current page
  await page.goto(url);
  await page.waitForSelector(selector);

  //We will ask the page to wait our selector
  const html_element = await page.$(selector);

  // Capture screenshot
  await html_element.screenshot({
    path: 'demo.png',
  });

  // Close the browser instance
  await browser.close();
})();

After updating our code, the output should be similar to to the following:

Conclusion
I explained few Puppeteer screenshot examples, and I hope I helped you solve your screenshot problems with Puppeteer.

Different Modelizations of Computer Networks

Kaan Yagci — Thu, 29 Dec 2022 14:14:13 +0000

In the previous article, we walked through some basics of computer networking. In this article, we'll walk through two widely used representations of computer networking. We'll not go into the implementation or semantic details for each representation. We'll get a general visualization of each model with some examples.

The Internet Protocol Suite (TCP/IP Model)

The Internet Protocol Suite, or the TCP/IP model, is a framework for organizing the communication protocols used in the Internet and similar computer networks according to functional criteria. This representation provides a four-layered network stack.

Let's take a closer look at each layer, starting from the bottom.

Link Layer

The link layer includes all hosts accessible without traversing a router. The size of the link is therefore determined by the networking hardware design. In principle, TCP/IP is designed to be hardware independent and may be implemented on virtually any link-layer technology. This includes hardware implementations and virtual link layers such as virtual private networks and networking tunnels.

Internet Layer

This is the layer where two devices on different networks communicate. This is the layer you use when printing something from the fifth-floor printer while sitting on the first floor. You can achieve this even though your office network has no internet connection.

Transport Layer

The transport layer provides the functional and procedural means of transferring variable-length data sequences from a source host to a destination host from one application to another across a network while maintaining the quality-of-service functions. This is the layer between your router and the application. It transports packages from your router to the application and vice-versa. This is the network layer you're using when printing something on your office printer while sitting on your couch at your home.

Application Layer

Generally speaking, the application layer is an abstraction layer that specifies the shared communications protocols and interface methods used by hosts in a communications network. For the Internet Protocol Suite, the application network contains the communications protocols and interface methods used in process-to-process communications across an Internet Protocol (IP) computer network. This is the highest layer of computer networking, which most people are familiar with. Every time you use your Web browser or every time you use a mobile application on your phone, this is the layer that you're using.

The OSI Model

The Open Systems Interconnection model (OSI) is a conceptual model that provides an everyday basis for coordinating ISO standards development for systems interconnection. Compared to the Internet Protocol Suite, the OSI model provides a network stack for more generic networking than Internet Protocol. This representation enumerates layers from bottom to top, starting from 1. Therefore in this representation, layers are often called by their number instead of their names.
The OSI representation provides a 7 layered network stack in which two communicating devices exchange protocol data units (PDUs) using a network protocol.

Layer 1: Physical Layer

The Physical Layer is responsible for the transmission and reception of unstructured raw data between a device, such as a network interface controller. This is the first layer that a device passes through. You can see this when you connect to a network for whatever reason. You must have a network interface to communicate with your router.

Layer 2: Data Link Layer

The Link Layer is the layer where two directly connected nodes communicate. You can see this as the layer you're using when printing something on your printer, which is on the same Network as you. To print, you don't send anything to the Internet. You just communicate with your printer through your router.

Layer 3: Network Layer

This layer is the same as the Internet Layer of the IP Suite. The naming is different because the IP Suite conceptualizes a network stack for internet communications, and OSI conceptualizes a network stack more generically. So, generally speaking, the Internet becomes Network.

Layer 4: Transport Layer

This layer has the same purpose as in the IP Suite model. The main difference in IP Suite is that it handles and controls the transport between Network Layer and the Session Layer.

Layer 5: Session Layer

The Session layer establishes, manages, and terminates the local and remote application connections. The Session Layer creates the setup, controls the connections, and ends the teardown between two or more computers, called a session. We'll get into more detail when we look into the HTTP in this tutorial series.

Layer 6: Presentation Layer

The Presentation Layer establishes data formatting and translation into a format specified by the application layer during the encapsulation of outgoing messages while being passed down the protocol stack and possibly reversed during the de-encapsulation of incoming messages when being passed up the protocol stack. The Presentation Layer handles protocol conversion, data encryption, data decryption, data compression, data decompression, incompatibility of data representation between OSs, and graphic commands. The presentation layer transforms data into the form that the application layer accepts to be sent across a network.

Layer 7: Application Layer

Finally, the Application Layer is the layer that is closest to the end user. You can think of it as it's in the Internet Protocol Suite.

Protocol Data Unit

A protocol data unit (PDU) is a single unit of information transmitted among peer entities of a computer network. It is composed of protocol-specific control information and user data. In the layered architectures of communication protocol stacks, each layer implements protocols tailored to the specific type or mode of data exchange.

For example, the Transmission Control Protocol (TCP) implements a connection-oriented transfer mode, and the PDU of this protocol is called a segment, while the User Datagram Protocol (UDP) uses datagrams as protocol data units for connectionless communication. A layer lower in the Internet protocol suite, at the Internet layer, the PDU is called a packet, irrespective of its payload type.

OSI Model

The layer 4 (Transport layer) PDU is the segment or the datagram, depending on the used protocol.
The Layer 3 (Network layer) PDU is the packet
The layer 2 (Data Link layer) PDU is frame
The Layer 1 (Physical layer) PDU is the bit, or more generally, symbol.

Internet Protocol Suite:

The Transport layer PDU is the TCP segment for TCP and the datagram for UDP
The Internet layer PDU is the packet
The Link layer PDU is the frame

On TCP/IP over Ethernet, the data on the physical layer is carried in Ethernet frames.

Internet Protocol Suite vs. OSI

There are a lot of differences between these two conceptualizations from a semantic and implementation point of view. But from a more generic point of view, there are more generic differences between these two conceptualizations:

number of layers: OSI is based on 7 layers, and Internet Protocol Suite is based on 4.
Do not confuse TCP/IP and Internet Protocol Suite: The Internet Protocol Suite is also called TCP/IP Model. But the conceptualization is separate from the TCP/IP protocol.
Enumerating Layers: The layer enumeration only exists in the OSI Model. In the Internet Protocol Suite, conceptualization layers are not enumerated by numbers as in the OSI Model.

What's next

In this tutorial, we walked through the two widely used modelizations of computer networks. In the next episode, we'll take a closer look to Layer 3 and will see how IP works in more details

More about Makepad

We're a tech consulting company based in France and share computer science related content on our socials.
If you want to see more this kind of content follow us on our socials: LinkedIn, Twitter and Instagram.

Makepad Follow

Makepad is a French tech consulting company that provides on-site and off-site services for open-source and proprietary projects.

Makepad · GitHub

Makepad is a French tech consulting company that provides consulting services on open-source and closed source development. - Makepad

github.com

To join to a community of tech enthusiasts where we talk about tech and other tech-related stuff 👇

WorkHouse

Check out the WorkHouse community on Discord - hang out with 14 other members and enjoy free voice and text chat.

discord.com

Introduction to Computer Networking

Kaan Yagci — Mon, 26 Dec 2022 07:22:58 +0000

In this tutorial series, I'll walk you through the basics of computer networking to familiarize you with some basic concepts that may help you understand the tools you're already using or may use in the future.

Disclaimer: This article series is not written to prepare you for a certification such as CCNA. The only reason for this tutorial series is to give you general knowledge about how things work under the hood.

Reasons to learn computer networking.

Less complication

Nowadays, almost everybody uses technologies like Docker and Kubernetes or REST APIs. Every developer uses it, but only some know how these things work. And if you don't see how these things work, when you need to debug your code, you may spend considerable time before making it work again.
Understanding generic concepts like cloud computing, REST, cyber security, or IoT becomes a nightmare if you don't have an existing knowledge of computer networking. For example, REST endpoints will feel like a black box without prior knowledge of HTTP.

Stand out in the competition.

Nowadays, more people become software engineers through boot camps or a CS degree. So the competition becomes more challenging every day as the number of developers also increases. Understanding how things work under the hood can help you stand out your profile in this competition.

Being a better team player

You have already heard that soft skills are essential to land your dream job. And being a good team player is one of the soft skills you'll see in a random list of "n soft skills that every developer should have." kinds of articles or podcasts. It's not only having good relations with your co-workers. You should maintain reasonable social concerns with everyone in your social life. If you understand what your network engineer, your DevOps, or your DevSecOps colleague is doing in their day-to-day job and the kind of challenges they are facing, you can help them as a developer you can make their life easier. And this will make you a better team player.

Path to becoming an expert.

Learning one or multiple programming languages inside out or using your favorite IDE may make you productive in your daily workflow. Having dozens of years of professional experience in your area may help you quickly understand more complicated scenarios, depending on your experience. But you will need more than these to make you an expert. To become an expert in your field, you must understand how things work under the hood. This is not only for computer science or engineering. For example, if you want to become an expert Formula 1 driver, you must understand aerodynamics or car mechanics.

Starting point: Vocabulary

As in most fields, the starting point of computer networking is also knowing some base vocabulary. I know this is boring, but there are not hundreds of them; most of these are things you've already heard.

Internet: a global computer network providing various information and communication facilities, consisting of interconnected networks using a standardized communication protocol, IP (Internet Protocol). We can imagine this as a massive network with billions of connected devices.
Web: the set of hyperlinks that connect the web pages between them. It's crucial to distinguish the Web and the Internet.
Web server: a computer accessible on the Internet and contains the Web's resources such as pages, images, etc. Web browser: a software program lets you consult the Web's resources.
HTML: or HyperText Markup Language, is a markup language that enables you to represent a web page.
Protocol: a system of rules that explain the correct conduct and procedures to be followed in formal situations. It can be either between two machines or multiple machines.
Speed: the number of bits per second that your Network can transfer (upload or download)
Latency: the number of seconds for the first transferred bit to arrive at its destination from the source.

What's next?

I hope you enjoyed this tutorial. If you like this article please like and share. In the following article, we'll walk through two widely used representation model of computer networking.

More about Makepad

Makepad Follow

Makepad is a French tech consulting company that provides on-site and off-site services for open-source and proprietary projects.

Makepad · GitHub

Makepad is a French tech consulting company that provides consulting services on open-source and closed source development. - Makepad

github.com

To join to a community of tech enthusiasts where we talk about tech and other tech-related stuff 👇

WorkHouse

Check out the WorkHouse community on Discord - hang out with 13 other members and enjoy free voice and text chat.

discord.com

Use emojis in your commit messages 🥳

Idil Saglam — Wed, 14 Dec 2022 11:46:55 +0000

Most of the time, it's difficult to understand the impact of a commit just from the commit message. You can, of course, create your own commit conventions or follow one of the existing conventions. You probably already saw a commit message like chore: implementing xyz feature. It's boring, isn't it?

How about using emojis in our commit messages to make them fun? 🤩

Yes, you read that right. In this article, I will present Gitmoji. I have been using it for two years, and I must admit that it is a game changer and really easy to use.

Getting Started

Installation

Check out their README file. The installation is also pretty simple. You can either install the npm package or the homebrew formulae.

# Installing via npm
npm i -g gitmoji-cli

# Installing via Homebrew
brew install gitmoji

Usage

After installing the CLI, you are ready to use. As usual add your files that you want to commit via git add <file_path_to_add> and just run the command gitmoji -c.

$ gitmoji -c
? Choose a gitmoji: (Use arrow keys or type to search)
❯ 🎨  - Improve structure / format of the code. 
  ⚡️  - Improve performance. 
  🔥  - Remove code or files. 
  🐛  - Fix a bug. 
  🚑  - Critical hotfix. 
  ✨  - Introduce new features. 
  📝  - Add or update documentation. 
(Move up and down to reveal more choices)

CLI provides some prompts and allows you to select the most appropriate emoji for your commit message from a list.

$ gitmoji -c
? Choose a gitmoji: add
❯ ➕  - Add a dependency. 
  📝  - Add or update documentation. 
  ✅  - Add or update tests. 
  📄  - Add or update license. 
  🍱  - Add or update assets. 
  🔊  - Add or update logs. 
  👥  - Add or update contributor(s). 
(Move up and down to reveal more choices)

But wait – there’s more

How does this look in a GitHub repo?

Isn't it awesome and fun?

Yay or Nay?

Cons

As in every convention, the reader should follow the convention in order to understand entirely.

Emojis are not ASCII characters, most of them are Unicode characters. Some tools may not support emojis at all or some of them may support only Unicode emojis.

Pros

I love emojis. Emojis are fun, and the GitHub repository looks better with them. It is fun to use, and it encourages writing commits.

Conclusion

It is easy to install and use and take your commits into an other level. I definitely recommend!

Happy coding!👩🏻‍💻