DEV Community: David

3 Ways to Stop Feeling Like an Imposter in Tech — Even If You’re the Only One Who Looks or Sounds Different

David — Fri, 13 Mar 2026 12:25:30 +0000

I'll never forget that day. During my first job in the United States. First engineering standup.

The team was going around the circle giving updates. One by one, everyone spoke clearly and confidently with their beautiful American accent. When it was my turn, before introducing myself, I didn't know what made me do it, but I felt the need to say something I still remember today:

"I'm sorry for my accent."

Later that day, my manager scheduled a 1:1 with me. And he told me something simple that is with me til this day.

He said:

"Never apologize for your accent or your background, David. Never again."

I said earlier, I didn’t know what made me say that stupid thing. But now I know.

What I was feeling had nothing to do with my engineering ability.

It was imposter syndrome.

As I did, many engineers experience this feeling at some point in their careers. But it becomes even more common when you are different from the majority in the room.

Maybe it's because of your accent.\
Maybe it's the color of your skin.\
Maybe it's your background, your country, or your culture.

You begin to feel like you don't truly belong.

And this feeling shows up in subtle ways.

You hesitate to speak up during meetings.

You overthink every comment during code reviews.

You second-guess your ideas before sharing them.

You stay quiet when your team starts talking about cultural references you don't understand.

You start shrinking yourself without even realizing it.

You have 2 options generally when that happens. You keep going downhill and crash very badly: complete loss of confidence, complete isolation from the rest of the team and organization, and a PIP. Or you don’t make excuses and start attacking the real problem behind that situation.

First, think about what imposter syndrome really costs you.

It costs you opportunities.

It costs you moments where you had the answer but stayed silent.

It costs you visibility.

It costs you energy to constantly try to perform “belonging.”

And over time, that performance becomes exhausting.

The worst part is that imposter syndrome doesn't just affect how you feel.

It affects how much of your potential you actually use.

How many ideas never get shared?

How many leadership opportunities never happen?

How many times do you hold back when you should have stepped forward?

When you think about it, the real danger of imposter syndrome is not that you feel like an imposter.

The danger is that you start acting like one. Because let me be clear with you, whatever you believe in, life will do whatever it takes to prove you right. You believe your accent is an issue; life will agree. You believe you don’t belong to this team, and life will also agree.

But there is some good news: I once heard two powerful ideas that completely changed the way I think about imposter syndrome.

The first comes from Professor Jeffrey Pfeffer.

He said:

"If you want to get rid of imposter syndrome, stop acting like an imposter."

The second comes from Dr. David J. Schwartz, in his book “Think Big”.

"To think confidently, act confidently."

Those two ideas reveal something important. Confidence does not come first. Action comes first. Because action is the most powerful cure for fear. If you want to get rid of imposter syndrome, you need to start acting like someone who belongs. Speak up in meetings.

Share your ideas.

Ask questions.

Walk, talk, and present yourself with confidence.

And most importantly, start building what Dr. David Schwartz calls a positive memory bank.

Collect small proofs that you belong.

Your manager approves your work.

A teammate thanking you for helping them.

A bug you solved.

A feature you delivered.

A moment when someone asked for your help.

Each one of those moments is evidence.

Evidence that you are not an imposter.

You're a capable engineer growing in your craft.

Does it mean imposter syndrome ever completely disappears?

Honestly, I don’t think so.

Even today, I still experience it from time to time.

And if you listen to many successful people (great speakers, leaders, founders, people who have changed industries), you’ll often hear them say the same thing: they still feel imposter syndrome from time to time.

So the goal is not to eliminate that feeling entirely.

The real goal is to reduce how often it controls you.

Think of it as a constant battle.

The more consistently you act confidently, the stronger you become.

Over time, something interesting happens.

That voice of doubt becomes quieter.

It shows up less often.

It becomes less present in your mind.

And even when it does appear, it no longer has the same power over you.

That’s what helped me.

It’s why I went from creating content on a French YouTube channel to starting an English one.

It’s the reason that even when I stutter sometimes, I still keep talking.

I still work on my body language.

I still keep showing up.

And you can do the same.

If you’re interested in working on yourself and surrounding yourself with people focused on growth, you can join my WhatsApp community for self-improvement.

I believe that working on the most important container in the universe (your mind) is the catalyst for building a great career and a meaningful life.

Feel free to join by clicking here.

See you in the next article.

Demystifying readEntity() in Java: How to Actually Read That API Response

David — Sat, 02 Aug 2025 19:58:17 +0000

“The response is empty.”
“But it works in Postman…”
“I don’t get it—it’s a 200!”

If you’ve ever worked with REST APIs in Java, chances are you’ve had one of those “why is my response object null” moments. Welcome to the world of readEntity().

Let me walk you through what it is, how it works, where it bites, and how to use it the right way.

What is readEntity()?

In Java, particularly when using JAX-RS client libraries (like Jersey), you often get an API response wrapped in a Response object.

But a Response is generic—it’s like a sealed envelope. You still need to unwrap it.

That’s where readEntity() comes in.

Response response = client
    .target("https://api.example.com/users/123")
    .request(MediaType.APPLICATION_JSON)
    .get();

User user = response.readEntity(User.class);

Boom. The readEntity(User.class) method tries to deserialize the response body into a User object.

But Here’s the Gotcha
If:

Your class doesn’t match the structure of the response
You forgot to register the right JSON provider
Or the content-type doesn’t match what the server sends

Then readEntity() will return null, or worse… it will silently swallow the problem.

Working Example

Let’s make this real. Suppose you’re calling an API that returns a list of products:

🔽 API Response (JSON):

{
  "items": [
    { "id": 1, "name": "Laptop" },
    { "id": 2, "name": "Keyboard" }
  ]
}

🧱 Java Models:

public class Product {
    public int id;
    public String name;
}

public class ProductResponse {
    public List<Product> items;
}

🚀 The Code:

Client client = ClientBuilder.newClient();
Response response = client
    .target("https://api.example.com/products")
    .request(MediaType.APPLICATION_JSON)
    .get();

ProductResponse productResponse = response.readEntity(ProductResponse.class);

for (Product p : productResponse.items) {
    System.out.println(p.id + " - " + p.name);
}

Important to note:

When readEntity() is called on a Response object to deserialize the response body into a specific Java type (e.g., response.readEntity(MyObject.class)), the JAX-RS (Java API for RESTful Web Services) framework needs to find a suitable MessageBodyReader capable of handling the content type of the response and converting it into the requested Java type.

These MessageBodyReader implementations are registered as providers within the JAX-RS runtime environment (e.g., Jersey, RESTEasy).

Examples of such providers include:

JSON providers: Like Jackson or Gson, which handle the deserialization of JSON data into Java objects.
XML providers: For handling XML data.
Plain text providers: For simple text-based responses.

Without a registered provider that can handle the specific media type and target Java type, calling readEntity() would result in an error like MessageBodyProviderNotFoundException. So the presence and proper registration of these providers are crucial for readEntity() to function correctly.

