DEV Community: Jasper Aurelio Villas

Heroku Dyno Types Compared

Jasper Aurelio Villas — Tue, 14 Oct 2025 14:38:33 +0000

Heroku’s only free dyno option is the Eco dyno, which requires a $5/month flat fee to unlock a shared pool of dyno hours. All other dyno types — Basic, Standard, and Performance — are paid tiers with increasing power and features.

🧱 Heroku Dyno Types Compared

🔹 Eco Dynos

💰 Cost: $5/month flat fee for 1000 dyno hours
💤 Sleeps when idle: Yes (after 30 minutes of inactivity)
⚙️ Resources: Shared
🚫 Autoscaling: Not available

✅ Best for: Hobby projects, prototypes, student apps

🔹 Basic Dynos
💰 Cost: $7/month per dyno
💤 Sleeps when idle: No — stays online
⚙️ Resources: Shared
🚫 Autoscaling: Not available

✅ Best for: Low-traffic apps that need consistent uptime

🔹 Standard Dynos
💰 Cost: $25–$50/month per dyno
💤 Sleeps when idle: No
⚙️ Resources: Dedicated
✅ Autoscaling: Supported
✅ Best for: Production apps with moderate traffic

🔹 Performance Dynos

💰 Cost: $250+/month per dyno
💤 Sleeps when idle: No
⚙️ Resources: Dedicated (high memory and CPU)
✅ Autoscaling: Supported
✅ Best for: Enterprise-grade, high-performance workloads

📝 Note: As of 2025, Heroku requires a payment method to access any dyno tier, including Eco. Free-tier hosting is no longer available without billing info.

🧠 Key Notes
Eco dynos are the only entry-level option with a shared pool of hours. You can run multiple apps on Eco dynos as long as you stay within the 1000-hour limit.

Basic dynos don’t sleep, but you pay per dyno — better for apps that need to stay online 24/7.

Standard and Performance dynos offer more memory, CPU, and features like autoscaling, preboot, and dedicated networking — but they’re priced for serious production use.

Let me know if you want help choosing the right dyno for your Spring Boot or .NET app, or if you’d like to migrate to a platform like Render or Railway that doesn’t require upfront payment.

📚 How to Build a ListView in ASP.NET Core MVC (Book Listing Example) Part 1

Jasper Aurelio Villas — Tue, 14 Oct 2025 11:55:35 +0000

This guide walks through displaying a list of books using a layered architecture with DTOs, services, and a Razor view.

🧱 Step 1: Define the DTO
Create a DTO to shape the data you want to expose in the view.

csharp
namespace library_system_dotnet.Models.Dto.Book
{
    public class BookReadDto
    {
        public int Id { get; set; }
        public string? ISBN { get; set; }
        public string? Title { get; set; }
        public string? Description { get; set; }
        public string? Author { get; set; }
        public int? PublishedYear { get; set; }
        public string? Genre { get; set; }
        public int? CopiesAvailable { get; set; }
        public int? TotalCopies { get; set; }
        public string? Location { get; set; }
        public string? CoverImageUrl { get; set; }
        public DateTime CreatedAt { get; set; }
        public DateTime UpdatedAt { get; set; }
    }
}

🔄 Step 2: Create a Mapper
Use a manual mapper to convert your Book entity to BookReadDto.

csharp
public static class BookMapper
{
    public static BookReadDto ToReadDto(Models.Book book)
    {
        return new BookReadDto
        {
            Id = book.Id,
            ISBN = book.ISBN,
            Title = book.Title,
            Description = book.Description,
            Author = book.Author,
            PublishedYear = book.PublishedYear,
            Genre = book.Genre,
            CopiesAvailable = book.CopiesAvailable,
            TotalCopies = book.TotalCopies,
            Location = book.Location,
            CoverImageUrl = book.CoverImageUrl
        };
    }
}

🧩 Step 3: Define the Service Contract

csharp
public interface IBookService
{
    Task<IEnumerable<BookReadDto>> GetAllAsync(CancellationToken ct = default);
}

⚙️ Step 4: Implement the Service

csharp
public class BookService : IBookService
{
    private readonly AppDbContext _context;
    private readonly IMapper _mapper;

    public BookService(AppDbContext context, IMapper mapper)
    {
        _context = context;
        _mapper = mapper;
    }

