DEV Community: Mayowa Fajube

Linux Users and Groups Management using Bash Script

Mayowa Fajube — Mon, 01 Jul 2024 16:44:52 +0000

INTRODUCTION

User and group management is a fundamental task for any Linux SysOps engineer. Handling these tasks manually can be error-prone and time-consuming, especially in larger environments. It is critical when dealing with multiple users and groups to ensure each user has the correct permissions and access within the system. To streamline this process, I have developed a Bash script, create_users.sh, which automates the creation of users and groups based on a supplied file. This script not only creates users and their corresponding home directories but also ensures they are assigned to the correct groups and generates secure random passwords for them. Additionally, the script logs all actions for auditing purposes.

Script Overview

The create_users.sh script automates the following tasks:

Reading user and group information from a file.
Creating users and their personal groups.
Setting up home directories with proper permissions.
Generating random passwords for each user.
Logging all actions to a log file.
Storing generated passwords securely in a CSV file.

Let's break down the script step by step to understand its functionality.

0. Shebang: Specifying the Interpreter

The script begins with a shebang line:
#!/bin/bash
The importance of this line is;

Interpreter Directive: It specifies the path to the interpreter that should be used to execute the script. In this case, #!/bin/bash tells the system to use the Bash shell to run the script. The interpreter is responsible for parsing and executing the commands within the script.
Executable Scripts: When the shebang is present, the script can be executed directly as a standalone program. This means the script can be run by simply typing its name, provided it has execute permissions. Without the shebang, you would need to explicitly invoke the interpreter and pass the script as an argument (e.g., bash create_users.sh).

1. Checking Script Arguments

The script starts by verifying if a file name argument is provided alongside the bash script during runtime. This file should contain the username and group information in a specific format.

if [ "$#" -ne 1 ]; then
    echo "Usage: $0 <user_file>"
    exit 1
fi

If the argument is missing, the script exits with a usage message, ensuring the user knows how to correctly run the script.

2. Assigning user file argument supplied to a variable

USER_FILE="$1"

USER_FILE is a variable that I defined within the script. By assigning USER_FILE="$1", I am storing the value of the first argument passed to the script in this variable which is then used throughout the script to refer to the file containing the user and group information. By assigning the argument to a variable, the script can easily reference the input file without directly using $1 multiple times, making the code more readable and maintainable.

3. Checking Input File Existence

The below command checks if the specified user file exists. If not, it exits with an error message.

if [ ! -f "$USER_FILE" ]; then
    echo "Error: File $USER_FILE does not exist."
    exit 1
fi

This is to prevent the script from running without the necessary input data, avoiding potential errors.

4. Defining File Paths for logs and passwords

LOG_FILE="/var/log/user_management.log"
PASSWORD_DIR="/var/secure"
PASSWORD_FILE="$PASSWORD_DIR/user_passwords.csv"

These assigned paths to variables LOG_FILE and PASSWORD_FILE help in organizing the script's output and ensuring logs and passwords are stored securely.

5. Ensuring Log and Password Files Exist

touch $LOG_FILE

if [ ! -d "$PASSWORD_DIR" ]; then
    mkdir -p "$PASSWORD_DIR"
    chmod 700 "$PASSWORD_DIR"
fi

if [ ! -f "$PASSWORD_FILE" ]; then
    echo "username,password" > $PASSWORD_FILE
fi
chmod 600 $PASSWORD_FILE

This section of the script ensures that the log file and password directory exist, creating them if necessary. It also sets appropriate permissions for security. Creating the password directory with chmod 700 and the password file with chmod 600, ensures that only the root user can read and write these files, protecting sensitive information.

6. Logging Function

log_action() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" >> $LOG_FILE
}

This simple logging function records actions with timestamps, helping in troubleshooting and auditing. It appends log entries to the log file, providing a history of all script actions.

7. Reading and Processing the Input File

while IFS=';' read -r username groups; do
    username=$(echo "$username" | xargs)
    groups=$(echo "$groups" | xargs)

The script reads the input file line by line at this stage, processing each entry to extract the usernames and groups. It removes any leading or trailing whitespace from the entries.This ensures that any extraneous spaces in the input file do not cause issues.

8. Checking and Creating Users and Groups

    if id -u "$username" >/dev/null 2>&1; then
        log_action "User $username already exists."
        continue
    fi