client.register(JacksonJsonProvider.class);

Pro Tip from My Experience

If you're using readEntity() and getting an empty object or list—even though Postman shows it perfectly—print the raw body to debug, chances are that the content-type in the response differs from the one the provider is supposed to consume (JSON vs x-msgpack for example).

Final Thoughts

The readEntity() method feels like it should "just work"—and most of the time it does. But in edge cases (encoding issues, media type mismatches, incorrect models), you need to dig deeper.

✅ Register your JSON provider
✅ Double-check your response structure
✅ Check that the content-type is the same across the client and the server

Will DeepSeek Shake OpenAI and NVIDIA?

David — Fri, 14 Feb 2025 17:06:23 +0000

AI is moving so fast these days that every big update can feel like a roller coaster. One minute we’re celebrating, and the next we’re freaking out. DeepSeek is the latest buzzworthy name in the mix, and people can’t stop talking about whether it could shake up the likes of OpenAI’s ChatGPT and hardware champs like NVIDIA.

What’s DeepSeek All About?

DeepSeek is showing off a model called R1, which they describe as a “reasoning model.” In plain English, it’s similar to ChatGPT but with one big twist: DeepSeek says it can train this model way cheaper than OpenAI can train GPT. Rumor has it they pulled it off for around $6 million, whereas OpenAI apparently spent north of $100 million on its GPT models.

And here’s the kicker: DeepSeek says they run it all using NVIDIA A100-series chips, which are still pretty powerful but definitely more budget-friendly compared to NVIDIA’s top-tier offerings. Even more intriguing, DeepSeek claims their approach is super memory-efficient, so they don’t need as much hardware muscle (or money) to keep things running smoothly.

Could DeepSeek Overtake the Big Players?

Short version: it’s not that simple. Yes, DeepSeek might offer cheaper and more efficient training, but raw tech is only part of what it takes to topple industry giants. Keep in mind, companies like OpenAI and Apple have built massive brand recognition, and that kind of name power doesn’t just vanish overnight.

Think back to when the iPhone first launched. A bunch of competitors—some from China—quickly released cheaper phones with similar features. But Apple still thrived because it was the original disruptor and had a killer brand. The same could happen with AI: ChatGPT and other US-based tools got there first, captured the world’s attention, and gained trust in the process. That’s not easy to unseat.

Why Should You Care?

Every time there’s a major AI breakthrough, you’ll see new tools and models popping up all over the place. If you try to chase every single one, you’ll end up stressed and behind the curve. Instead, it’s smarter to focus on the fundamentals of AI. If you know what’s going on under the hood, you’ll have an easier time adapting to any fresh developments that come your way.

So, yes, DeepSeek is interesting—and definitely worth watching—but don’t let the hype distract you from mastering the core skills that really matter in the long run.

Your journey to MAANG: Understanding Arrays

David — Wed, 08 Jan 2025 22:33:49 +0000

Arrays are one of the most fundamental data structures in computer science.
They are the building blocks for many more complex data structures. If you want to be good at data structures and algorithms to smash MAANG interviews, you have to understand how each data structure works. And how each one of them handles specific operations such as inserting, retrieving, and deleting.

The Fundamentals

At their core, arrays are contiguous blocks of memory that store elements in sequential order. This simple organization provides two key benefits:

Direct access to any element through indexing
Efficient memory usage through spatial locality

Memory Organization

Arrays operate at a very low level in the computing stack, close to machine language. When you create an array, the system allocates a continuous block of memory large enough to hold all its elements. Each element occupies a fixed amount of space, determined by the data type being stored.

Performance Characteristics

O(1) Access Time

One of the most powerful features of arrays is their constant-time (O(1)) access to elements. When you request an element at index i, the computer can calculate its exact memory location using a simple formula:

element_address = base_address + (index × element_size)

This direct calculation means that accessing any element takes the same amount of time, regardless of the array's size or the element's position.

Cache Locality

Arrays excel at cache locality, providing a significant performance advantage in practice. When the CPU loads an array element from the main memory into its cache, it also loads neighboring elements. This behavior, known as spatial locality, means that subsequent accesses to nearby elements are much faster since they're already in the cache.

Consider this practical example:

Reading from RAM might take 100ns
Reading from CPU cache might take 1ns
When iterating through an array sequentially, most elements after the first will be read from the cache

This cache-friendly behavior makes arrays particularly efficient for operations that process elements sequentially or access nearby elements frequently.

Dynamic Arrays

Modern programming languages typically implement dynamic arrays (like Java's ArrayList or Python's lists or Ruby's Array) that can grow as needed. Here's how they work:

Initial Capacity

Dynamic arrays start with a pre-allocated capacity (for example 8 or 16 elements) rather than size zero. Why? Simply to avoid frequent resizing operations during the array's early use.

Resizing Operations

When an array needs to grow beyond its current capacity:

A new, larger block of memory is allocated (typically 2x the current size)
Existing elements are copied to the new location
The old memory is freed

Even if resizing operations is expensive, its cost is amortized over many operations. So that at the end of the day we still have an average O(1) time for append operations.

How to add Recaptcha to your Laravel App without a package

David — Mon, 02 Dec 2024 05:14:40 +0000

Adding reCAPTCHA to your Laravel application is important to protect your forms from spam and bot attacks. In this article, I'll show you how to implement Google reCAPTCHA v2 in your Laravel authentication system.

Prerequisites

A Laravel application
A Google reCAPTCHA v2 site key and secret key. Here is how to get it quick:

Go to https://developers.google.com/recaptcha and click 'Get Started'

Enter your app information, choose the v2 -> 'Not a robot' option and click 'Submit'.

You will see the site and secret keys. Or you can access it in your console at https://console.cloud.google.com/security/recaptcha

If you want to know the difference between the v3 and the v2 options, ask Google ;)

Step 1: Configure reCAPTCHA Keys

First, add your reCAPTCHA configuration to your .env file:

RECAPTCHA_SITE_KEY=your_site_key_here
RECAPTCHA_SECRET_KEY=your_secret_key_here

Create a new config file config/captcha.php:

<?php

return [
    'sitekey' => env('RECAPTCHA_SITE_KEY'),
    'secret' => env('RECAPTCHA_SECRET_KEY'),
];

Step 2: Create a Validation Trait

Create a new trait to handle reCAPTCHA validation:

<?php

namespace App\Traits;

use Illuminate\Support\Facades\Http;
use Illuminate\Validation\ValidationException;

