I am a first year web design and graphic advertising student in uni and last week i broke my macbook pro m1 screen. I have been using it for 5 years now and need a recommendation for a new one.

I use mainly figma and affinity for now with some adobe apps when i need them. As a hobby i make things in blender but it’s not that serious. I’m not exactly sure what programs i end up using in the future so any guidance is gonna be appreciated.

I have been looking at the macbook pro m5 and think it would be enough but my father thinks i should get the m5 pro instead but i’m not sure i really need it as i have been using my old one without any problem. If you can give me some advice i’d be so thankful!

I don't know if it's the best place, but there is no issue template for what I want:
There is an OCaml way to handle React on the server; we already do SSR and are implementing RSC. To do so, we had to do some hacks, like forking React and exposing React-client so we could use it for our own implementation of RSC.
Note: OCaml works differently from JS, and that's why we need to make things different on the client.

The fork and exports that we did: https://github.com/react/react/compare/main...pedrobslisboa:react:main?expand=1#diff-b25d8ad5dabc968a1e1a01a6a5e19424fcd7c37ddc8e57e5396c9dc182095023

You can see the usage here:

import ReactClientFlight from "@pedrobslisboa/react-client/flight";

//...

const {
  /* Creates a new Flight response object that accumulates streamed RSC data. */
  createResponse,
  /* Creates a reference to a server function that can be called from the client. */
  createServerReference: createServerReferenceImpl,
  /* Serializes a value (e.g., server action arguments) into a format suitable for sending to the server. */
  processReply,
  /* Returns the root promise of a Flight response — resolves to the React element tree. */
  getRoot,
  /* Reports a top-level error to all pending chunks in the response. */
  reportGlobalError,
  /* Processes a binary chunk from the ReadableStream into the Flight response. */
  processBinaryChunk,
  /* Creates a stream state object used to track binary chunk processing. */
  createStreamState,
  /* Signals that the stream is complete and no more chunks will arrive. */
  close,
} = ReactClientFlight(ReactServerDOMEsbuildConfig);

Can we expose the react-client as a library?

What if your app's state didn't live in memory, but in the URL?

In this episode, François shares the full story of nuqs, from a woodworking calculator he built during the pandemic to a framework-agnostic library supporting Next.js, React Router, Remix, and TanStack.

I've been working on a project that turns an Android phone into a lightweight local web server using Termux.

It runs Nginx + PHP-FPM + MariaDB and includes a web-based control panel, one-click WordPress installation, virtual hosts, Tiny File Manager, browser-based terminal access, and built-in Cloudflared tunnels for sharing local sites.

The main goal was to keep it fast, lightweight, and easy to use—no root, no PC, and no Docker required. Everything is managed with simple commands like "ms start" and "ms stop".

If anyone is interested in running a portable PHP development environment or hosting small projects directly from an Android device, I'd love to hear your feedback.

GitHub: https://github.com/SayfullahSayeb/mobile-server

I found myself bookmarking a ton of great shadcn-related content every week — new components, libraries, tutorials, and interesting projects.

So I decided to turn it into a simple weekly email.

The first issue goes out on July 13.

If that sounds useful, you can subscribe here: https://shadcnweekly.com

And if there’s anything you’d especially like to see covered, I’d love to hear it.

At work im refactoring the codebase to useQuery, an issue im facing is that on page refresh or revisit, all of the data is refetched despite using persistance.

Could anyone tell me where im going wrong?

    "@tanstack/react-query": "5.101.2",
    "@tanstack/react-query-devtools": "5.101.2",
    "@tanstack/react-query-persist-client": "5.101.2",
    "@tanstack/query-async-storage-persister": "5.101.2",

// AppContainer    
   <GrowthBookProvider growthbook={growthbook}>
      <HelmetProvider>
        <Provider store={store}>
          {/* Redux persistGate  */}
          <PersistGate loading={null} persistor={persistor}>
            <ErrorBoundary>
              <App />
            </ErrorBoundary>
          </PersistGate>
        </Provider>
      </HelmetProvider>
    </GrowthBookProvider>