For each user, the script checks if the user already exists. If the user exists, it logs this information and skips it to the next user. If the user does not exist, the script creates a personal group for the user.

    if ! getent group "$username" >/dev/null 2>&1; then
        groupadd "$username"
    fi

It then creates the user with their personal group and sets up their home directory with the correct permissions.

    useradd -m -g "$username" -s /bin/bash "$username"
    chmod 700 /home/"$username"
    chown "$username:$username" /home/"$username"

This ensures that the user's home directory is private and owned by the user.

9. Generating and Setting Passwords

    password=$(openssl rand -base64 12)
    echo "$username:$password" | chpasswd
    echo "$username,$password" >> $PASSWORD_FILE

The script section generates a random password using openssl, sets this password for the user, and logs it securely in the password file. Using openssl rand -base64 12 generates a secure 12-character password for each user.

10. Assigning Additional Groups

    if [ -n "$groups" ]; then
        IFS=',' read -r -a group_array <<< "$groups"
        for group in "${group_array[@]}"; do
            group=$(echo "$group" | xargs)
            if ! getent group "$group" >/dev/null 2>&1; then
                groupadd "$group"
            fi
            usermod -aG "$group" "$username"
        done
    fi

If additional groups are specified for the user, the script processes each group, ensuring it exists before adding the user to the group. This ensures that users are correctly assigned to all specified groups, creating groups if they do not already exist.

11. Logging Completion

    log_action "User $username created with groups: $username, $groups"
done < $USER_FILE

log_action "User creation process completed."

After processing all users, the script logs the completion of the user creation process.

Thanks to the HNG team for their brilliant initiative. This technical article fulfills stage 1 to stage 2 of the HNG11 internship program. For those looking to enhance their skills, consider joining the HNG Internship program. This initiative offers valuable hands-on experience and mentorship from industry experts. Additionally, for more advanced resources and opportunities, the HNG Premium platform provides exclusive access to premium content and professional development tools.

Pulumi: Empowering Infrastructure Engineers with Real Programming Languages

Mayowa Fajube — Wed, 03 Apr 2024 10:44:25 +0000

Introduction:

Managing cloud infrastructure effectively and efficiently is essential for developers and IT operations teams to achieve agility, scalability and reliability in the dynamic fast-paced world of cloud computing. Traditional methods of managing infrastructure, reliant on manual process and configuration files, often fall short in meeting the demands of modern cloud-native applications. Infrastructure as Code (IaC) is a game changer for engineers in this domain to manage and provision their cloud resources, creating a more automated, consistent, and safer process.

The groundbreaking introduction of Pulumi into the world of IaC revolutionized the way engineers manage and deploy cloud resources. It offers solutions to challenges Engineers face using traditional IaC tools. In this blog post, we'll delve into what Pulumi is, its key features, installation process, and why it's gaining traction among developers and enterprises worldwide.

What is Pulumi ?

Pulumi is an open-source infrastructure as code software that gives engineers and developers ability to define, deploy and manage cloud infrastructure using familiar programming languages such as JavaScript, Python, Go, and .Net. Unlike traditional IaC tools that utilize domain-specific languages (DSLs) or configuration files, Pulumi allows developers to leverage their existing skills in mainstream programming languages to describe and provision infrastructure resources.

Pulumi supports a variety of cloud providers, including AWS, Azure, GCP, and Kubernetes. Features like version control and unit testing, which can help to ensure the quality of infrastructure code is another thing Pulumi supports.

Pulumi’s Core Features

Programming Language Flexibility

Pulumi supports multiple programming languages, offering engineers to choose the language they are most comfortable with. This flexibility eliminates the need to learn proprietary DSLs, reducing the learning curve associated with adopting new tools.

Full Lifecycle Management

Pulumi provides comprehensive support for the entire infrastructure lifecycle, including provisioning, updating, and deleting resources. This end-to-end management simplifies the deployment process and ensures consistency across environments.

Infrastructure as Software

With Pulumi, infrastructure code is treated as first-class software, allowing developers to apply software engineering best practices such as version control, code review, and testing. This approach enhances collaboration and promotes code reusability and maintainability.

Multi-Cloud Support