trait RecaptchaValidation
{
    /**
     * Validate reCAPTCHA token for a specific action
     *
     * @param string $token
     * @param string $action
     * @return bool
     * @throws ValidationException
     */
    protected function validateRecaptcha(string $token, string $action = 'DEFAULT'): bool
    {
        // Retrieve environment variables for Google Cloud Project ID and reCAPTCHA Site Key
        $recaptchaKey = config('captcha.sitekey');
        $project = config('services.google.project_id');

        // Create the reCAPTCHA client and project name
        $options = [
            'credentials' => config('services.google.service_account_credentials'),
        ];

        try {
            $client = new RecaptchaEnterpriseServiceClient($options);
            $projectName = $client->projectName($project);

            // Set the event for the reCAPTCHA assessment
            $event = (new Event())
                ->setSiteKey($recaptchaKey)
                ->setToken($token);

            // Create the assessment
            $assessment = (new \Google\Cloud\RecaptchaEnterprise\V1\Assessment())
                ->setEvent($event);

            $response = $client->createAssessment($projectName, $assessment);

            // Check if the token is valid
            if (!$response->getTokenProperties()->getValid()) {
                $invalidReason = InvalidReason::name($response->getTokenProperties()->getInvalidReason());
                Log::error("reCAPTCHA token invalid: $invalidReason");
                return false;
            }

            // Check if the action matches the expected action
            if ($response->getTokenProperties()->getAction() !== $action) {
                Log::error("reCAPTCHA action mismatch. Action: $action and expected action: " . $response->getTokenProperties()->getAction());
                return false;
            }

            // Check the risk score
            $riskScore = $response->getRiskAnalysis()->getScore();
            Log::info("reCAPTCHA risk score for {$action}: {$riskScore}");

            return $riskScore >= config('app.recaptcha.threshold');

        } catch (\Exception $e) {
            Log::error("reCAPTCHA assessment failed for {$action}: " . $e->getMessage());
            return false;
        }
    }

    /**
     * Validate reCAPTCHA token and throw exception if invalid
     *
     * @param string $token
     * @param string $action
     * @throws ValidationException
     */
    protected function validateRecaptchaOrFail(string $token, string $action = 'DEFAULT'): void
    {
        if (!$this->validateRecaptcha($token, $action)) {
            throw ValidationException::withMessages([
                'g-recaptcha-response' => ['reCAPTCHA verification failed.'],
            ]);
        }
    }
}

Step 3: Add reCAPTCHA to Your Views

Add the reCAPTCHA script to your layout file (e.g., layouts/auth.blade.php):

<!DOCTYPE html>
<html>
<head>
    <!-- Other head elements -->
    <script src="https://www.google.com/recaptcha/enterprise.js" async defer></script>
</head>
<body>
    @yield('content')
</body>
</html>

Add the reCAPTCHA widget to your login form (login.blade.php):

<form method="POST" action="{{ route('login') }}">
    @csrf
    <!-- Email and password fields -->

    <div class="form-group mt-4">
        @error('g-recaptcha-response')
            <span class="text-danger">{{ $message }}</span>
        @enderror
        <div class="g-recaptcha" data-sitekey="{{ config('captcha.sitekey') }}" data-action="LOGIN"></div>
    </div>

    <button type="submit" class="btn btn-primary">
        {{ trans('menu.login') }}
    </button>
</form>

And to your registration form (register.blade.php):

<form method="POST" action="{{ route('register') }}">
    @csrf
    <!-- Name, email, and password fields -->

    <div class="form-group mt-4">
        @error('g-recaptcha-response')
            <span class="text-danger">{{ $message }}</span>
        @enderror
        <div class="g-recaptcha" data-sitekey="{{ config('captcha.sitekey') }}" data-action="REGISTER"></div>
    </div>

    <button type="submit" class="btn btn-primary">
        {{ trans('menu.sign_up') }}
    </button>
</form>

Step 4: Update Controllers

Modify your LoginController.php:

use App\Traits\RecaptchaValidation;

class LoginController extends Controller
{
    use RecaptchaValidation;

    public function login(Request $request)
    {
        // Validate login credentials and reCAPTCHA token
        $this->validateLogin($request);

        $request->validate([
            'g-recaptcha-response' => 'required|string',
        ]);

        // Validate reCAPTCHA
        $this->validateRecaptchaOrFail(
            $request->input('g-recaptcha-response'),
            'LOGIN'
        );

        // Continue with login logic
        if ($this->attemptLogin($request)) {
            return $this->sendLoginResponse($request);
        }

        return $this->sendFailedLoginResponse($request);
    }
}

And your RegisterController.php:

use App\Traits\RecaptchaValidation;

class RegisterController extends Controller
{
    use RecaptchaValidation;

    protected function validator(array $data)
    {
        return Validator::make($data, [
            'name' => ['required', 'string', 'max:255'],
            'email' => ['required', 'string', 'email', 'max:255', 'unique:users'],
            'password' => ['required', 'string', 'min:8', 'confirmed'],
            'g-recaptcha-response' => ['required', 'string'],
        ]);
    }

    public function register(Request $request)
    {
        $this->validator($request->all())->validate();

        // Validate reCAPTCHA before registration
        $this->validateRecaptchaOrFail(
            $request->input('g-recaptcha-response'),
            'REGISTER'
        );

        event(new Registered($user = $this->create($request->all())));

        $this->guard()->login($user);

        return $this->registered($request, $user)
            ?: redirect($this->redirectPath());
    }
}

Et voila! You're welcome.

Any thoughts or feedback on this?
Let me know in the comments.

One thing you need to know about Time testing in Rails

David — Thu, 28 Nov 2024 18:39:02 +0000

Let's say for example that you have an Event model with a start_time and end_time attributes.
We also have an override method on start_time to default it from end_time.

class Event < ApplicationRecord
  def start_time
    super || end_time
  end
end

Consider this simple RSpec test:

it 'compares times correctly' do
  expect(Event.new(end_time: Time.now).start_time).to eq(Time.now)
end

This test fails. Why? You got it, it's because there are two different moments in time.
One way to fix it is to use variables. Like this:

it 'compares times correctly' do
  current_time = Time.now
  expect(Event.new(end_time: current_time).start_time).to eq(current_time)
end

But let's dig deeper. Let's say we have this:

When we debug:

current_time = Time.now
print current_time                    # => 2024-11-28 12:06:25 -0600
print Event.new(end_time: current_time).start_time  # => 2024-11-28 18:06:25 UTC

This spec passes even though both time are different. Why?
Here is why: when RSpec compares times with eq, it compares the actual moments in time, not their string representations or timezone formats.
So 2024-11-28 12:06:25 -0600and 2024-11-28 18:06:25 UTC will be equal.

The Ultimate Lesson

When working with time in Rails:

Remember ActiveRecord converts to UTC automatically
Store time instances in variables for comparisons
Times are equal if they represent the same moment, regardless of timezone

Any thoughts or feedback on this?
Let me know in the comments.

6 steps to deploy your React Next.js app with Github pages

David — Fri, 11 Oct 2024 19:00:34 +0000

Deploying a Next.js app to GitHub Pages can be a bit tricky due to the static nature of GitHub Pages and the dynamic features of Next.js. In this article, I'll walk you through the steps to successfully deploy do it.