    public async Task<IEnumerable<BookReadDto>> GetAllAsync(CancellationToken ct = default)
    {
        var books = await _context.Books.ToListAsync(ct);
        return _mapper.Map<IEnumerable<BookReadDto>>(books);
    }
}

🧭 Step 5: Register Services in Program.cs

csharp
builder.Services.AddDbContext<AppDbContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));

builder.Services.AddControllersWithViews();
builder.Services.AddAutoMapper(typeof(Program));
builder.Services.AddScoped<IBookService, BookService>();

🎯 Step 6: Create the Controller Action

csharp
[HttpGet("books")]
public async Task<ActionResult<IEnumerable<BookReadDto>>> Index()
{
    var books = await _context.Books.ToListAsync();
    var bookDtos = books.Select(BookMapper.ToReadDto);
    return View(bookDtos);
}

Note: You can switch to _bookService.GetAllAsync() once your service is fully wired.

🖼️ Step 7: Create the Razor View (Views/Books/Index.cshtml)

razor
@model IEnumerable<library_system_dotnet.Models.Dto.Book.BookReadDto>

@{
    ViewData["Title"] = "Books";
}

<h1>Books</h1>

<p>
    <a asp-action="Create">Create New</a>
</p>

<table class="table">
    <thead>
        <tr>
            <th>@Html.DisplayNameFor(model => model.ISBN)</th>
            <th>@Html.DisplayNameFor(model => model.Title)</th>
            <th>@Html.DisplayNameFor(model => model.Description)</th>
            <th>@Html.DisplayNameFor(model => model.Author)</th>
            <th>@Html.DisplayNameFor(model => model.PublishedYear)</th>
            <th>@Html.DisplayNameFor(model => model.Genre)</th>
            <th>@Html.DisplayNameFor(model => model.CopiesAvailable)</th>
            <th>@Html.DisplayNameFor(model => model.TotalCopies)</th>
            <th>@Html.DisplayNameFor(model => model.Location)</th>
            <th>@Html.DisplayNameFor(model => model.CoverImageUrl)</th>
            <th>@Html.DisplayNameFor(model => model.CreatedAt)</th>
            <th>@Html.DisplayNameFor(model => model.UpdatedAt)</th>
            <th></th>
        </tr>
    </thead>
    <tbody>
    @foreach (var item in Model)
    {
        <tr>
            <td>@Html.DisplayFor(modelItem => item.ISBN)</td>
            <td>@Html.DisplayFor(modelItem => item.Title)</td>
            <td>@Html.DisplayFor(modelItem => item.Description)</td>
            <td>@Html.DisplayFor(modelItem => item.Author)</td>
            <td>@Html.DisplayFor(modelItem => item.PublishedYear)</td>
            <td>@Html.DisplayFor(modelItem => item.Genre)</td>
            <td>@Html.DisplayFor(modelItem => item.CopiesAvailable)</td>
            <td>@Html.DisplayFor(modelItem => item.TotalCopies)</td>
            <td>@Html.DisplayFor(modelItem => item.Location)</td>
            <td>@Html.DisplayFor(modelItem => item.CoverImageUrl)</td>
            <td>@Html.DisplayFor(modelItem => item.CreatedAt)</td>
            <td>@Html.DisplayFor(modelItem => item.UpdatedAt)</td>
            <td>
                <a asp-action="Edit" asp-route-id="@item.Id">Edit</a> |
                <a asp-action="Details" asp-route-id="@item.Id">Details</a> |
                <a asp-action="Delete" asp-route-id="@item.Id">Delete</a>
            </td>
        </tr>
    }
    </tbody>
</table>

✅ Final Notes

Make sure the view file is named Index.cshtml and placed in /Views/Books/.
Ensure your controller inherits from Controller, not ControllerBase, to support view rendering.
If you use AutoMapper, ensure the profile is registered and the mapping is defined.

Detail Test Case Example

Jasper Aurelio Villas — Wed, 02 Jul 2025 07:03:01 +0000

Test Case: Valid User Login

Test Case ID: TC-001
Related Requirement: FR-Login-01
Module: Authentication
Prepared By: John Doe
Date: 2025-07-02
Version: 1.0
Priority: High

Objective

Verify that a registered user can log in successfully using valid credentials.

Pre-Conditions

The application under test is deployed and accessible.
Test user “testuser@example.com” exists with password “Password123!”
Browser cache and cookies are cleared before test execution.