Pulumi abstracts away the complexities of different cloud providers, enabling users to provision resources across multiple cloud platforms, including AWS, Azure, Google Cloud, and Kubernetes. This multi-cloud support facilitates hybrid and multi-cloud deployments, providing greater flexibility and vendor independence.

Resource Abstraction

Pulumi offers a rich set of abstractions for common cloud resources, allowing developers to define infrastructure using high-level constructs such as stacks, components, and modules. These abstractions promote modularity and encapsulation, making it easier to manage complex infrastructure configurations.

Reusable Components

Pulumi promotes code reusability through its Pulumi Packages. Developers can define infrastructure building blocks and share them across teams, promoting better consistency and reducing duplicated efforts.
Real-Time Feedback
Pulumi previews changes before deployment. This real-time feedback aids in avoiding potential issues and empowers more informed decisions.

Pulumi Installation

To get started with Pulumi, the first thing is to install Pulumi on your local device.

Step 1. Go to https://www.pulumi.com/docs/install/
Step 2. Choose your device operating system and follow the installation procedure to get Pulumi set-up.
Step 3. Configure the cloud provider credentials you want to create infrastructure on your device.
For instance, using the AWS platform.
Create an IAM user in the AWS console with programmatic access and ensure it has sufficient permissions to deploy and manage your Pulumi program’s resources;
Set up AWS credentials for the user
Set credentials as environment variables or use “aws configure”

Bootstrapping Project with Pulumi

The command pulumi new can be used to bootstrap a new project after installing pulumi on your device. This gives engineers room to select the cloud provider and programming language they intend to use and get basic configuration setup for the project ASAP.

Differences between Pulumi and Terraform

Pulumi and Terraform are both popular IaC tools. However, they have some key differences.

Pulumi uses your programming language to define your infrastructure, while Terraform uses its own proprietary language. This makes Pulumi more flexible and easier to use for developers who are already familiar with a programming language.
Pulumi supports aliases, while Terraform does not. This can be useful for making your code more readable and maintainable.
Pulumi is cloud-agnostic, while Terraform is only supported on a few cloud providers. This makes Pulumi more versatile and gives you more flexibility in terms of where you can deploy your infrastructure.

Benefits of Pulumi

Increased Productivity: By leveraging familiar programming languages and software development workflows, Pulumi enables developers to write infrastructure code more efficiently. This results in faster development cycles, quicker time-to-market, and increased productivity.
Improved Collaboration: Pulumi's focus on infrastructure as software fosters collaboration between development, operations, and security teams. Shared code repositories, code reviews, and automated testing help teams work together seamlessly, leading to better outcomes and fewer errors.
Greater Control and Flexibility: With Pulumi, developers have granular control over their infrastructure configurations, allowing them to tailor resources to meet specific requirements. This level of flexibility empowers teams to optimize performance, cost, and security based on their unique needs.
Reduced Vendor Lock-in: By abstracting away cloud provider-specific details, Pulumi mitigates the risk of vendor lock-in, enabling organizations to switch between cloud providers or adopt a multi-cloud strategy with minimal friction.
Community Ecosystem: Pulumi boasts a vibrant and active community of developers, contributors, and users who share best practices, tools, and extensions. This thriving ecosystem accelerates adoption, fosters innovation, and provides valuable resources for users at all skill levels.

In an era defined by digital transformation and cloud-native technologies, Pulumi stands out as a game-changer in the world of infrastructure as code. By combining the power of real programming languages with a comprehensive set of features and benefits, Pulumi empowers developers to build, deploy, and manage cloud infrastructure with unprecedented ease and efficiency.

Enhancing GIT: Improving Usability and Performance for Developers

Mayowa Fajube — Thu, 14 Mar 2024 07:58:51 +0000

Selecting Git as the focus of this review for my DXMentorship program task stems from my experience as a DevOps Engineer in the tech industry. Frequently, developers encounter challenges when working with the terminal or command line interface, leading to inefficiencies and frustrations. This review aims to explore potential enhancements to Git's usability and performance, addressing common pain points faced by developers in their everyday workflow.

In the realm of version control systems, Git stands out as a powerful and widely-used tool that revolutionized the way developers collaborate on projects. While Git has proven to be an invaluable asset for software development, there are areas where it can be further enhanced to elevate its usability and performance for developers of all levels.

The following are my insights into potential improvements:

Improving User Interface (UI):