Prerequisites

A GitHub account
Node.js and npm installed on your machine
A Next.js project ready to deploy

Step 1: Install gh-pages

npm install gh-pages --save-dev

Step 2: Update next.config.mjs

Next, you need to update your next.config.js (or next.config.mjs) file to handle the base path and asset prefix correctly.

const isProd = process.env.NODE_ENV === 'production';
const nextConfig = {
  reactStrictMode: true,
  images: {
    unoptimized: true, // Disable default image optimization
  },
  assetPrefix: isProd ? '/your-repository-name/' : '',
  basePath: isProd ? '/your-repository-name' : '',
  output: 'export'
};

export default nextConfig;

isProd checks if the NODE_ENV environment variable is set to 'production'. If it is, isProd will be true; otherwise, it will be false.
Conditional assetPrefix and basePath are set to your repository name only if isProd is true. Otherwise, they are set to an empty string for local development.
The images.unoptimized option is set to true to disable the default image optimization, which is not compatible with static exports.

Step 3: Update package.json

Update your package.json to include the homepage field and the deploy scripts.

"homepage": "https://<your-github-username>.github.io/<your-repo-name>",
  "private": true,
  "scripts": {
    "dev": "next dev",
    "build": "next build",
    "start": "next start",
    "lint": "next lint",
    "predeploy": "npm run build",
    "deploy": "gh-pages -d out"
  },

Replace and with your GitHub username and repository name.

Step 4: Deploy Your App

Run npm run predeploy and npm run deploy

These commands will:

Build your project.
Export it to the out directory.
Deploy it to the gh-pages branch on GitHub. Push your work to your GitHub branch before the next step

Step 5: Configure GitHub Pages

Go to your repository on GitHub.
Navigate to Settings > Pages.
Under Source, select the gh-pages branch.
Save the settings.
Add manually the .nojekyll file at the root of the gh-pages branch on GitHub. Learn more about this here.

Step 6: Verify Deployment

