DEV Community: JohnDivam - justnote8.com

JustNote8.com: The Free Online Notepad That Turns Your Ideas into Visual Flow Notes

JohnDivam - justnote8.com — Fri, 16 Oct 2026 08:05:00 +0000

Most note-taking apps give you a blank page and a blinking cursor. That works for a grocery list, but not for real thinking. Ideas don’t arrive in straight lines. They branch, connect, and loop back. JustNote8 is a free online notepad built for exactly that: it lets you organize your thoughts visually, as connected flow nodes on an open canvas.

What Is JustNote8.com?

JustNote8 is a visual notepad that runs in your browser. Instead of stacking text line after line, you place your ideas as nodes on a canvas and connect them with links. Each note opens into its own canvas, so every project, plan, or brainstorm gets a dedicated space.

There is nothing to install, and you can start without creating an account.

How Does a Flow-Based Notepad Work?
Create a note. Click “Add note” and give it a name.
Open its canvas. Click any note to enter a visual workspace.
Add nodes. Each node holds one idea, task, or piece of information.
Connect the dots. Link nodes to show order, dependencies, or relationships.

The result is a map of your thinking, not just a list of it.

Why Visual Notes Beat Plain Text
You see relationships at a glance. A link between two nodes shows a connection that paragraphs hide.
Planning gets easier. Flowcharts, roadmaps, and decision trees are natural on a canvas.
Brainstorming feels freer. You can drop ideas anywhere first and organize them later.
Memory improves. Spatial layouts are easier to recall than a long scroll of text.
Who Is JustNote8 For?
Students mapping out essays, study topics, and exam revision.
Developers sketching app architecture, user flows, and task dependencies.
Writers and creators outlining articles, stories, and content calendars.
Founders and teams planning launches, processes, and strategies.
Anyone who thinks better in diagrams than in bullet points.
Use Cases to Try Today
Plan a project from the first idea to the final deliverable.
Map a user journey or a software workflow.
Build a study plan that connects topics and deadlines.
Outline a blog post, video script, or presentation.
Turn a messy brain dump into a clear, linked structure.
Free, Fast, and Private by Design

JustNote8 is free to use and quick to open. You don’t need to sign up to start, and you can log in when you want your notes tied to an account. Details on how data is handled are in the site’s Privacy Policy and Cookie Policy.

Frequently Asked Questions

What is JustNote8.com?
JustNote8 is a free online notepad that organizes ideas as connected flow nodes on a visual canvas.

Do I need an account to use JustNote8?
No. You can start taking notes without signing up.

Is JustNote8 free?
Yes, you can use JustNote8 for free.

What is a flow node note?
A flow node is a single idea or task placed on a canvas. Linking nodes together forms a visual flow that shows how your ideas relate.

Can I use JustNote8 for brainstorming and project planning?
Yes. The canvas layout suits brainstorming, workflows, outlines, and project plans.

Start Organizing Your Ideas Visually

Stop forcing your thoughts into straight lines. Open JustNote8, create your first note, and see your ideas take shape.

RESTful API vs REST API: Is There Actually a Difference?

JohnDivam - justnote8.com — Mon, 12 Oct 2026 01:21:14 +0000

What is REST?

REST (Representational State Transfer) is an architectural style, not a protocol or a standard. It was introduced by Roy Fielding in his 2000 doctoral dissertation.

REST defines a set of constraints:

Client-server: UI and data storage are separated.
Stateless: each request contains everything the server needs; no session state on the server.
Cacheable: responses declare whether they can be cached.
Uniform interface: resources are identified by URLs and manipulated through standard methods.
Layered system: clients don't know if they talk to the real server or an intermediary.
Code on demand (optional): the server can send executable code to the client.

REST API vs RESTful API

	REST API	RESTful API
Meaning	An API that uses REST ideas	An API that faithfully follows REST constraints
Strictness	Loose, common usage	Strict, by-the-book
Typical in practice	JSON over HTTP, resource URLs	Same, plus correct verbs, status codes, statelessness, ideally HATEOAS

In other words:

REST is the architectural style.
REST API is the everyday label for an HTTP API inspired by it.
RESTful describes how well an API conforms to that style.

Example: not RESTful

POST /getUser
POST /createUser
POST /deleteUser?id=42