One key aspect that could benefit from enhancement is Git’s user interface. Simplifying the interface, providing better color schemes, and improving overall visual appeal can make Git more user-friendly, especially for beginners. A visually intuitive UI can streamline workflows and make navigating Git commands more accessible.

Enhancing Performance with Large Repositories:

Dealing with large repositories can sometimes challenge Git’s performance. Optimizing how Git handles numerous files and commits, along with speeding up operations like retrieving status or staging files, can significantly enhance performance when working with extensive codebases.

Improving Feature Request Management:

Enhancing the handling of feature requests and discussions within Git can streamline communication between developers and users. Implementing tools for tracking requests, automatic updates on request statuses, and a more organized approach to accepting or rejecting features can enhance collaboration and feedback mechanisms.

Implementing a Roadmap Feature:

Introducing a roadmap feature within Git could provide users with a clearer view of ongoing development processes, feature requests, and product ideas. This transparency can help users track progress and align expectations, fostering better communication between developers and users.

Implementing a File System Monitor:

To address performance issues related to the number of files in the working directory, incorporating a built-in file system monitor within Git can help optimize performance, particularly in monorepo setups. Monitoring file changes and managing resources efficiently can improve overall system responsiveness.

Better Integration with Feedback Software:

Seamless integration with feedback software tools like FeedBear can empower developers to gather quantitative feedback on feature requests and prioritize development efforts effectively. This integration can streamline the feedback loop and ensure that user input is efficiently captured and acted upon.

By focusing on enhancing usability, performance, communication tools, and integration capacities, Git can further solidify its reputation as a versatile and efficient version control system. Embracing these improvements will not only benefit developers but also contribute to a more seamless and collaborative development environment.

Harnessing the Power of AWS Local Zones in Nigeria: A Server Configuration Guide

Mayowa Fajube — Tue, 23 Jan 2024 07:55:50 +0000

Introduction

In recent years, cloud computing has revolutionized the way organizations manage their infrastructure and deploy applications. Amazon Web Services (AWS) has been at the forefront of this transformation, offering a wide range of services and features to meet the diverse needs of businesses around the world. One such offering is AWS Local Zones, which brings high-performance, low-latency cloud resources closer to specific geographic regions. In this article, we will explore how to configure your server to harness the power of AWS Local Zones in Nigeria, optimizing performance and reducing latency for your applications.

Inspiration for This Article

The inspiration for writing this article stems from a recent interview I had with the Chief Technology Officer (CTO) of a forward-thinking company. During the interview, the CTO posed a crucial question: "How would you deploy our service to better serve the Nigerian market?" In response, I proposed a strategic approach: deploying the service within the AWS Local Zone in Nigeria to optimize performance and reduce latency for Nigerian users.

The concept of AWS Local Zones perfectly aligns with the need for low-latency access to cloud resources, making it an ideal solution for serving specific geographic regions with enhanced performance. By choosing to utilize the Local Zone in Nigeria, businesses can deliver a seamless and responsive user experience, a critical factor for success in today's digital landscape.

Additionally, I emphasized that flexibility is key. If there is a requirement to expand the service's reach beyond Nigeria, whether to the United States or Europe, AWS CloudFront can be employed. AWS CloudFront is a content delivery network service that ensures fast and reliable content delivery globally, further enhancing the service's global accessibility.

With this strategic combination of AWS Local Zones in Nigeria and the scalability offered by AWS CloudFront, businesses can effectively cater to the specific needs of their target markets, whether local or international, while maintaining optimal performance and latency levels. This article aims to provide a comprehensive guide on configuring your server to implement this strategy successfully, ensuring your service's success in the Nigerian market and beyond.

Understanding AWS Local Zones

AWS Local Zones are an extension of AWS regions, designed to provide low-latency access to specific geographic areas. While traditional AWS regions are located in major cities, Local Zones are deployed in proximity to these regions but are designed to serve specific geographic locations with faster access to AWS resources. In the case of Nigeria, the availability of an AWS Local Zone means that businesses can access cloud resources with minimal latency, making it an attractive option for deploying servers and applications.

Configuring Your Server for Nigeria, AWS Local Zones

Step 1: Choose the Region Closest to Nigeria (Africa - Cape Town)
The first step in configuring your server to utilize AWS Local Zones in Nigeria is to choose the AWS region that is closest to Nigeria, which is Africa (Cape Town). AWS regions are geographically distributed, and selecting the nearest region helps minimize latency and ensures optimal performance for your users in Nigeria.