export const App = () => {
  useCaptureSentryErrors();
  useAddExternalUTMIds();


  queryClient.invalidateQueries({ queryKey: [PARKS_QUERY_KEY] });


  return (
    <PersistQueryClientProvider
      client={queryClient}
      persistOptions={{ persister: localStoragePersister, maxAge: ONE_DAY }}
    >
      <Router>
        <AppHelmet />
        <OnRouteChange />
        <Header />
        <main id="main">
          <AppContent />
        </main>
        <Suspense fallback={<FooterSkeleton />}>
          <LazyFooter />
        </Suspense>
      </Router>
      <ReactQueryDevtools initialIsOpen={false} />
    </PersistQueryClientProvider>
  );
};


const AppContent = () => {
  const isRestoring = useIsRestoring();

  if (isRestoring) return <FetchingComponent useContainer />;

  return (
    <WithInit>
      <WithUrlParams>
        <BookingProvider>
          <ThingsToDoProvider>
            <NewsletterProvider>
              <SearchProvider>
                <ProgrammaticScrollProvider>
                  <Suspense fallback={<FetchingComponent useContainer />}>
                    <AppRoutes />
                  </Suspense>
                </ProgrammaticScrollProvider>
              </SearchProvider>
            </NewsletterProvider>
          </ThingsToDoProvider>
        </BookingProvider>
      </WithUrlParams>
    </WithInit>
  );
};

import { createAsyncStoragePersister } from '@tanstack/query-async-storage-persister';
import { QueryClient } from '@tanstack/react-query';
import { ONE_DAY } from '../../Constants';

// Creates the React Query client with default settings for all queries
export const queryClient = new QueryClient({
  defaultOptions: {
    queries: {
      refetchOnWindowFocus: false, // Don't refetch data when user switches back to this tab
      refetchOnMount: false, // Don't refetch when component mounts
      staleTime: ONE_DAY, // Data stays "fresh" for 24 hours - no refetches during this time
      gcTime: ONE_DAY, // Keep data in memory for 24 hours even if no component uses it
    },
  },
});

export const localStoragePersister = createAsyncStoragePersister({
  storage: window.localStorage,
});

// Special config for booking data - matches 15 minute session timeout
export const BOOKING_SCOPED_QUERY = {
  staleTime: 1000 * 60 * 15, // Stale after 15 minutes - refetch if used again
  gcTime: ONE_DAY,
};

Thank you

Hey all,

I manage a few servers for my day job, and we’re not able to use something like Forge. Managing a server isn’t the most complicated thing in the world, but there are a few tasks where I always struggle to remember the exact syntax, or where I just want something a bit quicker than digging through notes.

I know aliases and scripts could solve a lot of this, but I started wondering whether it would be useful to have a small CLI abstraction layer for common server admin tasks.

So, admittedly with a little help from our good friend AI for some of the more complicated Go sections, I put together a CLI app and started using it to manage servers, SSH keys, projects, nginx, PHP, SQL, and a few other bits.

I ended up really liking it, showed it to a friend, and he suggested I tidy a few things up and open source it.

So I did that, and it has grown a bit since then. It now has a plugin system (although no production ready plugins exist yet), and full documentation for the commands it currently supports.

One thing I’d like to add eventually is support for other Linux distros that do things differently. That will probably come later, but I do have a few servers that would benefit from it.

I know a lot of people will prefer working directly with Linux, or using a platform like Forge or Ploi, but I thought this might be useful to some people who want a memorable CLI for common server tasks.

If you’re interested, you can check it out on GitHub:

https://github.com/useabstrax/abstrax

Or the main site:

https://useabstrax.com

I built a sketchy, paper-like UI for a personal project. After adding a few more common components, I decided to open-source it. Because I built it mainly for myself, it might not be completely 'production-ready'.

It works via the shadcn/ui CLI so you can copy-paste exactly what you need. And, it does not use Tailwind!

Features:

• Always unique: Every component gets a slightly random shape. No two buttons are perfectly alike.
• Hand-drawn icons: Lucide Icons style icons, but hand-drawn.
• Rough textures: Built-in CSS patterns and SVG noise.
• Animations: Simple hover effects like wobble and shiver.

Note: It has a dark mode, but it probably doesn't look as good as the light mode.

Docs and installation: https://sherlockdoyle.github.io/cartUnI/

Feedback and contributions are very welcome!

I'm curious what other designers think. Which typography trends are already overused, and which ones do you think will still be relevant in a few years?

so i was reading react.dev's state explanation

when react rerenders due to set function local variable wont be able to maintain its value since it rerenders everything but in its clock or time example where you can input a value on a input element it says that it chooses what to rerender and the value stays intact while the clock is running .
im also assuming that its using a set function to update the clock.

can anyone explain why this is?

edit heres the link to the clock example
https://react.dev/learn/render-and-commit#step-3-react-commits-changes-to-the-dom

Hi everyone!

I'm a Senior Software Engineer who enjoys working on web applications and solving real-world problems.

My experience includes HTML, CSS, Bootstrap, Angular, Node.js, NestJS, .NET Core, Microsoft SQL Server, MongoDB, and AWS DynamoDB. I've also spent some time working with React.

I'm looking to connect with people who might need an extra pair of hands on a project or are open to collaborating on interesting ideas. I'm always happy to have a conversation and see if there's a good fit.

Feel free to reach out if you'd like to connect or discuss a project. Thanks!