Test Data

Username: testuser@example.com
Password: Password123!
URL: https://app.example.com/login

Test Steps

Navigate to the login page at the provided URL.
Enter “testuser@example.com” into the Email field.
Enter “Password123!” into the Password field.
Click the “Login” button.

Expected Results

Login page loads within 3 seconds.
Email and Password fields accept input.
Clicking “Login” sends a request and receives a 200 OK response.
User is redirected to the dashboard at https://app.example.com/dashboard..
A welcome message “Welcome, testuser!” is displayed in the header.

Post-Conditions

User session is active and can access authenticated features.
No errors appear in the browser console or server logs.

Additional Test Scenarios to Consider

Invalid login with incorrect password and error message validation
Login throttling or account lockout after multiple failed attempts
Password reset flow and email delivery confirmation
Single sign-on (SSO) or multi-factor authentication (MFA) variations
Performance test for simultaneous login requests (< 5 s response time)

Test Plan and scope Template

Jasper Aurelio Villas — Wed, 02 Jul 2025 06:37:35 +0000

Test Plan and Scope Template
1 Document Control
Document Title:

Project Name:

Version:

Author:

Date:

2 Revision History

Version Date    Author  Changes Made
0.1 YYYY-MM-DD  Your Name   Initial draft
0.2 YYYY-MM-DD  Your Name   Updated scope section

3 Introduction

Describe the purpose of this test plan and how it fits into the overall project lifecycle.

4 Objectives

Verify that the application meets functional requirements.

Ensure performance and security benchmarks are satisfied.

Identify and log defects for resolution.

5 Scope

In-Scope:

List of modules, features, or user stories to be tested

Supported platforms and configurations

Out-of-Scope:

Any features, environments, or non-functional tests explicitly excluded

6 Test Items

ID  Feature/Test Item   Description
TI-001  User Login  Validate login, logout flows
TI-002  Shopping Cart   Add/remove items, checkout

7 Test Approach

Explain your overall strategy (manual vs. automated, risk-based, exploratory).

8 Test Types and Levels

Unit Testing: Developer-driven, local environment

Integration Testing: Interaction between modules

System Testing: End-to-end scenarios

Regression Testing: Re-execute affected tests on new builds

Acceptance Testing: Business stakeholder validation

9 Test Environment

Hardware: Servers, workstations, mobile devices

Software: OS versions, browsers, database versions

Tools: Test management, automation frameworks

10 Roles and Responsibilities

Role    Name    Responsibilities
Test Lead   Alice Smith Plan, coordinate, approve test artifacts
Automation Engineer Bob Jones   Develop and maintain automation scripts
Tester  Carol Lee   Execute test cases, log defects

11 Schedule and Milestones

Milestone   Planned Date    Owner
Test Plan Approval  YYYY-MM-DD  Test Lead
Test Case Development   YYYY-MM-DD  Testers
Test Execution Start    YYYY-MM-DD  Testers
Test Completion YYYY-MM-DD  Test Lead

12 Entry and Exit Criteria

Entry Criteria:

Build deployed to test environment

Test data prepared

Exit Criteria:

All high-priority defects resolved or risk-accepted

Test coverage threshold achieved

13 Risks and Mitigations

Risk: Environment instability

Mitigation: Maintain a backup environment

Risk: Insufficient test data

Mitigation: Create data scripts in advance

14 Test Deliverables

Approved Test Plan

Test cases and checklists

Defect reports

Test summary report

Approval

Role    Name    Signature / Date
Project Manager     
QA Manager

Next, consider adding a filled-in example for one feature or customizing this template for Agile sprints. You might also explore automation coverage metrics or integrate a traceability matrix to link requirements to test cases.

what is the difference betwen mock and injectmocks and when do i use it?

Jasper Aurelio Villas — Mon, 30 Jun 2025 10:11:35 +0000

Here’s the scoop on @Mock vs. @InjectMocks in Mockito, and when you reach for each:

@Mock

What it does: Creates a dummy instance (a “mock”) of a class or interface. All methods on that mock return default values (null/false/0) until you explicitly stub them.
When to use: Anytime your class under test depends on a collaborator you don’t want to exercise for real—e.g., a database client, a web service, a DAO.

java
@Mock
PaymentGateway mockGateway;

This line tells Mockito:

Construct a fake PaymentGateway object.
Track every call to its methods.
Let you stub (when(…).thenReturn(…)) or verify (verify(…)) interactions.

@InjectMocks

What it does: Instantiates your class under test and injects all available mocks (and spies) into it. Mockito tries constructor‐injection first, then setter‐injection, then field‐injection.
When to use: When you want Mockito to wire your class under test with your @Mock dependencies automatically—so you don’t have to new it yourself or write a DI framework for your unit test.

java
@InjectMocks
OrderService service;

This tells Mockito:

Find a way to build OrderService (calls its constructor).
Look at its parameters or fields for types matching your @Mocks (PaymentGateway).
Plug them in so service.gateway == mockGateway.

Putting it together

java
@ExtendWith(MockitoExtension.class)
class OrderServiceTest {
  @Mock               // step 1: create mocks
  PaymentGateway gateway;

  @InjectMocks        // step 2: build real OrderService + inject mock
  OrderService service;

  @Test
  void happyPath() {
    when(gateway.charge(100)).thenReturn(true);   // stub behavior
    assertTrue(service.charge(new Order(100)));   // exercise & assert
  }
}

@Mock → I need a fake; I’ll define its behavior or verify it later.
@InjectMocks → I need a real instance of my SUT (Service Under Test) with those fakes wired in.

Best-practice tips
1 One SUT, many mocks

You usually have one @InjectMocks and several @Mock fields.

2 Limit your mocks

Mock only outwards-facing dependencies. If a collaborator is a plain data object, don’t mock it.

3 Constructor vs. field injection

If your class has a single constructor, Mockito uses it. If you have multiple constructors, consider using @InjectMocks on a field + @Mock fields to make it explicit.

4 Avoid mixing frameworks

Don’t combine Spring’s @Autowired injection with Mockito’s @InjectMocks in the same test—it can get confusing.

When not to use @InjectMocks

If you’re doing a pure unit test of a static helper or POJO, you don’t need it—just new the class directly.
If you prefer manual wiring for clarity, feel free to call new OrderService(mockGateway) yourself in a @BeforeEach.

This is called interaction testing

Jasper Aurelio Villas — Mon, 30 Jun 2025 10:07:53 +0000

what is going on here?


@Test 
void verifyGatewayIsCalledExactlyOnceWithCorrectAmount() { 
 when(mockGateway.charge(123)).thenReturn(true); 
 service.charge(new Order(123)); 

 // confirm we called charge(123) exactly once, no more, no less
 verify(mockGateway, times(1)).charge(123); 
 verifyNoMoreInteractions(mockGateway); 
}

This test is verifying not just the outcome of calling service.charge(...), but how the method interacts with its dependency (PaymentGateway). This is called interaction testing—you're checking that the correct method was called, with the correct data, exactly the right number of times.

Let’s walk through it line by line:

🔧 when(mockGateway.charge(123)).thenReturn(true);
You're stubbing the mock so that if charge(123) is called, it returns true. This ensures the service method doesn’t fail due to an unexpected mock return.

🚀 service.charge(new Order(123));
You're calling the actual method under test. This is where OrderService calls mockGateway.charge(...) internally with the order's amount.

✅ verify(mockGateway, times(1)).charge(123);
This line is the heart of the test: it verifies that the mock's charge(123) method was called exactly once. If it was never called, or called with a different amount, or called more than once—it’ll fail.

🛑 verifyNoMoreInteractions(mockGateway);
This adds an extra safety check: you assert that no other interactions with mockGateway happened besides the charge(123) call. It's like saying: “Only this, and nothing else.”

Why this test is useful
This is a great sanity test to ensure that:

Your OrderService is doing what it should (delegating to the gateway)
You’re using that dependency correctly
No extra or accidental gateway calls sneak in later

This kind of verification is especially important in systems where external calls (e.g. APIs, payments, emails) need to happen precisely once, and not more.

Want to enhance this by verifying inputs with argument matchers, or checking that no calls happen for invalid orders? I’d love to show you!

what is the purpose of aikido security

Jasper Aurelio Villas — Tue, 17 Jun 2025 17:19:53 +0000

The purpose of Aikido Security is to provide developers and organizations with a comprehensive security platform that integrates seamlessly into their workflows to identify, prioritize, and remediate vulnerabilities across their codebase, cloud infrastructure, and runtime environments. It aims to simplify and automate security processes, enabling teams to build secure applications without slowing down development.