After deploying, open your GitHub Pages URL (e.g., https://.github.io/) to verify that your app is live.

And voila!

Feel free to leave any questions or comments below. Happy coding!

How to implement Token-Based Authentication and Authorization in Rails

David — Thu, 30 Nov 2023 06:16:47 +0000

"Technologies change, but the basics are the same". That's what my mentor told me years ago when I asked him how I could be a great software engineer. And it's so true especially when it comes to securing an API with a token-based authentication. No matter the framework you use (Spring, Rails, Laravel, etc.), the principle is the same. So in this blog post, we will discuss how to implement it successfully in your Rails application.

The project:

We want to create a backend API for an app like Hackerrank.
Here is the Database Design and Entity-Relationship Diagram (ERD) for the API.

For the entities, we have:
- Users
- Challenges (Programming questions)
- Submissions (User solutions to challenges)
- Categories (Challenge categories)
- Comments (User comments on challenges)
- Ratings (User ratings for challenges)
- Test Cases (Input and expected output for challenges)

Here are some relationships from the diagram above:
- A User has many Submissions.
- A Challenge belongs to a Category.
- A Challenge has many Test Cases.
- Only admins can create, update, or delete challenges, submissions, categories, or test cases.

Now, let's focus on implementing the authentication and authorization for our API. I assume you already know how to install a rails application focused on an API implementation, how to generate controllers and models.
We will go with the basic MVC architecture provided by Rails.

Install the necessary gems

Add this to your Gemfile:

gem 'bcrypt' # For hashing passwords
gem 'jwt'   # For JWT authentication

bcrypt will be used for password-hashing.
jwt will be used to successfully log the user in and handle authorization.

Create a secret_key_generator file in your initializers folder and paste this:

# config/initializers/secret_key_generator.rb

# Require the SecureRandom module
require 'securerandom'

# Generate a random secret key
secret_key = SecureRandom.hex(32) # Adjust the size as needed (e.g., 64 characters for a 256-bit key)

# Set the secret key as an environment variable
ENV['APP_SECRET_KEY'] = secret_key

Initializers are executed when the Rails application boots. In our case, this initializer generates a random secret key using SecureRandom and sets it as an environment variable (APP_SECRET_KEY). We will use it to decode JWT tokens.

Create the models and migration files

User

class User < ApplicationRecord
  enum role: { default: 0, admin: 1 }
  validates :name, presence: true
  validates :email, presence: true
  validates_uniqueness_of :email
  validates :password, presence: true, length: { minimum: 6 }

  has_secure_password

  def admin?
    role == 'admin'
  end
end

class CreateUsers < ActiveRecord::Migration[7.1]
  def change
    create_table :users do |t|
      t.string :name
      t.string :email
      t.string :password_digest
      t.integer :role

      t.timestamps
    end
  end
end

Category

class Category < ApplicationRecord
    validates :title, presence: true
    validates :description, allow_blank: true

    has_many :challenge_categories
    has_many :challenges, through: :challenge_categories
end

class CreateCategories < ActiveRecord::Migration[7.1]
  def change
    create_table :categories do |t|
      t.string :title
      t.text :description, :null => true

      t.timestamps
    end
  end
end

Challenge

class Challenge < ApplicationRecord
    validates :title, presence: true
    validates :description, presence: true

    has_many :challenge_categories
    has_many :categories, through: :challenge_categories
end

class CreateChallenges < ActiveRecord::Migration[7.1]
  def change
    create_table :challenges do |t|
      t.string :title
      t.text :description

      t.timestamps
    end
  end
end

And since there is a many-to-many relationship between Challenge and Category, let's add the pivot table:

class CreateChallengeCategories < ActiveRecord::Migration[7.1]
  def change
    create_table :challenge_categories do |t|
      t.references :challenge, null: false, foreign_key: true
      t.references :category, null: false, foreign_key: true

      t.timestamps
    end
  end
end

Add the routes

resources :users, only: [:create]
  namespace :auth do
    post '/login', to: 'sessions#create'
    delete '/logout', to: 'sessions#destroy'
  end
  resources :challenges
  post '/admin', to: 'users#add_admin'

You may have guessed it, but you will need to create a controllers/auth folder. I'll explain why in a few minutes.

Authentication logic

Add this to your users_controller file:

class UsersController < ApplicationController
  def create
    @user = User.new(user_params)
    if @user.save
      render json: { message: 'Registration successful. Please log in.' }, status: :created
    else
      render json: { errors: @user.errors.full_messages }, status: :unprocessable_entity
    end
  end

  def add_admin
    email = params[:email]

    if email.blank?
      render json: { errors: 'Email parameter is required' }, status: :unprocessable_entity
    end
    @user = User.find_by(email: email)
    if @user.nil?
      render json: { errors: 'No user with that Email found' }, status: :not_found
    else
      @user.update_column(:role, 1)
      render json: { message: 'User is now an admin' }, status: :ok
    end
  end

  private

  def user_params
      params.require(:user).permit(:name, :email, :password, :password_confirmation)
  end

end

That controller is simply responsible for creating new users and admins.

Create a helpers/token_helper file in your app folder and add this code:

# app/helpers/token_helper.rb
module TokenHelper
  def decode_token(token)
    JWT.decode(token, ENV['APP_SECRET_KEY'], true, algorithm: 'HS256')[0]
  rescue JWT::DecodeError
    nil
  end
end

And include it in your application_controller:

include TokenHelper

Now let's create a sessions_controller in our auth folder and add this code:

# app/controllers/sessions_controller.rb

class Auth::SessionsController < ApplicationController
  def create
    user = User.find_by(email: params[:email])

    if user && user.authenticate(params[:password])
        # Set the expiration time (e.g., 1 hour from now)
        expiration_time = Time.now.to_i + (3600 * 3) # 3600 seconds = 1 hour

        # Create the payload
        payload = { 
            user_id: user.id,
            exp: expiration_time # This sets the expiration time
        }
        token = JWT.encode(payload, ENV['APP_SECRET_KEY'], 'HS256')
        render json: { message: 'Logged in successfully', token: token }
    else
        render json: { error: 'Invalid credentials' }, status: :unauthorized
    end
  end

  def destroy
    # Invalidate the JWT token by marking it as expired or revoking it.
    token = extract_token_from_request
    if token
      begin
        # Try to decode the token to check its validity
        payload, _ = JWT.decode(token, ENV['APP_SECRET_KEY'], true, algorithm: 'HS256')

        # At this point, the token is considered valid
        # Add expiration to the payload to mark the token as invalid
        payload['exp'] = Time.now.to_i
        new_token = JWT.encode(payload, ENV['APP_SECRET_KEY'], 'HS256')

        render json: { message: 'Logged out successfully' }
      rescue JWT::DecodeError
        # JWT::DecodeError is raised when the token is not valid
        render json: { message: 'You need to sign in or sign up before continuing' }, status: :unauthorized
      end
    else
      render json: { message: 'No token found' }, status: :unprocessable_entity
    end
  end

  private

  def extract_token_from_request
    request.headers['Authorization']&.split&.last
  end
end

What we did there basically is generate a new token when a user logs in and invalidate a token when a user logs out. Remember, the token is used to check if a user session is valid or not. If you don't know how JWT tokens work, check the documentation here.

Now if you request POST /users and POST /login with the correct parameters using Postman, it should work.

Add the Challenge and Category controllers:

class ChallengesController < ApplicationController
    before_action :set_challenge, only: [:show, :update, :destroy]
    before_action :authorize_user, except: [:index, :show]
    before_action :authorize_admin, except: [:index, :show]

    def index
        @challenges = Challenge.all
        render json: @challenges
    end

    def show
        render json: @challenge
    end

    def create
        @challenge = Challenge.new(challenge_params)
        if @challenge.save
            render json: @challenge, status: :created
        else
            render json: @challenge.errors, status: :unprocessable_entity
        end
    end

    def update
        if @challenge.update(challenge_params)
            render json: @challenge
        else
            render json: @challenge.errors, status: :unprocessable_entity
        end
    end

    def destroy
        @challenge.destroy
        render json: { message: 'Challenge was successfully deleted' }
    end

    private

    def set_challenge
        @challenge = Challenge.find(params[:id])
    end

    def challenge_params
        params.require(:challenge).permit(:title, :description, category_ids: [])
    end
end

class CategoriesController < ApplicationController
  before_action :set_category, only: [:show, :update, :destroy]
  before_action :authorize_user, except: [:index, :show]
  before_action :authorize_admin, except: [:index, :show]

  def index
    @categories = Category.all
    render json: @categories
  end

  def show
    render json: @category
  end

  def create
    @category = Category.new(category_params)
    if @category.save
      render json: @category, status: :created
    else
      render json: @category.errors, status: :unprocessable_entity
    end
  end

  def update
    if @category.update(category_params)
      render json: @category
    else
      render json: @category.errors, status: :unprocessable_entity
    end
  end

  def destroy
    @category.destroy
    head :no_content
  end

  private

  def set_category
    @category = Category.find(params[:id])
  end

  def category_params
    params.require(:category).permit(:title, :description, challenge_ids: [])
  end
end

As you can see, both controllers check if the user session is valid before executing some controller actions (create, update, delete). They are doing so with authorize_user and authorize_admin.
Add those methods in your application_controller:

def authorize_user
        token = request.headers['Authorization']&.split(' ')&.last
        payload = decode_token(token)
        if payload.nil?
            render json: { error: 'Unauthorized' }, status: :unauthorized
        else
            @current_user = User.find(payload['user_id'])
        end
    end

    def authorize_admin
        if !@current_user || !@current_user.admin?
            render json: { error: 'Unauthorized' }, status: :unauthorized
        end
    end

Now, try to create a challenge without logging in and you should get an Unauthorized message. Log in, set the current user as admin, try again and it should work.

Et voila, let me know in the comments section if you found this article helpful.

API security: How to implement Authentication and Authorization with AWS Cognito in Spring Boot

David — Thu, 23 Nov 2023 01:14:15 +0000

When I implemented the authentication and authorization process with Spring Security 6, I didn't find any helpful and updated articles on this matter. So, I'll save you some time and show you how you can do that. In this blog post, we'll focus on implementing the registration, login processes, and the JWT Token authorization with AWS Cognito. You're welcome, let's get started!

What is AWS Cognito

Amazon Cognito is a product from Amazon Web Services (AWS) that controls user authentication and access for mobile apps. It's an identity platform for web and mobile apps.

Cognito's main features include:

User directory
Authentication server
Authorization service
User sign-up and authentication
Temporary security credentials
Session management
Forgotten password functionality

Cognito also provides a secure identity store that can scale to millions of users. This store securely stores user profile data for users who sign up directly and for federated users who sign in with external identity providers.

You can learn more on their FAQ page.

The project

Let's build an app like pramp.com.

Users can obviously register and log in.
Admin can create many questions
Default users can create many interview sessions
Each interview session has 2 questions from the same type

Here is the ERD for more understanding

I will assume that you already know how to install Spring Boot. Just make sure that you have the following dependencies in your pom.xml file

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        <dependency>
            <groupId>com.amazonaws</groupId>
            <artifactId>aws-java-sdk-cognitoidp</artifactId>
            <version>1.11.934</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.26</version>
        </dependency>
<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-oauth2-resource-server</artifactId>
        </dependency>

Let's break down each dependency:

spring-boot-starter-security: is part of the Spring Boot framework and provides a comprehensive set of security-related features.
- Authentication: Helps in user authentication.
- Authorization: Supports role-based and permission-based access control.
- Common security configurations out of the box.
- Integration with various authentication providers.
aws-java-sdk-cognitoidp: is part of the AWS SDK for Java and specifically focuses on Amazon Cognito Identity Pools.
- Provides Java APIs for interacting with Amazon Cognito Identity Pools.
- Enables your Java application to integrate with Amazon Cognito for user management and authentication.
- Includes functionality for user sign-up, sign-in, and other identity-related operations.
mysql-connector-java: is the official JDBC driver for MySQL databases, allowing Java applications to connect and interact with MySQL databases. Because you will need to create a local database. Look up online on how to do it with IntelliJ.
spring-boot-starter-oauth2-resource-server: is part of Spring Boot and is designed to set up an OAuth 2.0 Resource Server.
- Configures the application to act as a resource server, capable of processing and validating OAuth 2.0 access tokens.
- Allows the application to secure its resources and endpoints using OAuth 2.0 authentication and authorization.

The architecture:

We'll use the Domain Driven Design principles:

controller: For handling HTTP requests and defining endpoints.
service: For implementing business logic.
repository: For data access to interact with databases like DynamoDB.
model: For defining domain entities and value objects.
requests: We could use Data Transfer Objects (DTO) that encapsulate data passed between layers. But for this project, we will use request classes, which serve as a form of DTO. Those classes define the structure of the data you expect to receive in your HTTP request.
config: For Spring configuration classes.
security: For security-related classes.

Here is what your src/main folder should look like:

├── java
│   └── com
│       └── example
│           └── chat_app
│               ├── ChatAppApplication.java
│               ├── config
│               │   ├── CognitoConfig.java
│               │   └── SecurityConfig.java
│               ├── controller
│               │   ├── QuestionController.java
│               │   └── UserController.java
│               ├── dto
│               ├── model
│               │   ├── Question.java
│               │   └── User.java
│               ├── repository
│               │   ├── QuestionRepository.java
│               │   └── UserRepository.java
│               ├── requests
│               │   ├── CreateQuestionRequest.java
│               │   ├── UserLoginRequest.java
│               │   └── UserRegistrationRequest.java
│               ├── security
│               └── service
│                   ├── CognitoService.java
│                   ├── QuestionService.java
│                   ├── QuestionServiceImpl.java
│                   ├── UserService.java
│                   └── UserServiceImpl.java
└── resources
    ├── application.properties
    ├── simple.priv
    ├── static
    └── templates

Registration and Login

Create a Cognito user pool: check this tutorial or this video to do it.
Add the following to your application.properties file

spring.security.oauth2.client.registration.cognito.client-id=your_cognito_app_client_id
spring.security.oauth2.client.registration.cognito.client-secret=your_cognito_app_client_secret
spring.security.oauth2.client.registration.cognito.scope=openid
spring.security.oauth2.client.provider.cognito.issuer-uri=https://cognito-idp.us-east-2.amazonaws.com/us-east-2_EDjR6VYYS https://cognito-idp.<REGION>.amazonaws.com/<POOL Id>
aws.accessKeyId=aws_access_key
aws.secretKey=aws_secret_key
aws.region=aws_region
spring.datasource.url=database_uri
spring.datasource.username=database_username
spring.datasource.password=database_password

Add the controller actions for your login and register routes in the UserController:

@Autowired
    private UserServiceImpl userService;

    @PostMapping(value = "/register", consumes = {"application/json"})
    public ResponseEntity<User> registerUser(@Valid @RequestBody UserRegistrationRequest userRegistrationRequest) {
        System.out.println(userRegistrationRequest);
        // Perform user registration
        User registeredUser = userService.registerUser(userRegistrationRequest);
        if (registeredUser != null) {
            return ResponseEntity.ok(registeredUser);
        } else {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }

    }

    @PostMapping("/login")
    public ResponseEntity<User> loginUser(@Valid @RequestBody UserLoginRequest userLoginRequest) {
        // Perform user login
        User loggedInUser = userService.loginUser(userLoginRequest.getUsername(), userLoginRequest.getPassword());

        if (loggedInUser != null) {
            // Successful login
            return ResponseEntity.ok(loggedInUser);
        } else {
            // Invalid login, return an appropriate response
            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
        }
    }

Add the registerUser and loginUser methods in the UserService interface and implement them in the UserServiceImpl class:

public interface UserService {
    User registerUser(UserRegistrationRequest userRegistrationRequest);
    User loginUser(String username, String password);
}

@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private UserRepository userRepository;

    @Autowired
    private CognitoService cognitoService;

    @Override
    public User registerUser(UserRegistrationRequest userRegistrationRequest) {
        String username = userRegistrationRequest.getUsername();
        String password = userRegistrationRequest.getPassword();
        String email = userRegistrationRequest.getEmail();
        // Register the user with Amazon Cognito
        return cognitoService.registerUser(username, email, password);
    }

    @Override
    public User loginUser(String username, String password) {
        return cognitoService.loginUser(username, password);
    }
}