Here HTTP is just a tunnel. The action is in the URL, and every call is a POST. This is closer to RPC than REST.

Example: RESTful

GET    /users        # list users
GET    /users/42     # get one user
POST   /users        # create a user
PUT    /users/42     # replace a user
PATCH  /users/42     # partially update a user
DELETE /users/42     # delete a user

The URL identifies the resource (a noun), and the HTTP method expresses the action.

RESTful in Laravel

Laravel makes this almost free with resource routes:

// routes/api.php
Route::apiResource('users', UserController::class);

This single line generates index, store, show, update, and destroy, mapped to the right verbs and URLs.

And return proper status codes:

public function store(StoreUserRequest $request)
{
    $user = User::create($request->validated());

    return response()->json($user, 201); // 201 Created, not 200
}

public function destroy(User $user)
{
    $user->delete();

    return response()->noContent(); // 204 No Content
}

The HATEOAS Problem

The most-ignored REST constraint is HATEOAS (Hypermedia as the Engine of Application State): responses should include links telling the client what it can do next.

{
  "id": 42,
  "name": "Hakim",
  "_links": {
    "self": { "href": "/users/42" },
    "orders": { "href": "/users/42/orders" },
    "delete": { "href": "/users/42", "method": "DELETE" }
  }
}

Almost nobody implements this, which means that, strictly speaking, most "RESTful" APIs aren't fully RESTful by Fielding's definition. Some people call the pragmatic version "REST-ish" or simply an "HTTP API."

Checklist for a "RESTful enough" API

[x] Nouns in URLs, plural (/users, not /getUsers)
[x] Correct HTTP verbs for each action
[x] Meaningful status codes (201, 204, 404, 422)
[x] Stateless requests (token auth, no server sessions)
[x] Consistent JSON structure
[x] Versioning (/api/v1/...)
[ ] HATEOAS (optional in practice)

So which term should you use?

In daily conversation, docs, and job descriptions, "REST API" and "RESTful API" mean the same thing. Use either.
In a technical discussion, "RESTful" implies you follow the constraints properly.
If someone is being strict, the honest answer is: "It's REST-style, but not full HATEOAS."

Conclusion

REST is the style, REST API is the common label, and RESTful means faithful to the style. What matters more than the term is designing APIs that are predictable, stateless, and consistent with HTTP semantics.

How do you use these terms on your team? Does anyone actually implement HATEOAS? Let me know in the comments.

Found this useful? Follow me for more backend and Laravel content.

Why You Should Never Skip .dockerignore

JohnDivam - justnote8.com — Thu, 01 Oct 2026 14:58:25 +0000

Why You Should Never Skip .dockerignore

When I started using Docker, I wrote a Dockerfile, ran docker build, and moved on. It worked, so I never thought about it again. Later I noticed my builds were slow and my images were bigger than they should be. The cause was a small file I had never created: .dockerignore.

What is it?

A .dockerignore file tells Docker which files to leave out when you build an image. It works like .gitignore, but for Docker. When you run docker build, Docker first sends your whole project folder (the "build context") to the Docker engine. Anything listed in .dockerignore is not sent.

Why it matters

1. Faster builds.
Think about node_modules, vendor, or .git. These folders can be hundreds of megabytes. Without .dockerignore, Docker copies all of it on every build, even if your Dockerfile never uses it. With the file in place, the build starts almost right away.

2. Smaller images.
When you write COPY . ., everything in the folder goes into the image. That includes logs, cache, test files, and editor settings. A smaller image is faster to push, pull, and deploy.

3. Better security.
This one is the most important. Your project folder may contain .env files, private keys, or passwords. If you copy them into an image, they stay there. Anyone who can pull the image can read them. Ignoring these files keeps secrets out.

4. Fewer strange bugs.
Here is a real example. You install dependencies on your Windows machine, then build a Linux image. If your local node_modules gets copied into the image, it can overwrite the clean one installed inside Docker. Native packages then break, and the error messages make no sense. Ignoring node_modules fixes this.

5. Better layer caching.
Docker reuses a layer if nothing in it has changed. If a log file or a cache file changes on every run and gets copied into the image, the cache is broken and Docker rebuilds everything. Ignoring those files keeps the cache working.

A simple example

For a Node project:

node_modules
.git
.env
.env.*
dist
npm-debug.log
Dockerfile
.dockerignore

For a PHP project, you would ignore vendor, var, and local .env files instead.

A few tips

Do not ignore files your build needs, like package.json or composer.json.
Keep your lock files. They make builds repeatable.
Create the file on day one, not after problems start.
Review it from time to time as the project grows.

Final thoughts

.dockerignore takes two minutes to write, and it saves you from slow builds, large images, leaked secrets, and confusing errors. It is one of the easiest improvements you can make to a Docker setup. If your project does not have one yet, add it today.

# VCS / IDE
.git
.gitignore
.idea
.vscode

# Dependencies (installed inside the image)
vendor
node_modules
public/storage
bootstrap/cache/*.php
storage/framework/views/*
storage/framework/cache/*
storage/framework/sessions/*
storage/logs/*
.env
.env.local
.env.*.local
.env.dev
.env.test
var
k8s

# Secrets
config/jwt/*.pem

# Tests / tooling
tests
.phpunit.cache
.phpunit.result.cache
phpunit.xml
.php-cs-fixer.cache
.php_cs.cache

# Docker files
Dockerfile
.dockerignore
compose.yml
compose.dev.yaml
compose.prod.yaml
docker-compose*.yml

# Misc
*.log
*.md

Containerized Full-Stack Application using Docker, Nuxt 4, and Symfony 7.4

JohnDivam - justnote8.com — Tue, 01 Sep 2026 09:00:14 +0000

To run a multi-container full-stack application, the best practice is to separate your frontend and backend into isolated containers and orchestrate them using Docker Compose. This keeps your development environment clean, handles internal networking automatically, and allows services to scale independently.

Structure:

justproject/
├── justproject_api/
│   └── docker/entrypoint.sh   
│   └── docker/nginx.conf   
│   ├── docker-compose.yml   
│   ├── Dockerfile          
└── justproject_front/
    └── Dockerfile

justproject_api\docker-compose.yml

services:
  database:
    image: mariadb:11
    ports:
      - "3307:3306"
    environment:
      MYSQL_DATABASE: ${MYSQL_DATABASE:-justproject}
      MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD:-root}
    healthcheck:
      test: ["CMD", "healthcheck.sh", "--connect", "--innodb_initialized"]
      timeout: 5s
      retries: 5
      start_period: 30s
    volumes:
      - database_data:/var/lib/mysql:rw

  app:
    build: .
    volumes:
      - .:/var/www/html
      - app_cache:/var/www/html/var/cache
      - app_log:/var/www/html/var/log
    depends_on:
      database:
        condition: service_healthy

  nginx:
    image: nginx:alpine
    ports:
      - "8000:80"
    volumes:
      - .:/var/www/html
      - ./docker/nginx.conf:/etc/nginx/conf.d/default.conf
    depends_on:
      - app

  frontend:
    build: ../justproject_front
    ports:
      - "3000:3000"
    environment:
      NUXT_PUBLIC_API_BASE: "http://localhost:8000"
    volumes:
      - ../justproject_front:/app
      - /app/node_modules

volumes:
  database_data:
  app_cache:
  app_log:

justproject_api\Dockerfile

FROM php:8.4-fpm

RUN apt-get update && apt-get install -y \
    git unzip libicu-dev libzip-dev \
    && docker-php-ext-install pdo_mysql intl zip

COPY --from=composer:2 /usr/bin/composer /usr/bin/composer

WORKDIR /var/www/html
COPY . .
RUN composer install --no-interaction --optimize-autoloader

COPY docker/entrypoint.sh /usr/local/bin/entrypoint.sh
RUN chmod +x /usr/local/bin/entrypoint.sh

ENTRYPOINT ["entrypoint.sh"]
CMD ["php-fpm"]

justproject_front\Dockerfile

FROM node:20-alpine

WORKDIR /app
COPY package*.json ./
RUN npm install

COPY . .
EXPOSE 3000
CMD ["npm", "run", "dev", "--", "--host", "0.0.0.0"]

justproject_api\docker\entrypoint.sh

#!/bin/sh
set -e

mkdir -p var/cache var/log
chown -R www-data:www-data var/cache var/log
chmod -R 775 var/cache var/log

exec "$@"

justproject_api\docker\nginx.conf

server {
    listen 80;
    root /var/www/html/public;

    location / {
        try_files $uri /index.php$is_args$args;
    }

    location ~ ^/index\.php(/|$) {
        fastcgi_pass app:9000;
        fastcgi_split_path_info ^(.+\.php)(/.*)$;
        include fastcgi_params;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        fastcgi_param DOCUMENT_ROOT $document_root;
    }
}

up
docker compose up -d --build

to check mgirations list :
docker compose exec app php bin/console doctrine:migrations:list

This only for local environment

Website Builder : Using Livewire

JohnDivam - justnote8.com — Tue, 07 Jul 2026 10:23:48 +0000

"QubeSite is an integrated platform for creating websites without writing any code. The platform was developed using Laravel with an advanced control panel to manage users, packages, templates, and subscriptions. The platform provides a visual editor, multilingual support, and domain linking, with high performance and a smooth user experience, to facilitate the creation of professional websites in minutes."

Built with:
Laravel • Livewire • Filament • MySQL • Redis

Filament: Hide Submit and Cancel Buttons in wizard

JohnDivam - justnote8.com — Tue, 28 Oct 2025 10:19:50 +0000

Override the submitAction dynamically in the Page class
If you’re in a CreatePage or EditPage, you can control visibility like this:

class CreatePage extends CreateRecord
{
    protected static string $resource = PageResource::class;

    //add this 
    public function getFormActions(): array
    {
        return [

        ];
    }
}

And in your PageForm :

Wizard::make([
...
])
 ->submitAction(view('filament.submit-button'))

// in resources\views\filament\submit-button.blade.php

<div 
    x-data
    x-transition
>
    <x-filament::button
        type="submit"
        color="primary"
        class="fi-btn"
    >
        Submit
    </x-filament::button>
</div>

Laravel app was slow. Here's how I fixed it

JohnDivam - justnote8.com — Fri, 17 Oct 2025 14:25:08 +0000

Imagine fetching 100 users, each with related posts and comments.
Without optimization, your app might execute 1000+ queries just to load a single page!
The result? Slow performance, wasted resources, and frustrated users.
Let’s fix it step by step :

1️⃣** Eager Loading ->with()**
Instead of making one query per related record, load relationships in advance.

Before:

$users = User::all();

After:

$users = User::with('posts', 'comments')->get(); //Faster. Cleaner. Efficient.

2️⃣ Database Indexing
Add indexes to columns you frequently query or use in WHERE, JOIN, and ORDER BY clauses.

Example:

CREATE INDEX idx_user_email ON users(email); //Query time improved from 800ms → 50ms

3️⃣ Query Caching (Laravel Cache)
Cache repeated queries or expensive operations using Laravel’s built-in caching.

Example:

$users = Cache::remember('users_with_posts', 60, function() {
    return User::with('posts')->get();
});

4️⃣ Lazy Loading Assets (Images, Videos, etc.)
Optimize your frontend performance by loading assets only when they’re visible.

<img src="image.jpg" loading="lazy" alt="User profile">

Faster page rendering and lower initial load times.

5️⃣ Optimize Select Queries (Avoid SELECT *)
Fetching unnecessary columns bloats your response and slows queries.

Before:

$users = User::with('posts')->get();

After:

$users = User::select('id', 'name', 'email')
             ->with('posts:id,user_id,title')
             ->get(); //Only the data you need — smaller payloads, faster delivery.

Final Thoughts
Performance optimization isn’t a one-time task — it’s an ongoing discipline.
By combining eager loading, indexing, caching, and smart query design, you can turn a slow, bloated app into a lightning-fast experience ⚡.

Is Laravel the Best PHP Framework in 2025

JohnDivam - justnote8.com — Fri, 17 Oct 2025 14:12:53 +0000

While new frameworks pop up every year, Laravel continues to stand tall as the go-to choice for developers worldwide. Here’s why it remains unbeatable:

1️⃣ Elegant, Readable Syntax
Laravel’s syntax is poetry in code — clean, expressive, and a joy to work with. Writing Laravel feels natural, like speaking fluent English. It’s not just beautiful — it’s maintainable and developer-friendly.

2️⃣ A Massive, Integrated Ecosystem
Forge – effortless server management and deployment
Vapor – seamless serverless scaling on AWS
Nova – powerful, elegant admin panels
Horizon – advanced queue monitoring and control
Everything you need to build, deploy, and scale — all within reach.

3️⃣ A Thriving Global Community
Get stuck? You’re never alone. Thousands of Laravel developers are ready to help.
From Laracasts tutorials to active Discord servers, forums, and GitHub discussions, support is always just a message away.

4️⃣ Packed with Modern Features
Laravel brings all the essentials of modern web development — no extra setup required:
✅ Built-in authentication
✅ Queue management
✅ Real-time event broadcasting
✅ Task scheduling
✅ API resources and resourceful routing

It’s modern, streamlined, and designed for productivity.

5️⃣ Scales with Your Vision
Whether you’re launching a small MVP or running an enterprise app serving millions, Laravel grows with you. Its architecture and ecosystem are built for performance and scalability. 💪

6️⃣ Constantly Evolving
Led by Taylor Otwell and an incredible open-source community, Laravel evolves rapidly. Expect frequent updates, new features, and rock-solid security patches — keeping your stack modern and secure.

7️⃣ Job Market
Laravel skills are in high demand. From startups to global companies, everyone’s hiring Laravel developers — and the opportunities just keep growing.

Laravel isn’t just surviving the test of time — it’s defining the future of web development.

Groups in Filament v4

JohnDivam - justnote8.com — Sat, 11 Oct 2025 10:56:30 +0000

you can use it with any layout component. For example, you could use a Group component which has no styling associated with it:

use Filament\Schemas\Components\Section;


public static function configure(Schema $schema): Schema
    {
        return $schema
            ->components([
                Section::make()
                  ->schema([
                    TextInput::make('test1'),
                ])->columnSpan(['lg' => 2]),
                Section::make()
                  ->schema([
                    TextInput::make('test2'),
                ])->columnSpan(['lg' => 1]),
            ])->columns(3);
    }

Filament Repeater, total sum & validate

JohnDivam - justnote8.com — Sat, 27 Sep 2025 10:40:23 +0000

Sum the values of all repeater rows
Validate the total against a maximum
Update another field automatically

return $form->schema([

    // This field will display the calculated total
    Forms\Components\TextInput::make('qnt_allocated')
       ->label('Total Quantity')
        ->required()
        ->numeric()
        ->suffix('Kg'),

    // Repeater of groups
    Forms\Components\Repeater::make('groups')
        ->label('groups:')
        ->relationship('groups')
        ->schema([
            Forms\Components\TextInput::make('quantity')
                ->label('group quantity')
                ->required()
                ->numeric()
                ->reactive()
                ->rules([
                    fn (Get $get): \Closure => function (string $attribute, $value, \Closure $fail) use ($get) {
                        $total = collect($get('../../groups'))->sum('quantity');
                        if ($total > 7000) {
                           $fail("Total quantity for all groups cannot exceed 7000 kg (Current total: {$total})");
                        }
                    },
                ])
                ->afterStateUpdated(function ($state, callable $get, callable $set) {
                    $total = collect($get('../../groups'))->sum('quantity');
                    $set('../../qnt_allocated', $total);
                })
                ->suffix('Kg'),
        ])
]);

Filament How to redirect to list page after (create,update) using Trait

JohnDivam - justnote8.com — Thu, 22 Aug 2024 11:51:59 +0000

To redirect to the list page after creating or updating a resource in Filament v3, you can use a custom trait in your resource class .

Create a Custom Trait

<?php

namespace App\Traits;

trait RedirectIndex
{
    protected function getRedirectUrl(): string
    {
        return $this->getResource()::getUrl('index');
    }
}

Use the Trait in Your Filament Resource

class CreateProduct extends CreateRecord
{
    protected static string $resource = ProductResource::class;

   //add trait in your CreateRecord or UpdateRecord
    use \App\Traits\RedirectIndex; 
}

Laravel Filament: get resource table data by authenticated id

JohnDivam - justnote8.com — Tue, 02 Jul 2024 11:06:22 +0000

To restrict the display of resources in a Filament resource based on the user_id of the authenticated user, you can modify the getEloquentQuery() method in your Filament resource class. Here’s how you can do it:

 public static function getEloquentQuery(): Builder{
        return parent::getEloquentQuery()->where('user_id',auth()->id());
    }