Step 2: Enable AWS Local Zone in Nigeria setting in EC2 section
Enabling the AWS Local Zone in Nigeria is a critical step to access low-latency cloud resources within the region.
Here's how to do it:

Navigate to the EC2 Dashboard: In the AWS Management Console, navigate to the EC2 dashboard. You can do this by clicking on the "Services" menu at the top left corner, selecting "Compute," and then clicking on "EC2."
Choose the Africa (Cape Town) Region: Ensure that you have selected the Africa (Cape Town) region as your current region. You can check and change your region in the top-right corner of the AWS Management Console. Click on the region name and select "Africa (Cape Town)" from the drop down menu.
Enable Local Zone for Nigeria:
a. In the EC2 dashboard, locate the "Local Zones" option in the navigation pane on the left-hand side. Click on it to access the Local Zones section.
b. Within the Local Zones section, you should see the Nigeria Local Zone listed if it's available in the Africa (Cape Town) region. It may be named something like "af-south-1-lag-1."
c. Click on the Nigeria Local Zone to select it.
d. In the details pane, you should see an option to "Enable Local Zone." Click on this option to initiate the process.
e. Follow the on-screen instructions and confirm the enabling of the Local Zone. AWS will guide you through the necessary steps and configurations specific to the Nigeria Local Zone.
Wait for Confirmation: AWS will take a short amount of time to enable the Local Zone. Once the process is complete, you will receive confirmation that the Local Zone is now available for use within the Africa (Cape Town) region.

Step 3: Create a Subnet in Your VPC
Once you've enabled the AWS Local Zone in Nigeria and created the VPC, the next crucial steps involve setting up the necessary networking components and launching your server instance within the Local Zone.
Here's how to do it:

Navigate to the VPC Dashboard: In the AWS Management Console, navigate to the VPC dashboard. You can do this by clicking on the "Services" menu at the top left corner, selecting "Networking & Content Delivery," and then clicking on "VPC."
Create a Subnet in Your VPC:
a. In the VPC dashboard, locate the "Subnets" option in the navigation pane on the left-hand side. Click on it to access the Subnets section.
b. Click the "Create Subnet" button.
c. Follow the wizard to create a subnet within your VPC. When specifying the subnet's availability zone, make sure to choose the availability zone associated with the Nigeria Local Zone "Nigeria (Lagos)/af-south-1-lag-1" that you enabled in Step 2. This ensures that your subnet is within the Local Zone's region.
Step 4: Launch the Local Zone Instance
With your VPC and subnet in place, it's time to launch your server instance within the AWS Local Zone. However, it's essential to note that there are certain instance types that may not be available in this specific availability zone.
Here's how to proceed:
Navigate to the EC2 Dashboard: In the AWS Management Console, navigate to the EC2 dashboard. You can do this by clicking on the "Services" menu at the top left corner, selecting "Compute," and then clicking on "EC2."
Launch Your Local Zone Instance:
a. In the EC2 dashboard, click on the "Launch Instance" button to create a new server instance.
b. Follow the instance creation wizard, ensuring that you select the appropriate subnet you created earlier within the Local Zone. Make sure you choose the availability zone associated with the Nigeria Local Zone that you enabled in Step 2.
c. During instance type selection, please be aware that some instance types may not be available in the Nigeria Local Zone due to regional limitations.
To find compatible instance types:
In the "Choose an Instance Type" step of the wizard, click on the "View all instance types" link.
In the "Search" field at the top right corner of the instance type selection page, enter "availability zones: af-south-1-lag-1" and press Enter.
This search will filter and display instance types that are compatible with the Nigeria Local Zone (af-south-1-lag-1).
d. Continue with the configuration of your server instance, selecting an instance type that is compatible with the Nigeria Local Zone.
e. Configure storage, set up security groups as needed, and review other settings.
Step 5: IP Address Location Verification
After launching your server instance within the AWS Local Zone in Nigeria, it's essential to verify the IP address location. This step ensures that your server is correctly configured to serve users in Nigeria. Here's how to check the IP address location:
Verify IP Address Location:
a. Use an online IP geolocation service or website to verify the location associated with your ec2 instance public IP address.
b. Open a web browser and visit an IP geolocation service or website (e.g., "https://ipinfo.io" or "https://iplocation.net").
c. Enter your server's public IP address obtained in Step 2 into the provided field or search bar on the website.
d. The service will provide information about the approximate location, including the country. Confirm that the IP address location corresponds to Nigeria.