Implement the registration and login logic in the CognitoService:

@Value("${spring.security.oauth2.client.registration.cognito.client-id}")
    private String clientId;

    @Value("${spring.security.oauth2.client.registration.cognito.client-secret}")
    private String clientSecret;

    @Value("${spring.security.oauth2.client.registration.cognito.scope}")
    private String scope;

    @Value("${spring.security.oauth2.client.provider.cognito.issuer-uri}")
    private String issuerUri;

    @Autowired
    private AWSCognitoIdentityProvider cognitoIdentityProvider;

    @Autowired
    private UserRepository userRepository;

    public User registerUser(String username, String email, String password) {
        // Set up the AWS Cognito registration request
        SignUpRequest signUpRequest = new SignUpRequest()
                .withClientId(clientId)
                .withUsername(username)
                .withPassword(password)
                .withUserAttributes(
                        new AttributeType().withName("email").withValue(email)
                );

        // Register the user with Amazon Cognito
        try {
            SignUpResult signUpResponse = cognitoIdentityProvider.signUp(signUpRequest);

            User registeredUser = new User();
            registeredUser.setUsername(username);
            registeredUser.setEmail(email);
            registeredUser.setPassword(password);

            return userRepository.save(registeredUser);

        } catch (Exception e) {
            throw new RuntimeException("User registration failed: " + e.getMessage(), e);
        }
    }

    public User loginUser(String username, String password) {
        // Set up the authentication request
        InitiateAuthRequest authRequest = new InitiateAuthRequest()
                .withAuthFlow("USER_PASSWORD_AUTH")
                .withClientId(clientId)
                .withAuthParameters(
                        Map.of(
                                "USERNAME", username,   // Use email as the username
                                "PASSWORD", password
                        )
                );

        try {
            InitiateAuthResult authResult = cognitoIdentityProvider.initiateAuth(authRequest);
            System.out.println(authResult);
            AuthenticationResultType authResponse = authResult.getAuthenticationResult();

            // At this point, the user is successfully authenticated, and you can access JWT tokens:
            String accessToken = authResponse.getAccessToken();
            String idToken = authResponse.getIdToken();
            String refreshToken = authResponse.getRefreshToken();

            // You can decode and verify the JWT tokens for user information

            User loggedInUser = new User();
            loggedInUser.setUsername(username);
            loggedInUser.setAccessToken(accessToken); // Store the token for future requests

            return loggedInUser;

        } catch (Exception e) {
            throw new RuntimeException("User login failed: " + e.getMessage(), e);
        }
    }