Key Objectives of Aikido Security

Protect Codebases:
- Detect vulnerabilities in source code through Static Application Security Testing (SAST).
- Identify exposed secrets like API keys, passwords, and tokens to prevent data breaches.
- Scan open-source dependencies for known vulnerabilities and license risks.
Secure Cloud Infrastructure:
- Analyze Infrastructure-as-Code (IaC) files (e.g., Terraform, Kubernetes) for misconfigurations.
- Monitor cloud environments for compliance with security best practices.
Enhance Runtime Security:
- Protect applications during runtime by blocking critical injection attacks and enforcing API rate limits.
- Monitor live environments for suspicious activity.
Streamline Security Workflows:
- Integrate directly into developer tools like GitHub, GitLab, and CI/CD pipelines to catch vulnerabilities early in the development lifecycle.
- Provide actionable insights and automated fixes to reduce manual effort.
Ensure Compliance:
- Help organizations meet industry standards like SOC 2, ISO 27001, GDPR, and OWASP Top 10 by generating compliance reports and enforcing best practices.
Prioritize and Automate:
- Use AI-powered triage to prioritize critical vulnerabilities and reduce noise.
- Offer auto-remediation for common issues, saving time for developers.

Why Aikido Security Exists
The primary purpose of Aikido Security is to address the growing complexity of modern application development and the increasing risks of cyberattacks. By consolidating multiple security tools into a single platform, Aikido aims to:

Empower developers to take ownership of security without needing deep expertise.
Reduce vulnerabilities in applications and infrastructure before they reach production.
Improve efficiency by automating repetitive security tasks and integrating seamlessly into existing workflows.

Who Benefits from Aikido Security?

Developers: Gain actionable insights and automated fixes directly in their tools (e.g., GitHub, GitLab).
DevOps Teams: Secure CI/CD pipelines and cloud infrastructure without disrupting workflows.
Security Teams: Centralize vulnerability management and ensure compliance with industry standards.
Organizations: Reduce the risk of breaches, improve compliance, and build secure applications faster.

Basic docker app

Jasper Aurelio Villas — Wed, 04 Jun 2025 21:02:07 +0000

Let's start from square one and build a very simple Dockerfile. Imagine Docker as a magic box that lets you package up an application and everything it needs so it runs anywhere. A Dockerfile is like a recipe: it tells Docker which ingredients (base image, files, commands) to combine into your container.

I'll walk you through creating a very basic Dockerfile that uses Nginx to serve some simple HTML. We'll work step by step.

Step 1: Install Docker

Download Docker Desktop: If you haven't installed Docker yet, download and install Docker Desktop.
Confirm Installation: Open your terminal (Command Prompt, PowerShell, or another shell) and

docker --version

If you see Docker's version information, you're ready to go.

Step 2: Set Up Your Project

Create a New Directory: Create a folder for your project. For example, open a terminal and run:


mkdir my-docker-app
cd my-docker-app

Create the Files: You'll need at least 2 files in this folder:
- Dockerfile: Contains your Docker instructions.
- index.html: A simple HTML file that Nginx will serve.

Step 3: Write Your Dockerfile

Open a Text Editor: Use a simple text editor (like Notepad, VS Code, or Notepad++).
Write the Dockerfile Commands: In your Dockerfile, type exactly the following (make sure there’s no extra indentation before the commands):

dockerfile
FROM nginx:alpine
COPY index.html /usr/share/nginx/html/index.html

Explanation:

FROM nginx:alpine: This tells Docker to start with the official lightweight Nginx image, running on Alpine Linux.
COPY index.html /usr/share/nginx/html/index.html: This copies your index.html file from the project folder into Nginx’s default directory for serving web pages.
- Save the File: Save this file as Dockerfile (with no extension) in your my-docker-app folder.

Step 4: Create Your Simple HTML Page
Create the HTML File: In the same my-docker-app folder, create a file called index.html with the following content:

html
<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8">
    <title>Hello Docker!</title>
  </head>
  <body>
    <h1>Hello from Docker!</h1>
    <p>This is a very simple web page served by Nginx in a Docker container.</p>
  </body>
</html>

Save the File: Make sure it is saved as index.html in the same folder as the Dockerfile.

Step 5: Build Your Docker Image

Open Your Terminal: Open a terminal window and navigate to your project folder (my-docker-app).
Build the Image: Run the following command:

bash
docker build -t my-nginx .

What It Does:

docker build tells Docker to build an image.
-t my-nginx tags the image with the name "my-nginx".
The . at the end tells Docker to use the current directory as the build context (where it finds the Dockerfile and index.html).
- Watch the Output: Docker will read your Dockerfile, pull the nginx:alpine image (if not already on your machine), and execute the instructions.

Step 6: Run Your Docker Container

Run the Container: Once the image is built successfully, run the following command:

bash
docker run -d -p 8080:80 my-nginx

Explanation:

docker run starts a new container.
-d runs the container in detached mode (in the background).
-p 8080:80 maps port 80 in the container (where Nginx listens) to port 8080 on your host computer.
my-nginx is the name of the image you built.
- Access the Web Page: Open your web browser and go to http://localhost:8080. You should see your “Hello from Docker!” web page.

Step 7: Explore and Learn More

List Running Containers: In your terminal, run:


bash
docker ps

This command lists all currently running containers.

Stop Your Container: Find the container ID from the docker ps output and run:

bash
docker stop <container_id>

Additional Concepts: Now that you have a basic Dockerfile working, you might explore:
- Volumes: How to persist data outside the container.
- Environment Variables: How to pass configuration into your container.
- Docker Compose: For managing multi-container applications.

Wrap-Up
Congratulations! You've just created a Dockerfile, built a Docker image, and ran a container that serves a web page using Nginx. These steps provide a hands-on introduction, and you can now experiment by modifying the HTML, changing the Nginx configuration, or even trying out different base images.

⚔️ Spring Boot Maven Plugin vs Maven Compiler Plugin — What’s the Difference? When you're working on a Spring B

Jasper Aurelio Villas — Wed, 21 May 2025 09:09:14 +0000

When you're working on a Spring Boot project with Maven, you’ve probably seen both spring-boot-maven-plugin and maven-compiler-plugin in the pom.xml. They sound similar, but they serve completely different purposes.

Let’s break down the difference and when to use each. 👇

🔧 spring-boot-maven-plugin
This plugin is Spring Boot-specific. It helps you package your application into an executable JAR (or WAR), making it easy to deploy and run.

✅ What it does:
Packages your app with an embedded server (like Tomcat)

Allows mvn spring-boot:run for quick local development
Bundles all dependencies into a single runnable JAR

🚫 What it doesn’t do:

It does not control the Java compiler version
It does not support annotation processors like Lombok

🧰 maven-compiler-plugin
This plugin controls how your Java code is compiled — including setting the Java version and handling annotation processing.

✅ What it does:

Sets source and target Java versions (e.g., Java 17)
Adds support for annotation processors like lombok
Essential for compiling clean, version-compatible code

🚫 What it doesn’t do:

It does not package your Spring Boot app
It does not include runtime dependencies or embedded servers

🧠 TL;DR — Use Them Together
Plugin Use it for...
maven-compiler-plugin Compiling your code with correct Java version and annotation processors
spring-boot-maven-plugin Packaging and running your Spring Boot application

Both are essential — just for different parts of the build lifecycle.

✍️ Sample Setup

xml

<build>
  <plugins>

    <!-- Compiler plugin for Java version & Lombok support -->
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-compiler-plugin</artifactId>
      <version>3.11.0</version>
      <configuration>
        <source>17</source>
        <target>17</target>
        <annotationProcessorPaths>
          <path>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.30</version>
          </path>
        </annotationProcessorPaths>
      </configuration>
    </plugin>

    <!-- Spring Boot plugin for building the app -->
    <plugin>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-maven-plugin</artifactId>
    </plugin>

  </plugins>
</build>

🎯 Tip: If you're seeing unexpected behavior in your Spring Boot build or annotation processing isn't working (like with Lombok), double-check that you're not misusing these plugins.

Hope this clears up the confusion! 🚀

Github notification - webhooks

Jasper Aurelio Villas — Thu, 15 May 2025 09:59:25 +0000

To send GitHub notifications (like pushes, issues, pull requests, etc.) to a Discord channel, the most common and reliable way is using a Webhook. Here's how you can set that up:

✅ Step-by-step: GitHub → Discord Webhook
1 Create a Webhook in Discord
Go to your Discord server.

2.Click the gear icon ⚙️ next to the channel you want GitHub messages to go to.

