Hey everyone!

I've been working on a small PHP library called AmunCode Config, and I'm sharing its first stable release.

The idea is simple: provide a lightweight, framework-independent way to load environment variables, load PHP configuration files, and access configuration values without introducing a large framework or unnecessary abstractions.

What does it provide?

The package currently has four main classes:

• EnvironmentLoader — loads .env files using PHP dotenv, with optional or required file loading.
• Env — retrieves environment variables from $_ENV, $_SERVER, and getenv(), with automatic value normalization.
• ConfigurationLoader — discovers and loads PHP configuration files from a directory.
• Config — provides dot-notation access to configuration values, including retrieving, updating, and recursively merging configuration arrays.

A quick example

use AmunCode\Config\Config; use AmunCode\Config\EnvironmentLoader; // Load environment variables. $environment = new EnvironmentLoader(); $environment->load($root); // Load PHP configuration files. $config = new Config($root . '/config'); // Retrieve configuration values. $appName = $config->get('app.name', 'My Application'); $dbHost = $config->get('database.host'); // Update configuration. $config->set('app.debug', true); 

A few design decisions:

• Environment loading and configuration loading are separate operations.
• Environment variables are not overwritten by .env values when already defined.
• Empty environment values are preserved rather than silently replaced by defaults.
• The package doesn't automatically define a global env() helper.

Technical details

• PHP 8.4.1+
• Symfony Finder
• PHP dotenv
• Composer package
• MIT License
• PHPUnit tests and GitHub Actions CI

Installation

composer require amuncode/config 

Source code: https://github.com/AmunCode-OSS/Config

Documentation and usage examples are available in the repository README.

I'd appreciate feedback from other PHP developers, particularly on the API design, class responsibilities, and whether anything important is missing or could be simpler.

Thanks for taking a look!

Seasoned developer here, new to Wordpress. While there is lots to like with Wordpress, and the FSE environment, some of the architectural decisions baffle me.

1. While I understand the need for backward compatibility, mangling the "wp-posts" database table to contain everything under the sun, many of which are not "posts" at all, is clumsy at best.

2. Storing pages/scripts/stylesheets/etc in the database (yes the "posts" table), means a developer cannot reasonably use a source code control system like git to manage source code - an absolute requirement when bugs are introduced and things need to be backed out.

3. On top of these issues, every version of every page/script/stylesheet is stored in the database. Not in a way that you can easily revert back to a known/tagged version, but in a way that just bloats the database in a way that you are only using a small fraction of it at runtime, the rest is just dead baggage.

Hey r/reactjs!

I got tired of constantly opening browser DevTools, filtering out noisy browser extensions, and switching between tabs just to check local storage or quick fetch responses during local development.

To solve this, I built React Dev Companion — a lightweight, zero-dependency developer tools overlay that embeds directly into your React / Next.js application UI.

💡 Key Features:

• Real-Time Network Interception: Intercepts native window.fetch non-invasively to capture HTTP methods, endpoints, and status codes.
• Storage Inspector: Switch between localStorage, sessionStorage, and cookies to view, inject, or delete keys in real-time.
• Zero Extra Dependencies: Designed to keep bundle overhead minimal.
• Dev-Only Friendly: Easy to mount conditionally (e.g., inside Next.js Root Layout or Vite main component).

🔍 Quick Example (Next.js App Router):

```tsx 'use client'; import { DevCompanion } from 'react-dev-companion';

export default function RootLayout({ children }: { children: React.ReactNode }) { return ( <html lang="en"> <body> {children} {process.env.NODE_ENV === 'development' && <DevCompanion />} </body> </html> ); } ```

We set up a strict CI/CD pipeline using GitHub Actions, TypeScript, Conventional Commits, and Husky to keep the codebase clean.

🐙 GitHub Repository: https://github.com/Kickz1nn/react-dev-companion
📖 Dev.to Article: https://dev.to/kickz1nn/building-an-embeddable-zero-dependency-devtools-panel-for-react-nextjs-3ic6

I'd love to hear your thoughts, feedback, or any features you'd like to see added next!

Burrow is a personal-data desktop app (budget, journal, todos, habits, notes). The stack is a Vite and React frontend, a Node server that owns a single SQLite database, and a Tauri shell that packages the two into a Windows installer for x64 and ARM64.

Things in the repo that might interest React devs:

- A hard JavaScript bundle budget enforced in CI, with the number pinned in a test so it cannot creep.

- Visual regression baselines regenerated on a side branch in CI rather than committed from dev machines.

- Modules are isolated under src/modules and server/modules with a small shared envelope for API errors.

- The assistant UI streams from a local Ollama server, so no API keys anywhere in the app.

It went free this week and the core is AGPL. Links in the comments.

I’m just wondering if people still are with them and if they switched. Would love to know where you guys switched if u did

Hi

Suddenly today I have a lot of delay sending and receiving mail from goddady.

Any help? What can I do?

Thanks

Hey everyone!

I'm looking for any websites or discussion forums that talk about design patterns, or really any cool features for web development. Etc, manipulating CSS in interesting ways to get cool designs, interesting things you can do with JavaScript etc..

I'm a bit tired of looking at AI responses and would love to hear if there's anything out there!

TypeSQL type-checks SQL strings in TypeScript. The compiler parses the SQL itself and checks it against your schema type, so there are no generated files, no build step and no database connection.

// rows is { email: string; title: string | null }[] // The LEFT JOIN makes title nullable. const rows = await sql( `SELECT u.email, p.title FROM users u LEFT JOIN posts p ON p.author_id = u.id WHERE u.id = ${sql.param(userId)}`, ).execute(); // Compile error: column "emial" does not exist. Perhaps you meant the column "email"? sql("SELECT emial FROM users"); 

It supports PostgreSQL, SQLite, MySQL and MariaDB, and the runtime is under 3 kB with no dependencies. The main catch is that it needs TypeScript 7.1 or later (7.1.0-beta works), and very large queries can hit the compiler's limits (workaround-able using sql.as<>())

I used AI coding to build this. To keep the output honest, each bug fix gets a permanent test project, and the 100+ scenario tests run against real PostgreSQL, MySQL and MariaDB servers. I will try to keep it non-slop.

GitHub: https://github.com/ismailkarsli/TypeSQL Docs: https://typesql.karsli.net

I am new to web design, and I am new to Figma, and I want to redesign a website. The website uses some template that I need to design within. The template consists of a logo, a banner and some navigation. I will be able to design what I need underneath this.

I want to take a screenshot of the top of this template to place into a Figma document, though I want the sizing to be accurate.

Please pardon my ignorance:

1. What is the best way for me to get an accurate idea of the current resolution of the website? If I just take a screenshot of the header template isn't that just going to be based on the resolution settings on my display?

2. Is there some way to view the source code to see the actual dimensions of the template content?

Thanks in advance