Create the AWSCognitoIdentityProvider bean in your CognitoConfig class:

@Configuration
public class CognitoConfig {

    @Value("${aws.accessKeyId}")
    private String accessKey;

    @Value("${aws.secretKey}")
    private String secretKey;

    @Value("${aws.region}")
    private String region;


    @Bean
    public AWSCognitoIdentityProvider cognitoIdentityProvider() {
        BasicAWSCredentials awsCredentials = new BasicAWSCredentials(accessKey, secretKey);

        return AWSCognitoIdentityProviderClientBuilder.standard()
                .withCredentials(new AWSStaticCredentialsProvider(awsCredentials))
                .withRegion(Regions.fromName(region))
                .build();
    }
}

Implement the UserLoginRequest and UserRegistrationRequest classes:

public class UserLoginRequest {
    @NotBlank(message = "Username is required")
    private String username;

    @NotBlank(message = "Password is required")
    private String password;

    public String getUsername() {
        return username;
    }
    public String getPassword() {
        return password;
    }
}

public class UserRegistrationRequest {

    @NotBlank(message = "Username is required")
    private String username;

    @NotBlank(message = "Password is required")
    private String password;

    @Email(message = "Invalid email address")
    private String email;

    // Getters and setters for the fields

    public String getUsername() {
        return username;
    }
    public String getPassword() {
        return password;
    }
    public String getEmail() {
        return email;
    }

}

Implement the User model:

@Entity
@Table(
        name = "users",
        uniqueConstraints = {
                @UniqueConstraint(columnNames = "email"),
                @UniqueConstraint(columnNames = "username")
        }
)
public class User {
    @jakarta.persistence.Id
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;

    @Column
    @NotEmpty(message = "Username is required")
    @Size(min = 5, max = 50)
    private String username;

    @Column
    @NotEmpty(message = "Email is required")
    private String email;

    @Column
    @NotEmpty(message = "Password is required")
    private String password;

    @Transient
    private String accessToken;

    public void setAccessToken(String accessToken) {
        this.accessToken = accessToken;
    }

    public String getAccessToken() {
        return accessToken;
    }

    public String getUsername() {
        return username;
    }

    public String getEmail() {
        return email;
    }

    public String getPassword() {
        return password;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getId() {
        return id;
    }

Finally, add this to your SecurityConfig class:

@Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {

        http.authorizeHttpRequests(
            requests -> requests
                    .requestMatchers("/admin")
                    .hasAnyRole("Admin", "Editor")
                    .requestMatchers("/login")
                    .permitAll()
                    .requestMatchers("/register")
                    .permitAll()
                    .requestMatchers("/logout")
                    .permitAll()
                    .anyRequest()
                    .authenticated()
        );

        http.csrf(AbstractHttpConfigurer::disable);

        return http.build();
    }

Now start your Spring app, open Postman, and ensure your app is connected to your database. Run the POST /register request and you should get the following result:

{
    "id": <user_id>,
    "username": <username>,
    "email": <email>,
    "password": <password>,
    "accessToken": null
}

You should also be able to see the new user in your AWS Cognito app.
Run the POST /login request and you should get the following result:

{
    "id": <user_id>,
    "username": <username>,
    "email": <email>,
    "password": null,
    "accessToken": <access_token>,
}

Don't forget to confirm manually the user account from the AWS Cognito. You can look up the documentation to see how you can also do it using Spring Boot.

Verifying authorization

Spring Security supports protecting endpoints by using two forms of OAuth 2.0 Bearer Tokens:

JWT
Opaque Tokens
We are going to use JWT. You can learn more about it in the Spring documentation.
Spring Boot will do it by checking the token provided by our client (in this case, Postman), verifying if it's a valid Cognito token, and either returning success or unauthorized statuses.
For more
Update your Securityconfig

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    private final JWSAlgorithm jwsAlgorithm = JWSAlgorithm.RS256;

    private final JWEAlgorithm jweAlgorithm = JWEAlgorithm.RSA_OAEP_256;

    private final EncryptionMethod encryptionMethod = EncryptionMethod.A256GCM;

    @Value("${spring.security.oauth2.resourceserver.jwt.jwk-set-uri}")
    URL jwkSetUri;

    @Value("${sample.jwe-key-value}")
    RSAPrivateKey key;

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {

        http.authorizeHttpRequests(
            requests -> requests
                    .requestMatchers("/admin")
                    .hasAnyRole("Admin", "Editor")
                    .requestMatchers("/login")
                    .permitAll()
                    .requestMatchers("/register")
                    .permitAll()
                    .requestMatchers("/logout")
                    .permitAll()
                    .anyRequest()
                    .authenticated()
        )
        .oauth2ResourceServer((oauth2) -> oauth2.jwt(withDefaults()));

        http.csrf(AbstractHttpConfigurer::disable);

        return http.build();
    }

    @Bean
    JwtDecoder jwtDecoder() {
        return new NimbusJwtDecoder(jwtProcessor());
    }

    private JWTProcessor<SecurityContext> jwtProcessor() {
        JWKSource<SecurityContext> jwsJwkSource = new RemoteJWKSet<>(this.jwkSetUri);
        JWSKeySelector<SecurityContext> jwsKeySelector = new JWSVerificationKeySelector<>(this.jwsAlgorithm,
                jwsJwkSource);

        JWKSource<SecurityContext> jweJwkSource = new ImmutableJWKSet<>(new JWKSet(rsaKey()));
        JWEKeySelector<SecurityContext> jweKeySelector = new JWEDecryptionKeySelector<>(this.jweAlgorithm,
                this.encryptionMethod, jweJwkSource);

        ConfigurableJWTProcessor<SecurityContext> jwtProcessor = new DefaultJWTProcessor<>();
        jwtProcessor.setJWSKeySelector(jwsKeySelector);
        jwtProcessor.setJWEKeySelector(jweKeySelector);

        return jwtProcessor;
    }

    private RSAKey rsaKey() {
        RSAPrivateCrtKey crtKey = (RSAPrivateCrtKey) this.key;
        Base64URL n = Base64URL.encode(crtKey.getModulus());
        Base64URL e = Base64URL.encode(crtKey.getPublicExponent());
        return new RSAKey.Builder(n, e).privateKey(this.key).keyUse(KeyUse.ENCRYPTION).build();
    }
}

Add this line to your application.properties file:

spring.security.oauth2.resourceserver.jwt.jwk-set-uri=https://cognito-idp.<region>.amazonaws.com/<userPoolID>/.well-known/jwks.json
sample.jwe-key-value: classpath:simple.priv

Create a simple.priv file and paste the following key. Or create your own RSA key:

That's it. Now let's say you want to create a question. Simply create the endpoint and add the controller action in the QuestionController:

@Autowired
    private QuestionServiceImpl questionService;