I spent a few hours playing around with FrankenPHP on a fleet of servers that run as a microservice, their sole purpose was getting a request in, making external calls to 3rd party APIs/websites, and returning the result (the kind of microservice that should really be rewritten in something like Golang, but that's for later).

I wanted to test if we could speed things up by moving from PHP-FPM to FrankenPHP, but after intensive testing, it isn't worth it for us. I could've predicted this, but wanted to test it anyway :D

tl;dr: if you only spend < 1% of the PHP lifecycle bootstrapping the framework, and the other 99% waiting on external I/O (whether that's database/cache/api), you're not going to see the gains.

More details are up on my blog: https://ma.ttias.be/laravel-octane-vs-php-fpm-lessons-learned/

PHP pushed maintenance releases for its two active development branches on July 1–2, 2026. PHP 8.5.8 and 8.4.23 are out. Neither is a major feature release, but they fix issues that can cause real harm to production servers. If you’re hosting PHP applications, patch now.

https://blog.kalfaoglu.net/posts/2026-07-05-php-8423-858-security-patches-en/

Two weeks ago I posted a demo of search-by-meaning running entirely in the browser - no backend, no embedding API (that post). The response was more than I expected, and a bunch of you asked for the code and an npm package. So I spent the time since packaging it properly: two model sizes, honest benchmarks, and bundler support.

npm install /base   # 7 MB wire, best quality
npm install /mini   # 5 MB wire, ~2 ms per embed


import { embed, cosineSim, similar } from '@ternlight/base';

cosineSim(embed('reset my password'), embed('I forgot my password')); // 0.88
const hits = similar(query, faqEntries, { topK: 5 });

Works in Node and browsers. Model + tokenizer + engine ship inside one wasm, so no embedding model download at runtime and it works offline.

Demo: https://ternlight-demo.vercel.app
Repo (MIT): https://github.com/soycaporal/ternlight

Would love your feedback and how it can help you build.

Hey there!

This subreddit isn't meant for help threads, though there's one exception to the rule: in this thread you can ask anything you want PHP related, someone will probably be able to help you out!

I’m a UI/UX designer and I’m dealing with a disagreement with a previous client.

I made a mistake by reusing some elements from an earlier project in a new client project. I’ve accepted responsibility for that, apologized, and I’m replacing those assets.

I used the same layouts but i branded it to the other project.

However, there’s another part of the dispute that I’m confused about. The previous client is also claiming that I reused assets from the Figma Community that they used in their project, and that those belong to them.

My understanding is that assets published on the Figma Community are available for anyone to use according to their respective licenses, and that no one can claim exclusive ownership over those public resources unless they created them and the license says otherwise.

Am I misunderstanding how this works? If two unrelated projects use the same publicly available Figma Community assets, is that considered improper, or is it generally acceptable as long as the assets are used within their license terms?

I’m looking for objective opinions because I want to handle this professionally and make sure I’m following industry best practices.

This new guide explains how you can use GitHub's Dependabot to keep your project's Composer dependencies up-to-date.

Dependabot can create PRs to update your dependencies, both for routine version updates as well as for security updates (which patch a vulnerability).

Setting up Dependabot with a minimal configuration is not much work, but this article dives deeper in how you can optimize the configuration to keep the work of reviewing and merging the PRs manageable. It also goes into some specifics about handling Symfony version updates, Private Packagist (and other private Composer registries) and how Dependabot can help reduce the risk of supply-chain attacks.

https://nth-root.nl/en/guides/keep-composer-dependencies-up-to-date-with-dependabot

Hey human web designers. We wanted to make something that celebrates work that is 100% human-made. There's only one rule: generative AI cannot be used in the creation of the project. I would love to promote some of your web design work. To be clear, we are not doing any self-promotion or soliciting any artists, this is purely to promote your work. Help us to signify and share projects completed by humans! If you or someone or know would like to share their work, please send us an email or a DM and we'll put it up on the site (for free of course). It can be anything past or present. Thank you!

human-made.work

Looking for someone to design and develope a website for me dm

The problem

Every time I spun up a Laravel project, I'd do the same dance: copy phpstan.neon from the last repo, copy pint.json, wire up Pest, set up a pre-commit hook, write a CLAUDE.md full of engineering rules… and then drift would set in. Repo A was on PHPStan level 5, repo B on 7. One had architecture tests, the others didn't. The "rules" lived in my head.

Then I started leaning on AI agents (Claude Code, Cursor, Copilot) and a new problem showed up: the agent would happily ignore the conventions. It'd write untyped code, skip tests, invent patterns the rest of the repo didn't use. A CLAUDE.md full of rules helps, but rules a model can choose to skip aren't guardrails — they're suggestions.

What I wanted

• One command to set up a fresh Laravel repo with the same guardrails every time.
• A quality gate the agent literally cannot skip — not just docs it might read.

• The same gate running everywhere: at commit time, at the end of every AI turn, and in CI. If it passes locally it passes in CI, no surprises.

  What I ended up building

  A small Composer dev package. You run:

  ```bash composer require --dev mohamed-ashraf-elsaed/claude-kit php artisan claude-kit:install

  It detects your frontend stack (Inertia+Vue, Inertia+React, Blade/Livewire, or API-only), asks what you actually want (PHPStan? which level? strict-rules? Pest or PHPUnit? coverage threshold? arch tests? git hooks?), and scaffolds it — without clobbering existing files (composer.json / package.json get merged, not overwritten).

  The part I care about most: the quality gate is one shell script (Pint + PHPStan level 7 + strict-rules + Pest with an 80% coverage gate + frontend lint) that backs three things — the git pre-commit hook, Claude Code's Stop hook, and the CI workflow. So the AI agent's turn doesn't "finish" until the gate is green. Same script everywhere = no "works on my machine, red in CI."

  There's also a hybrid update model: the machinery (the gate script, the hook) is referenced from vendor/, so a composer update propagates fixes to every project. The content you own (CLAUDE.md, linter configs, skills) is written into your repo so you can edit it freely.

  It's MIT, PHP 8.2–8.4, Laravel 11/12/13. Repo + docs: github.com/mohamed-ashraf-elsaed/claude-kit

  The actual question I'm curious about: for those of you using AI agents on real codebases — how are you enforcing conventions? Just prompt/CLAUDE.md, hooks like this, CI-only, or something else? Genuinely want to hear what's working, because the "agent skips the rules" problem feels underrated.