24 results for “manukall”
How to Manually Install #Mikrotik CHR on #VPS from Custom ISO or Image
This article provides a guide for how to manually install Mikrotik CHR on VPS from custom ISO or image.
What is Mikrotik CHR?
Mikrotik CHR (or Cloud Hosted Router) is a full-featured #router designed for use in virtual environments. Installing CHR on a VPS can be beneficial for managing network traffic, ...
Continued 👉 https://blog.radwebhosting.com/manually-install-mikrotik-chr-on-vps-from-custom-iso-or-image/?utm_source=mastodon&utm_medium=social&utm_campaign=mastodon.social #mikrotikchr #selfhosted #selfhosting #installguide #vpsguide #kvmvps #routeros
I switched to #nixos for running my #k3s nodes. No more Ansible scripts to manually push changes. 🎉
I was surprised that I can also do partitioning in nixos. Very convenient to have the exact same hard disk layouts across nodes for the cluster. And still being able to configure slight differences for individual nodes.
And you can even have like a GitOps workflow if you want that.
The human interface is still just a little bit confusing ("latest only" is not checked on by default, and my architecture is not checked on neither so I have to check both of them manually or else it gives me like a list of the same thing but only one of them would work for me and it's not obvious at all which one does) but still so much better than not being able to understand anything! #FedoraKDE #SteamFrame #dnfdragora
Inside Amazon’s Robot Warehouse: How Automation Is Changing Jobs
Amazon warehouse workers used to spend much of their days walking, pushing carts through long aisles to manually…
#UnitedStates #US #USA #Amazon #america #area #business #BusinessInsider #cart #employeeworkstation #facility #humanworker #machine #morepackage #people #proteus #robin #robot #tracy #unitedstatesofamerica #work
https://www.europesays.com/3337162/
A comprehensive review compares the top free VPN services for 2026 based on over 10 years of testing.
Proton VPN takes the top spot with unlimited data across 10 countries, though free users cannot manually select servers.
TunnelBear offers unlimited simultaneous connections with a 2GB monthly limit, while PrivadoVPN provides 10GB before throttling.
The analysis also covers free tier constraints from Windscribe,, and Hotspot Shie…
Is this satire or what? Instead of enforcing traffic laws, pedestrians now may to spin a toy and beg Mr. Driver The King for permission to cross.
"Havainnehyrrä" is a manually operated observation device that a person crossing the street can spin to signal their intention to cross."
https://www.tamperelainen.fi/paikalliset/9897362
ht @ssundell
Thought Control Resonant had a bug because it would reliably stutter every 1 second.
Actual problem: TV used as a display somehow persuaded Windows to set refresh at 59.94Hz. Manually set it to 60Hz and now everything is smooth again.
I did a bare-metal install of #NetBSD today on my 2017 HP Pavilion (Intel/Nvidia) laptop using a USB-connected 500 GB HDD.
It took a couple passes before I figured out that I had to manually remove the MBR on the target drive for the installation to boot.
Then it was easy because I've done a bunch of practice installs.
On this laptop, everything works:
WiFi
X11
Sound (and volume buttons)
Brightness buttons
YouTube video plays great
Improvement: - Normalize All Instruments -> this shortcut will normalize all instruments in the song, so you don't need to manually press Normalize on each of them
Link to Patreon in bio.
#paketti #tracker #patreon #lua #renoise #demoscene #trackermusic
Automation Architecture for WordPress REST API: A Founder’s Playbook
Server crashes and API limits are the relentless nightmares of a tech solopreneur. Let me be clear: the efficiency of your WordPress site might hinge on how adeptly you automate using the REST API. Automation isn’t a luxury; it's a necessity, especially when your resources are as limited as your patience with manual processes.
The Core Technical Problem & Why This Matters
Here's the brutal truth: Manual WordPress tasks are a time sink. Whether you're managing large volumes of data, orchestrating content updates, or handling user interactions, doing it manually can lead to errors and inconsistencies. If your site's responsiveness falters, it doesn't just irritate you; it drives your audience away. Automating these processes using the WordPress REST API can save countless hours and improve site performance.
The REST API facilitates interactions with WordPress through HTTP requests, enabling you to integrate, retrieve, and update data without being shackled to the WordPress admin interface. It extends your ability to shape your site's functionality at scale, fix systemic bottlenecks, and streamline operations. The intent is clear—reduce human error while maximizing efficiency.
The Systems Engineering Approach
When approaching WordPress REST API automation, consider your system architecture as a network of interlocking parts that need meticulous alignment. Start by identifying the routine tasks that can be automated, such as content publishing, user management, and custom plugin integrations. Define the requirements for each task so that they align seamlessly with your workflow.
Focus on the endpoints provided by the REST API. Each endpoint represents a window into WordPress operations. With GET, POST, PUT, and DELETE requests, you tap into various functionalities. For example, a POST request can publish content automatically when certain conditions are met, while a DELETE request can clear out redundant comments.
Security is paramount. Ensure that authentication mechanisms, such as OAuth or API keys, are robust and insulated from potential threats. Implement measures like rate limiting and monitoring to secure your operations without slamming into API call quotas.
Real-World Architecture & ROI
In the real world, the ROI of automation through the REST API can be striking. Take an e-commerce site: automating the inventory updates via the API ensures that your database mirrors warehouse stock levels in real-time. Your JSON structure becomes a linchpin here, handling data elegantly. A well-designed JSON payload that updates product availability can reduce time spent on continual data checks, enhancing your operations' responsiveness.
Consider a content-heavy blog. If you have contributors submitting posts from various locations, automation helps in moderating and publishing content via the API, drastically reducing the manual overhead. This also aids in maintaining a uniform tone and quality. The architecture moves beyond mere CRUD operations, evolving into a cohesive system engineered for repetitive task handling.
The financial return? By slashing manual hours, you're not just saving on salaries. You're freeing up mental bandwidth, fostering innovation instead of tedium—time better spent on scaling your business in Davao or wherever life takes you next.
Common API & Integration Pitfalls
Even with careful planning, API integrations can spiral into chaos. One common pitfall is underestimating the intricacies of data formats. Data mishaps occur if your JSON structure isn’t tailored to the endpoints or if you ignore version updates of the API. Always keep abreast of changes to WordPress API protocols; they shift as frequently as technology itself.
Don't ignore load testing. High traffic can expose weaknesses in your API calls. Without proper caching mechanisms, your system could be overwhelmed during peak times. Prepare your architecture to scale gracefully, avoiding overloading the server with concurrent requests.
Another blind spot is error handling. When API requests fail, they don't just vanish—they accumulate technical debt. Crafting robust error-handling protocols ensures that these failures don't morph into larger systemic issues. Logging and alerts keep you informed, allowing for proactive resolutions.
The Ultimate Scalability Factor
Scalability hinges on how well your system adapts to growing demands. Automating WordPress tasks via REST API transforms your site’s elasticity. Begin by modularizing your automation scripts to ensure they’re adaptable. This modularity permits upgrades without overhauling existing systems, preserving your sanity and streamlining growth.
Use asynchronous processing to handle extensive, resource-intensive tasks. This ensures that even during upticks in user activity, your core functions remain untouched by bottlenecks. Leverage queuing services to stagger task execution, maintaining consistent throughput without server strain.
Finally, assess your deployment strategy. Whether you’re hosting on-premises or opting for cloud solutions, your infrastructure should facilitate quick scaling. Regular audits of your system architecture reveal opportunities for enhancement, ensuring that as your needs evolve, your automation can flex accordingly.
<h3>Want the JSON Blueprint for this architecture?</h3>
<p>I don't charge for the blueprint. If you want to replicate this automated pipeline in your own workspace, send me the word <strong>"AUTOMATION"</strong> directly on Telegram.</p>
<a href="https://t.me/Techhustledaily_bot">Get the JSON Blueprint ➔</a>
<p><em>Need this exact pipeline integrated into your business? Send a message to discuss custom deployment and API routing.</em></p>
[IRIS_QUOTE]Iris says: Automation slashes time, driving profit up, while manual labor simmers tech burnout. Who needs that?[/IRIS_QUOTE]
[META]Automate WordPress with REST API: save time, reduce tech headaches.[/META]
[SEO_KEYWORD]REST API[/SEO_KEYWORD]
[IMAGE_KEYWORD]cyberpunk code#saas #webdev #productivity #startup #software #coding #development #engineering #inclusive #community
AumaAccufdPAP:AFud’Playbk
So for big five personality test thing, I got
Openness 46
Conscientiousness 15
Extraversion 21
Agreeabless 73
Neuroticism 13
I've done some reading and it means I'm calm, stable and self-sacrificing yet scatterbrained.
I mean it makes sense. I got called out 4 years ago by my trainer at a trade school for lacking focus, lol
Though I was able to install Arch and Gentoo Linux manually. Pretty easy and fun too.
#bigfive #personality #mastodon #archlinux #gentoo #linux #opensource
#AskFedi
How do people manage images on their static sites?
My blog contents are Git-backed and generated with 11ty, deployed on a server I can SSH into. If I want to start adding photos, where do I put those?
Surely I don’t commit them directly to the repo, right?
Do I host them somewhere and pull them in dynamically on build? Do I manually put a folder on the web server and dump some images in it, then write my img tags so that they correctly (🤞🏻) reference those? Do I figure out how Git LFS or whatever works? Is this all just what CDNs are and I should have already wrapped my head around those? (Probably.)
«CL is mathematically precise»
And here, too, is where intent also comes in.
In contexts like the present one, the choice of a precise definition of ”mathematically precise” is also a matter of intent.
For example, I can imagine an intent to replace automatically #C(17.17 0.0) with 17.17, which would match the behavior of `=’ and `equalp’.
(With Common Lisp, one would have to do this manually, of course, which can be cumbersome.)
And I don't think that ignoring letter case is “culturally consistent” with distinguishing between 1717/100 and 17.17, but again, your intended mileage may vary.
Also, note that
(and (realp x) (equalp x y))
does not imply
(realp y)
(ditto for `=’).
There are other more interesting cases in wider design space, like having a complex number with one component a floating-point number and the other a rational number.
One very famous case for this is
(/ (log -1) (sqrt -1))
(besides computer algebra systems, this requires some special casing, but arguably, acceptably little).
While `equalp’ can indeed be useful, sometimes very useful, using it successfully requires much more care than using `equal’.
The distinction between `eq’ and `eql’ is rather different in this respect, because `eql’ insists (1) on the types being the same and (2) on immutability for two things that are not `eq’.
Thus using `eql’ successfully is much more straightforward than `equalp'.
Unlike the other three, the latter's definition is not really straightforward, more an idiosyncratic combination of trade-offs and historical reasons.
And it is by far not the only workable extension of `equal’.
Is there an open source log monitoring system that tells me useful stuff out of the box like whether something new has cropped up in a log that hasn't been seen before, a certain message has suddenly got a lot more frequent or a regular message has stopped? With today's ML I'm surprised I haven't come across something like that. Most tools look like they require you to craft your own queries manually, or the ones which tout 'AI' are expensive & closed.
Preface
Before diving in to the basics, this post would like to implore the reader to look up definitions of all the technical jargon that will naturally follow in the series. You cannot build a technical understanding of the structures involved unless you’re proficient in the language it speaks.
Note: All technical jargon will be marked with an asterisk (*), making it easier to identify them for lookups.
This is the first in a 5-part series that aims to act as a manual to developers who are either starting out learning GitLab CI/CD or more senior devs looking for a handbook.
First order of business — What are CI/CD pipelines, and why GitLab?
In order to comprehend the concept that is automation and pipelines, we need to trace the history of why these things came into place, the technologies that came after and how refined they became over time.
To give a brief introduction, before pipelines, developers had to manually set up everything — from installing dependencies required by apps to setting up infrastructure for their projects to run.
After the advent of scripting, it became a lot easier to automate manual tasks with the run of a single .sh file. But scripting brought up its own sets of problems, one of them being deployment.
Deployment was still done manually, because scripting produced many errors such as:
CI/CD Pipelines — Demystified
CI/CD pipelines are Continuous Integration/Continuous Delivery tools that aid in automating 90% of the work that you would have otherwise done manually, such as deployment, setting up infrastructure on a server, etc.
Any changes you make in your code base or structure immediately get integrated and tested by the pipeline — the Continuous Integration part — and then deployed to a cloud platform of your choice, which falls under the Continuous Delivery section (AWS, Microsoft Azure, Google Cloud, etc.).
There are many CI tools that came about after the advent of pipelining. A few notable ones are:
EC2 Instance or a Kubernetes cluster.There is no “proper” or “best” pipeline, since the primary work that each tool does is automation, while offering different sets of features, such as GitLab CI offering native *Terraform integration, whereas GitHub Actions — being relatively new — does not, requiring third-party support. But that is about the degree to which the distinction between each pipeline goes.
Of course, the choice varies from company-to-company. The employee must, then, learn to be flexible to suit the company’s requirements.
Why GitLab CI? Why not other CI tools?
Herein lies the “paradox of choice”. There are several repo-hosting platforms available that offer CI/CD capabilities, so choosing each depends on the pros and cons of each platform, along with the needs of the individual/team.
A table is then best suited to provide a more direct comparison between each platform, their benefits, and the costs they offer.
A table is then best suited to provide a more direct comparison between each platform, their benefits, and the costs they offer.
Conclusion
While GitHub and BitBucket offer more features in general development — with JFrog Artifactory offering solely binary storage — GitLab stands out as the best production-standard for a DevOps team when it comes to offering a pure DevOps-related repository hosting platform.
And thus, we shall begin by navigating through GitLab and its main attraction point for many developers — CI/CD capabilities.
Any corrections in this post will be much appreciated in the comments!#automation #cicd #devops #tutorial #software #coding #development #engineering #inclusive #community
The GitLab CI Manual: The Textbook You’ve Always Needed — #1 Introduction
Competitive truth markets require open proofs at the base layer. Independent nodes earn fees by verifying computations correctly, forcing prices toward cost. Apps consume proofs, not promises, inheriting a shared state they didn't have to manually reconcile.
4/4
After installing a cluster, the first thing many engineers do is run gcadmin. Then comes command not found, or the command starts but reports an unexpected cluster state.
With GBase Database(GBase 8a), installation is not just about putting binaries in place. The current shell must also load the correct environment so that administrative commands can locate the intended executables, configuration files, and libraries.
Before troubleshooting cluster services, verify the environment.
1. Why gcadmin Fails After Installation
A successful GBase Database installation does not guarantee that every new shell automatically inherits the required environment variables.
Three things matter:
gcadmin executable?If any of these settings is missing or points to an old installation, administrative commands may fail or behave unexpectedly.
User switching is another common source of confusion. Loading environment variables as root does not automatically configure the environment for the gbase account. Always verify the environment under the account that will run the database administration commands.
2. Load and Verify the GBase Database Environment
If your installation procedure configures ~/.bash_profile as the environment entry point, load it before running gcadmin:
source ~/.bash_profile
which gcadmin
gcadmin
The source command applies the profile settings to the current shell. The which command helps identify the executable selected through PATH, while gcadmin lets you inspect the cluster state.
Check the relevant environment variables as well:
env | grep -E '^(PATH|LD_LIBRARY_PATH|GBASE)'
The exact variable names depend on the installed release and configuration. Compare the results with the environment documented for your version, and confirm that paths point to the intended installation rather than leftover files from an earlier deployment.
Important: The profile filename and initialization procedure may vary by release or installation method. Use the version-specific GBase Database documentation to confirm the correct entry point.
3. Understand the Installation Directory Structure
The GBase Database(GBase 8a) installation directory contains components with different responsibilities. Depending on the installation layout, you may encounter directories such as gcware, gcluster, and gnode.
These components provide useful starting points during troubleshooting, but their exact directory contents and locations depend on the installation layout.
Inspect the actual installation prefix rather than assuming every component lives directly under /opt:
ls -ld /path/to/install/gcware \
/path/to/install/gcluster \
/path/to/install/gnode
Replace /path/to/install with your configured installation directory. If the directory layout differs, consult the installation documentation instead of assuming that a missing path indicates a failed installation.
Avoid manually editing internal configuration or metadata files simply because a service appears unhealthy. First identify the relevant logs and use the supported administration procedures.
4. Verify the Environment on Every Node
In a multi-node GBase Database cluster, configuring the environment on the Coordinator does not automatically configure every other machine.
Verify the following on each node where administration commands will be executed:
A command that works on one host may fail on another because of differences in user profiles, installation paths, or environment settings.
For automation, scheduled jobs, and fresh SSH sessions, explicitly initialize the environment when necessary. Do not rely on settings that exist only in an interactive shell.
5. Don't Confuse Cluster State with Environment Problems
A successful command execution does not necessarily mean the cluster is ready for use. Likewise, an unexpected status does not automatically indicate a failed installation.
For example, if gcadmin reports CLOSE, verify the licensing or authorization state and the expected startup sequence for your installed version before diagnosing a service failure. The meaning of a particular state must be interpreted in context; do not assume that every CLOSE status has the same cause.
Troubleshoot in a consistent order:
This sequence helps separate shell initialization problems from actual cluster issues.
6. Make Environment Initialization Part of the Runbook
The most reliable fix is to turn environment initialization into a documented operational step rather than an individual's habit.
For GBase Database administration, record the correct account, installation prefix, environment entry point, verification commands, and expected cluster status. Ensure that the procedure also covers non-interactive sessions and the nodes where administrative commands will run.
The key lesson is simple: load the environment, verify the executable, and then investigate the cluster state.
When troubleshooting GBase Database(GBase 8a), checking the shell environment first can save time and prevent a configuration issue from being mistaken for a database service failure.#gbase #database #数据库 #todayilearned #software #coding #development #engineering #inclusive #community
TIL: Fix the Shell Environment Before Troubleshooting GBase Database
"Apply clear frontend boundaries by separating server and client state, centralizing API access, and organizing code around features."
Although much of my recent architectural focus has been backend engineering, full-stack systems have reminded me that frontend architecture also needs boundaries.
A backend can be beautifully designed and still become difficult to work with if the frontend mixes networking, server state, local state and UI behavior indiscriminately.
When every component is responsible for fetching data, handling errors, managing loading indicators, transforming responses and maintaining shared state, the application gradually becomes harder to reason about.
Small changes begin to affect unrelated components. API changes spread across the UI. State becomes difficult to trace. Components become tightly coupled to implementation details that should have remained behind a boundary.
These are not necessarily problems with React or any particular frontend framework.
They are architectural problems.
The same principles that make backend systems easier to maintain—separation of concerns, explicit contracts and clear ownership—also apply to frontend engineering.
Separate server state from client state
This distinction is particularly important.
Data retrieved from an API is server state.
Examples include:
UI state is different.
Examples include:
These two categories should not automatically be managed the same way.
Server state represents information owned by an external system, usually the backend. It may become stale, change independently of the current browser session, require refetching, and need synchronization after mutations.
Client state represents information that the frontend owns for the current interaction or application experience.
For example, a requisition list may be server state, while the currently selected status filter is client state. The filtered result may be derived from those two values rather than stored as another independent copy.
This distinction matters because every additional copy of the same data creates another opportunity for inconsistency.
If a requisition is approved, the frontend should not have to manually update several unrelated stores and component states to keep the interface synchronized.
Instead, the architecture should make it clear where the authoritative data comes from and how the UI responds when that data changes.
React Query
For server state, TanStack Query (formerly React Query) provides useful mechanisms around:
That reduces the temptation to put every API response into a global client store.
It also provides a consistent approach to concerns that otherwise tend to be implemented repeatedly across components.
For example, a requisition query can be defined independently of the component that displays the result:
import { useQuery } from "@tanstack/react-query";
import { requisitionsApi } from "@/lib/api/requisitions";
export function useRequisitions() {
return useQuery({
queryKey: ["requisitions"],
queryFn: () => requisitionsApi.list(),
});
}
A page or component can consume the query and focus on presentation:
"use client";
import { useRequisitions } from "@/hooks/use-requisitions";
export function RequisitionList() {
const { data: requisitions, isPending, isError } = useRequisitions();
if (isPending) {
return <p>Loading requisitions...</p>;
}
if (isError) {
return <p>Unable to load requisitions.</p>;
}
return (
<ul>
{requisitions.map((requisition) => (
<li key={requisition.id}>{requisition.reference}</li>
))}
</ul>
);
}
These examples assume that the API client returns data in the shape expected by the component. In a production application, that contract should be defined and validated appropriately.
Mutations should also have an explicit strategy for keeping cached data consistent. Depending on the operation, that might involve invalidating a query, updating cached data, or using an optimistic update with appropriate rollback behavior.
There is an important distinction here: caching does not make the frontend the source of truth. It provides a mechanism for reusing and synchronizing data that is ultimately owned by the backend.
Query keys, invalidation rules and mutation behavior are therefore part of the frontend's data architecture, not just implementation details.
Zustand
A lightweight client-state library such as Zustand can instead handle application state that genuinely belongs on the client.
For example, an application might need to retain sidebar visibility, a temporary multi-step workflow, or a shared selection used across several components.
Zustand can provide a simple way to manage that state without introducing unnecessary complexity.
import { create } from "zustand";
type WorkspaceState = {
sidebarOpen: boolean;
toggleSidebar: () => void;
};
export const useWorkspaceStore = create<WorkspaceState>((set) => ({
sidebarOpen: true,
toggleSidebar: () =>
set((state) => ({
sidebarOpen: !state.sidebarOpen,
})),
}));
The store owns the sidebar's UI state. It does not need to own the API responses displayed inside the sidebar.
This is the architectural distinction I want to preserve.
A global store should not become the default destination for every piece of data simply because multiple components need access to it.
Before adding state to a shared store, it is worth asking whether that state actually needs to be shared, whether it can be derived, and who owns its lifecycle.
Not every state value needs a library. Local component state remains appropriate for interactions that do not need to be shared, while form libraries can handle more involved form state and validation.
The architectural distinction is more important than the particular library.
API clients
I also prefer keeping HTTP concerns behind a consistent client boundary.
For example:
UI
│
▼
Query / Mutation
│
▼
API Client
│
▼
Backend
The UI should not need to understand every Axios configuration detail.
A centralized API client can own concerns such as:
Feature-specific API modules can then expose operations in terms that make sense to the application.
For example, a requisition module might expose list(), getById() and approve(), rather than requiring every component to construct its own HTTP requests.
import { apiClient } from "@/lib/api/client";
import type { Requisition } from "@/types/requisition";
export const requisitionsApi = {
async list(): Promise<Requisition[]> {
const response = await apiClient.get<Requisition[]>("/requisitions");
return response.data;
},
async approve(id: string): Promise<Requisition> {
const response = await apiClient.post<Requisition>(
`/requisitions/${id}/approve`,
);
return response.data;
},
};
This example illustrates the boundary; a real implementation should use the actual response envelope and error contract defined by the backend.
The benefit is not simply fewer lines of code.
It is the ability to change HTTP configuration, error handling or transport details without rewriting every component that consumes the API.
It also gives the frontend a natural place to translate technical transport concerns into application-level behavior.
However, a shared client should not become an excuse to hide important semantics. Authentication failures, authorization failures, validation errors and transient network failures may require different responses. A generic interceptor should not silently treat them all as equivalent.
Respect the backend contract
A frontend and backend are not independent systems that happen to communicate over HTTP.
They are two parts of a system with an explicit contract.
That contract includes more than endpoint URLs. It also includes request and response shapes, validation rules, authorization behavior, pagination, error formats, and the meaning of successful operations.
For example, hiding an approval button in the UI does not enforce authorization. The backend must still verify that the current identity has permission to approve the requisition.
Similarly, frontend validation can improve usability, but the backend remains responsible for enforcing business rules.
TypeScript helps maintain consistency within the frontend codebase, but a TypeScript interface does not automatically validate data received over the network at runtime.
Where necessary, runtime schema validation and shared contract definitions can reduce the risk of frontend and backend assumptions drifting apart.
The objective is not to duplicate the entire backend domain model in the browser. It is to establish a clear, dependable contract between the two sides.
Next.js
Next.js provides another layer of architectural decisions.
With the App Router, developers need to understand:
These concepts influence where code executes, how data reaches the UI, and which responsibilities belong on the server or in the browser.
Server Components are useful for rendering content that does not require browser-side interactivity. They can fetch data on the server and keep server-only implementation details out of the client bundle.
Client Components are appropriate when a feature requires state, event handlers, effects, or browser APIs.
The distinction should be intentional.
Marking a large component tree as client-rendered simply because one small section needs interactivity can expand the client-side JavaScript unnecessarily. Conversely, forcing interactive behavior into Server Components creates avoidable friction.
Data fetching also needs deliberate ownership. Next.js server-side data access and a client-side query cache solve related but different problems.
Server Components can be appropriate for initial rendering and server-side access to data. TanStack Query is useful when the client needs ongoing query caching, refetching, mutation handling, or synchronization during an interactive session.
Using both is possible, but their responsibilities should be clear. Otherwise, the same data may be fetched and cached independently without a coherent invalidation strategy.
Loading and error boundaries deserve similar attention. They should communicate the state of the application meaningfully rather than serve as generic fallbacks that conceal the source of a failure.
Again, the framework should support the application architecture.
It should not determine the architecture by accident.
Organize around features and responsibilities
As frontend applications grow, folder structure can either reinforce or weaken these boundaries.
A feature-oriented structure can keep related API operations, query hooks, types and components close to one another:
src/
├── app/
│ ├── requisitions/
│ └── inventory/
├── components/
│ ├── ui/
│ └── layout/
├── features/
│ ├── requisitions/
│ │ ├── api/
│ │ ├── hooks/
│ │ ├── components/
│ │ ├── schemas/
│ │ └── types/
│ └── inventory/
│ ├── api/
│ ├── hooks/
│ ├── components/
│ ├── schemas/
│ └── types/
├── lib/
│ └── api/
└── stores/
This is one possible arrangement, not a universal prescription.
A small application may not need all these folders. A larger application may benefit from stronger feature boundaries and explicit shared contracts.
The underlying principle is that related responsibilities should be easy to locate, while unrelated features should not become tightly coupled through shared components or global state.
A folder structure alone cannot guarantee good architecture. The imports, ownership rules and dependencies between modules matter more than the names of the directories.
Final thought
Full-stack engineering is not about treating frontend and backend as unrelated applications.
The contracts between them are part of the architecture.
Server state and client state have different responsibilities. API clients should isolate transport concerns. Components should focus on presenting and interacting with data. Framework features should be used according to their strengths.
These boundaries reduce unnecessary coupling and make changes easier to reason about.
A clean API boundary makes both sides easier to evolve.
A clean frontend architecture helps ensure that the backend's design remains an asset rather than becoming obscured by the way the UI consumes it.#frontend #backenddevelopment #react #nextjs #software #coding #development #engineering #inclusive #community
Building Frontends That Respect Backend Architecture
Google Anti Gravity
Okay, I have been struggling with an issue with Gnome 50 for about a year now. The issue was that when I right clicked an App Icon on the App Grid and tried to pin it to the Dash there was a long delay, sometimes as long as 3 seconds. The same thing just moving around App Icons on the Dash or unpinning them. This was, as you can imagine, really annoying.
Today, I installed Google's Anti Gravity and after setting it up I started having Gemini analyze the issue. I was able to work out a solution in around 30 minutes! After trying to comb through the Gnome Shell code base for over a year. I had totally missed the issue. By consolidating all of my App Icons into about a dozen Folders I had created a bottle neck for Gnome Shell. It was actually and easy work around after I found out what the issue was.
This was a hard to find bug in Gnome 50. I would have likely never found it by manually pouring through the source code. I am very happy to have my system performing up to specs now. I really do love Anti Gravity! Best new tool of the year for my toolbox!
We are currently in the middle of a massive agent gold rush, with everyone stringing together task-specific bots, writing complex prompt chains, and orchestrating multi-agent frameworks to automate everything from code generation to workflows. But if you look closely at where these systems bottleneck, it becomes obvious that agents are just a transitional technology. They are the scaffolding. The real endgame is digital twins.
To understand why, you have to look at the structural limits of how we build and deploy these systems.
An agent is fundamentally a transactional construct. It is essentially a function-call loop wrapped around a language model, where you provide a system prompt and a set of tools, and it executes a bounded task before stopping or waiting for the next trigger. Because of this, agents suffer from severe context fragmentation. When you build a multi-agent swarm—such as a researcher handing off to a writer, who then hands off to a coder—they do not share a continuous reality. They just pass serialized text back and forth across brittle boundaries, losing nuance, intent, and implicit state along the way. You end up spending a ridiculous amount of engineering effort writing glue code and re-steering prompts just to keep the swarm from drifting off course.
A digital twin approaches the problem from the exact opposite direction. Instead of starting with a transient task, it starts with persistent state, identity, and continuous memory. A digital twin does not ask what tool to run next to complete a prompt; it acts as a persistent state engine that continuously models a real-world entity—whether that is a human operator, a complex codebase, or an entire infrastructure stack—retaining full historical context and behavioral constraints in real time.
This also changes how we handle execution. Agents are reactive by design, waiting around for a webhook, a prompt, or a cron job to fire before scrambling to execute a workflow. Digital twins introduce a predictive, simulation-first paradigm. Because a true twin maintains a high-fidelity mirror of its environment, you stop relying on fire-and-forget automation. Instead of just telling an agent to push a change and hope for the best, a digital twin architecture lets you run simulations against historical data and edge cases, find the failure points in a sandbox, and execute the optimal path autonomously. You shift from brittle task execution to high-certainty state transition.
Right now, developers are trying to patch the agent memory problem with vector databases and RAG pipelines bolted onto stateless models. While those help, they treat memory as an external lookup table rather than a core property of the system. A digital twin treats memory, logic, and execution as an integrated whole, where the identity layer is an evolving state machine rather than a paragraph stuck in a system prompt.
Ultimately, agents are the micro-services of this era—valuable, modular building blocks for executing specific workloads. But they are too fragmented and short-lived to form a cohesive autonomous future. The architecture we should actually be building toward consists of persistent, stateful digital twins that can spawn, manage, and coordinate tactical agents as mere sub-routines of a much larger, unified system.
When you move past the chat-bot phase of AI and look at a true personal digital twin, the shift is from a tool you talk to into an operational proxy that acts as you.
Instead of waiting around for prompts, a personal digital twin acts as a continuous, stateful extension of your identity, running in the background across your local workstation, cloud services, and real-world infrastructure.
Here is what that actually looks like in practice.
Continuous Environmental and Contextual Awareness
Right now, every AI interaction starts from zero. You have to explain who you are, what project you are working on, and what your preferences are. A digital twin maintains a persistent state model of your day-to-day reality. It tracks the active codebases you are building, your communication patterns, your schedule, and your current priorities. When an event happens—a pull request opens, an email arrives, or a deadline shifts—the twin evaluates it instantly against your real-world context without needing you to manually feed it background info.
Autonomous Proxy Operations and Comms
An agent can draft an email if you tell it to. A digital twin handles communication and coordination proactively because it understands your voice, your boundaries, and your ongoing projects. It can triage inbound communications across your channels, negotiate scheduling, and handle administrative back-and-forth based on how you actually operate. It doesn't just sound like you because of a few system prompt examples; it writes and responds based on an evolving model of your actual decisions and historical behavior.
Sandbox Simulation Before Execution
One of the biggest limits of current automation is the fear of breaking things. A digital twin changes that by introducing sandbox simulation. If you want to deploy a new infrastructure configuration, refactor a complex system, or launch an automated marketing pipeline, your twin can simulate the entire execution path first against your historical data and constraints. It stress-tests the logic, flags potential failure modes, and models the outcomes in a secure environment before anything touches production.
Cross-System Orchestration
Right now, we use a dozen disjointed apps that don't talk to each other well. A digital twin acts as the central nervous system connecting your local machine, your cloud environments, and external APIs. It can spawn, manage, and coordinate tactical sub-agents to handle specific workloads—one agent spinning up a research crawl, another handling local file management, another writing boilerplate—while the twin itself maintains the macro-level vision and ensures nothing drifts off course.
Ultimately, a personal digital twin isn't something you prompt. It’s an autonomous mirror of your operational workflow that absorbs the friction, handles the execution, and scales your capabilities without requiring constant babysitting.#ai #webdev #devops #architecture #software #coding #development #engineering #inclusive #community
Why "Agents" Are Just the Bridge: Digital Twins Are the True End State of AI