    @PostMapping(value = "/questions", consumes = {"application/json"})
    public ResponseEntity<Question> createQuestion(@AuthenticationPrincipal Jwt jwt, @RequestBody CreateQuestionRequest request) {
        Question createdQuestion = questionService.createQuestion(jwt, request);
        return ResponseEntity.status(HttpStatus.CREATED).body(createdQuestion);
    }

@AuthenticationPrincipal is used to inject the JSON Web Token (JWT) directly into the method parameter and check if it's valid one.
I'll let you implement the logic in the service, request, repository and model. Ciao.

Fix docker rails error: tmp/pids/server.pid Not Cleaned Up

David — Fri, 17 Nov 2023 18:20:51 +0000

If you work on a Rail app with Docker, you may encounter a docker rails error that says "A server is already running (pid: pid_number, file: /app/tmp/pids/server.pid)".
I was frustrated when that happened to me, so I decided to write this article and show you how I fixed it. It's pretty simple in reality. Let's go!

create a docker-entrypoint.sh file at the root of your project. This is what mine looks like

#!/bin/bash
set -e

if [ -f tmp/pids/server.pid ]; then
  rm tmp/pids/server.pid
fi

exec bundle exec "$@"

add this to your Dockerfile, just before starting your server

Start the Rails server

ENTRYPOINT ["docker-entrypoint.sh"]
CMD ["rails", "server", "-b", "0.0.0.0"]

Run docker-compose up again and everything should be ok.

7 JavaScript Concepts You Should Know Before Learning React

David — Fri, 04 Aug 2023 16:14:13 +0000

Maybe you don't know, but I'm someone who believes in building strong foundations. And, as we all know, ReactJS is a powerful JavaScript framework. But some developers tend to dive straight into it without grasping the basics. Huge mistake. That's why in this article, I'll cover some essential JavaScript concepts that will give you a strong foundation for learning and mastering React. Let's get started.

Destructuring

Destructuring allows you to extract values from arrays and objects and assign them to variables. In React, you'll often see destructuring used to extract properties from props and state. Here's an example:

const MyComponent = ({ name, age }) => {
  return (

        My name is {name}, and I am {age} years old.

  );
};

Spread Operators

As the name said it, they allow you to spread the elements of an array or object into a new array or object. Like this:

const arr1 = [1, 2, 3];
const arr2 = [...arr1, 4, 5, 6];
console.log(arr2); // [1, 2, 3, 4, 5, 6]

Arrow Functions

One of my favorite concepts in JavaScript ES6. It provides a concise syntax for writing functions in JavaScript. They're commonly used in React to define event handlers and component methods.

const MyComponent = () => {
  const handleClick = () => {
    console.log('Button clicked');
  };

  return (

        Click me

  );
};

Immutability

Immutability is a critical concept to understand when working with React. The goal is that we want to avoid directly mutating the state object, instead creating new copies of it with updated values. That way, React's internal state management and rendering mechanisms work correctly:

const [counter, setCounter] = useState(0);

const incrementCounter = () => {
  setCounter(prevCounter => prevCounter + 1);
};

Let me explain the code above: I'm using the useState hook in React to create a new counter state variable. I'm also using the setCounter function to update the counter value, but I'm doing so immutably by passing a function to the setCounter function that returns a new value based on the previous value.

Higher-Order Functions

Higher-order functions are functions that either take other functions as arguments or return functions. They're commonly used in React to provide reusable logic and to create custom hooks:

const withLogger = (WrappedComponent) => {
  return function(props) {
    console.log('Rendered: ', WrappedComponent.name);
    return ;
  };
};

Here the higher-order function is withLogger that takes a WrappedComponent as an argument. The withLogger function returns a new function that logs the name of the WrappedComponent and passes its props down to it.

Promises and Async/Await

They are essential concepts in modern JavaScript and are commonly used in React to handle asynchronous operations like fetching data from an API. Here's an example:

const fetchData = async () => {
  const response = await fetch('https://api.example.com/data');
  const data = await response.json();
  return data;
};

Modules and Imports/Exports

Modules are a way to organize code in JavaScript, separating it into different files or modules. Imports and exports are used to share code between modules. Check the following example: I'm defining a module called utils.js that exports a function called add. Then importing the add function into a different module, app.js, using the import statement.

// utils.js
export const add = (a, b) => a + b;

// app.js
import { add } from './utils';
console.log(add(1, 2)); // 3

That's it! Now go ahead and start learning those concepts if you didn't do it yet!

💻 10 essential Java Development tools you should learn

David — Thu, 03 Aug 2023 15:41:00 +0000

Java is well-known for its extensive use for web, enterprise, and mobile applications. The field of web development moves fast and staying ahead of the curve is a necessity. Here are 10 essential web development tools that a Java developer shouldn't miss. These tools are meant to help you streamline your workflow, debug with ease, speed up productivity, and keep up with the pace of web development.

1) IntelliJ IDEA - IntelliJ IDEA is a popular Java IDE that is widely used by Java developers. It provides rich features like code completion, debugging, and testing. It also supports web development workflows and enables plugin integration with other software tools.

2) Spring Framework - Spring Framework is a widely used and mature open-source Java framework for building web applications. It provides a vast array of features such as data access, messaging, and security. It is flexible, well-supported, and has an active community.

3) Postman - Postman is a tool for testing REST APIs. It is easy to use and can save a considerable amount of time when testing and debugging APIs. It provides a collection of features such as saving requests, responses, and environments.

4) Git - Git is a free, open-source distributed version control system. It provides a way to track changes made to the source code. It facilitates collaboration among developers and allows for easy branching, merging, and reverting changes.

5) Docker - Docker is a containerization platform that is used to create, deploy, and run applications. It provides a simple way to package the application with all its dependencies into a container. Docker containers are lightweight and can run anywhere, providing a seamless deployment process.

6) Sonar - Sonar is a continuous code quality tool used to analyze source code for bugs, vulnerabilities, and other technical debt. It provides static analysis, code coverage, and duplication detection. Sonar integrates well with Eclipse and other IDEs.

7) Apache Maven - Apache Maven is a build automation tool used primarily for Java projects. It is used to compile, test, and package Java code into JAR or WAR files. It can manage dependencies, integrate with other build systems, and automate the build process.

8) JIRA - JIRA is a project management tool used by many development teams to manage bugs, issues, and tasks. It integrates well with other tools like Git and Jenkins.

9) Apache Tomcat - Apache Tomcat is a widely used Java servlet container. It is used to run Java web applications. It provides a simple way to deploy, test and run web applications, and supports multiple operating systems.

10) Selenium - Selenium is a tool for web browser automation, which means you can test your web pages like both JSP and static pages written using HTML and JavaScript using Selenium.

Let me know in the comments section what other tools Java developers should know in 2023