UNVEILING THE WORLD OF DEVREL FROM NOVICE POV

Mayowa Fajube — Tue, 16 Jan 2024 15:46:18 +0000

The first encounter with the term DevRel was like unlocking a door to a whole new realm within the vast space of information technology. Despite my more than eight years in the industry, this buzzword had eluded me until then, prompting my curious mind to explore the intricacies of a field that seemed to be at the nexus of technology's constant evolution. As I delved into Google searches, blog posts, and sought insights from my mentor, the mystery surrounding DevRel began to unravel, leading me to embark on a mission to demystify this enigmatic term for others who, like me, were initially unfamiliar.

In this journey of discovery, my goal was to shed light on what DevRel truly entails, its significance in the technology space, and the valuable contributions it makes to both organizations and the broader developer community. If you have ever wondered what it takes to bridge the gap between tech companies and the developer community, or if you're contemplating a career in this field, let's delve into the fascinating world of DevRel. Let's explore the essence of DevRel, decipher its role, and unravel the myriad ways it benefits organizations and developers alike.

DevRel, derived from Developer Relations, is an umbrella term that encompasses the strategies and activities used to build and maintain positive relationships between an organization and the developers’ community who use its products, services, or technologies. Far from being a mere buzzword, DevRel represents a strategic approach dedicated to ensuring mutual benefit – where the company's products enhance developers' capabilities, and in turn, developers contribute to the betterment of the company's offerings.

The Essence of DevRel

At its core, DevRel is all about finding the delicate equilibrium between a company and the developers utilizing its tools. It is very pertinent to note that not every organization is a fit for DevRel; it’s specifically tailored for companies offering developer tools. Essentially, DevRel is the bridge that ensures developers have the resources they need to be effective in their roles and continuously improve their workflows.

What DevRel Does for Organizations and Developers

DevTools DevRel professionals are instrumental in creating and maintaining essential tools for developers that use their organization tools or services. This includes documentation, CLIs, APIs, OSS repositories, and example projects. The goal is to empower developers with the right tools to streamline their work and enhance productivity.
Education Knowledge-sharing is at the heart of DevRel. Through guides, tutorials, videos, public speaking engagements, blog posts, Twitter threads, and live streams, DevRel practitioners strive to educate developers. This not only helps developers harness the full potential of the tools provided but also contribute to the overall growth of the developer community.
Community DevRel professionals actively engage in community building by organizing events, creating effective engagement strategies, soliciting testing and early feedback, and advocating for community-driven development. The focus is on fostering a sense of belonging and collaboration among developers.

DevRel Career Opportunities

If the idea of being a bridge between tech companies and developers excites you, there are various career opportunities within the realm of DevRel:

a. Developer Advocate
Serve as the liaison between developers and the company, advocating for their needs and ensuring they have the support and resources required.

b. Community Manager
Facilitate the growth and engagement of developer communities, fostering a sense of belonging and collaboration.

c. Devex Engineer
Craft and optimize the developer experience by creating user-friendly tools and interfaces.

d. Content Creator
Contribute to the education of developers through various mediums like blog posts, videos, and tutorials.

e. Technical Writer
Communicate complex technical information in a clear and concise manner, aiding developers in understanding and utilizing tools effectively.

Skills to Thrive in DevRel

To excel in the world of DevRel, certain skills are invaluable:

• Technical Proficiency
Understand the tools and technologies used by developers.
• Networking Skills
Build and maintain connections within the developer community.
• Teaching Skills
Effectively convey complex information in an understandable manner.
• Media Presence
Utilize various platforms to share knowledge and engage with the community.
• Credibility
Establish trust within the developer community.
• Public Speaking
Articulate ideas and information confidently in public forums.
• Community Management
Foster a sense of community and collaboration.
• Live Streaming
Leverage live streaming for interactive and real-time engagement.
• OSS
Contribute to open-source projects, showcasing commitment to collaboration.
• Event Organization
Plan and execute events that bring developers together.
• Humor
A touch of humor can make technical content more approachable and enjoyable.