3.Go to Integrations > Webhooks.

4.Click “New Webhook”.

5.Give it a name (e.g., GitHub Bot) and copy the Webhook URL.

6.Save changes.

2 Set up Webhook on GitHub

1.Go to your GitHub repository.

2.Click Settings > Webhooks.

3.Click “Add webhook”.

4.In the Payload URL, paste the Discord Webhook URL.

5.Set Content type to: application/json

6.In “Which events would you like to trigger this webhook?”, choose:

✅ Let me select individual events
Select things like:
- Pushes
- Pull requests
- Issues
- Or whatever else you care about

7.Leave SSL verification enabled (recommended).

8.Click “Add webhook”.

📬 Done!
Now, any selected events (like new pushes or PRs) will show up in your Discord channel.

🛠 Optional: Use GitHub Actions for custom formatting
If you want nicer messages (with embeds, colors, formatting), you can create a GitHub Action to POST custom messages to the Discord webhook. Let me know if you want help with that setup.

Student benefits part 1

Jasper Aurelio Villas — Mon, 12 May 2025 10:49:13 +0000

Congratulations on claiming your free JetBrains Educational License! This license grants you access to the JetBrains All Products Pack, which includes professional-grade IDEs and tools such as IntelliJ IDEA Ultimate, PyCharm Professional, WebStorm, CLion, PhpStorm, DataGrip, Rider, GoLand, RubyMine, and ReSharper Ultimate. These tools are invaluable for developing in various languages and frameworks, including Java, Python, JavaScript, C++, PHP, .NET, Go, and more.

Beyond the core tools, here are additional benefits you can leverage as a student:

🎓 JetBrains Academy
JetBrains Academy offers interactive, project-based learning paths in languages like Java, Python, Kotlin, and more. As a student license holder, you can access many of these courses for free or at a discounted rate.

🎁 Graduation Discount
Upon graduation, JetBrains provides a 40% discount on personal subscriptions for any JetBrains product or the All Products Pack. This discount is valid for up to two years after your student license expires.

🤝 GitHub Student Developer Pack
If you're part of the GitHub Student Developer Pack, you can also claim JetBrains licenses through GitHub, which might offer additional benefits or integrations.

🧑‍🏫 Classroom Licenses
If you're involved in teaching or organizing workshops, JetBrains offers free Classroom Licenses for educational institutions. These licenses are ideal for setting up labs or teaching environments.

🔄 Annual Renewal
Your educational license is valid for one year and can be renewed annually as long as you're still a student. JetBrains typically sends a reminder before expiration, but you can also renew manually through your JetBrains account.

⚠️ Usage Restrictions
Remember, the educational license is strictly for non-commercial use. It's intended for learning, academic projects, and personal development. Using it for commercial purposes violates the license agreement.

Student benefits part 2

Jasper Aurelio Villas — Mon, 12 May 2025 10:48:56 +0000

Yes, aside from JetBrains, Microsoft also offers excellent tools and benefits for students and developers. Here are some key resources you can explore:

🎓 Microsoft Learn for Students
Offers free learning paths and certifications in areas like Azure, .NET, AI, cybersecurity, and more.

Great for building skills and earning badges/certifications recognized by employers.
🔗 learn.microsoft.com/training/students

💼 GitHub Student Developer Pack (includes Microsoft tools)
If you’re a student, you can claim this pack which includes:

Free access to Microsoft Azure for Students, which includes:

$100 in Azure credits (renewable annually)

Free services like App Services, Azure Functions, Cosmos DB, and more.

Free access to Visual Studio Code Spaces, GitHub Codespaces, and Azure DevOps.

🔗 education.github.com/pack

🛠️ Microsoft Developer Tools
Visual Studio Community Edition – A full-featured IDE for .NET, C#, C++, Python, and more (free for students and open-source contributors).

Visual Studio Code – Lightweight code editor with rich extension support (free and open source).

.NET SDK – For building modern web, desktop, mobile, and cloud applications.

🔗 visualstudio.microsoft.com

☁️ Azure for Students
No credit card needed.

Comes with $100 free Azure credit, and access to 25+ free products.

You can deploy websites, train ML models, and run VMs.

🔗 azure.microsoft.com/free/students

💡 Bonus Tip
Also check out Microsoft Reactor events and workshops. They often host free coding bootcamps, webinars, and mentorship sessions.