标签：#RAM

submitted by /u/ErneuerbareEnergien [link] [留言]

submitted by /u/FlukeHawkins [link] [留言]

submitted by /u/lukehaas [link] [留言]

submitted by /u/Successful_Bowl2564 [link] [留言]

Hi everyone, I would like to introduce Portivo Control Center , an independent, open-source and self-hosted network operations platform designed for compatible Alcatel-Lucent Enterprise OmniSwitch environments. Portivo brings everyday switch management, troubleshooting and controlled automation into a single web-based workspace. Key capabilities include: Centralized switch inventory and live operational visibility Logical port-panel views with VLAN, PoE, media and link-state information Endpoint discovery using MAC, IP, hostname, UNP and VLAN evidence Integrated browser-based SSH terminal Controlled command preview and execution Multi-device jobs and reusable automation runbooks Fleet-wide read-only operational audits Role-based access control with Site and Group scope Audit history, reports and operational evidence SNMPv3 UPS monitoring and power-aware infrastructure visibility Backup, restore and administration tools Windows and Linux deployment support Portivo is intended to complement native CLI expertise, not replace it. The objective is to provide network operators with a safer and more consistent workflow for discovering, diagnosing, executing and documenting network changes. The platform is self-hosted, does not require agents on managed switches and can operate inside a protected management network. Switch operations use SSH, while supported UPS monitoring uses SNMPv3. The project is licensed under AGPL-3.0-only . Website: https://portivo.org/ Documentation: https://portivo.org/docs/ Roadmap and changelog: https://portivo.org/roadmap.html Source code: https://github.com/Donacgreece/Portivo I would genuinely appreciate feedback from network engineers, system administrators and anyone operating ALE OmniSwitch infrastructure. I am particularly interested in feedback about operational workflows, documentation, deployment and features that would be useful in real environments. Thank you for taking a look. submitted by /u/Psychological-Top938 [link] [留言]

James Arthur shares why sync is the next frontier in frontend architecture. He explains how extending reactivity to the server with Electric and TanStack DB replaces imperative fetching with declarative data bindings. Learn how query-driven sync and local optimistic updates enable engineering leaders to build insanely fast, collaborative, and agentic applications using their existing stack. By James Arthur

Business workflows can look messy. A lead arrives from a website form. Someone contacts the customer. A follow-up is scheduled. A proposal is sent. The deal either moves forward or becomes inactive. But from a software design perspective, this process can be viewed in a much simpler way: A series of states and transitions. This is one reason CRM workflows can benefit from thinking like developers. Every Lead Has a State A lead is not just a row in a database. At any point in time, it has a current state. For example: NEW ↓ CONTACTED ↓ QUALIFIED ↓ PROPOSAL_SENT ↓ NEGOTIATION ↓ WON / LOST Each transition should represent a meaningful business event. This structure makes the workflow easier to understand and reduces ambiguity. Avoid Undefined Transitions Problems appear when teams can move records anywhere without clear rules. For example: NEW → WON Is that valid? Sometimes, maybe. But if a transition skips important steps, the system may lose useful context. A better workflow defines which transitions are expected: NEW → CONTACTED CONTACTED → QUALIFIED QUALIFIED → PROPOSAL_SENT PROPOSAL_SENT → NEGOTIATION NEGOTIATION → WON NEGOTIATION → LOST This doesn't mean every business needs a rigid process. It means the system should make state changes understandable. Events Can Trigger Actions State changes can also trigger workflows. For example: Event: Lead Created ↓ Assign Owner ↓ Create Follow-Up Task ↓ Notify Sales Team Or: Event: Proposal Sent ↓ Schedule Follow-Up ↓ Set Reminder ↓ Track Response This is where workflow automation becomes useful. Instead of expecting users to remember every repetitive step, the system can handle predictable actions. Separate State From History Current state tells you where something is now. History tells you how it got there. For example: Current State: NEGOTIATION That alone is useful. But an event history gives more context: Aug 10 → Lead Created Aug 11 → First Contact Aug 13 → Qualified Aug 16 → Proposal Sent Aug 19 → Negotiation Started

submitted by /u/goto-con [link] [留言]

submitted by /u/NXGZ [link] [留言]

i was recently suffering from finding what are the setups for installing and setup of languages , and this is the result of frustration submitted by /u/Sameer23536 [link] [留言]

InfoQ has opened enrollment for the InfoQ Certified AI-Assisted Engineering Program, a five-week online certification program for senior engineers and architects who already run a coding agent against production code daily, where the open questions have moved past prompting into what the agent is allowed to touch and what catches its mistakes before a human does. By Artenisa Chatziou

submitted by /u/throwaway16830261 [link] [留言]

submitted by /u/vanbrosh [link] [留言]

submitted by /u/throwaway16830261 [link] [留言]

Most developers building frontend applications spend a lot of time writing code that communicates with their backend due to the traditional approach (using APIs). This is not because the logic is hard to implement, but because the communication itself is complex. When using standard APIs, we build routes, define request and response models, generate clients, and keep multiple layers on track with application updates. Instead of exposing backend functionality through REST endpoints and consuming it through HTTP clients, Graftcode exposes backend methods directly and generates packages that applications can install and use as dependencies. The result is a communication model that is like you are calling a library rather than consuming an API with strongly typed clients. Working with Graftcode is very simple: install your library and call its functions. In this article, we'll be building a simple task tracker or to-do list application using React and a TypeScript backend to see what working with Graftcode looks like. In this blog post, we will learn the following: Why API layers require you to maintain APIs manually How Graftcode exposes backend functionality through Graftcode Gateway How Graftcode Vision helps discover backend capabilities Familiarity with APIs and fetch() requests How React applications can use TypeScript backend logic without building API routes Why strongly-typed backend packages can improve developer experience Prerequisites Let’s get our hands a bit dirty, but before we do, there are some need-to-haves to get you started. Let’s have a look at that in this section: Latest Node version installed on your machine Basic knowledge of React and TypeScript Familiarity with how APIs and fetch requests work (for understanding how easy Graftcode’s approach is) A Graftcode account Graftcode gateway installed on your local machine With these prerequisites, you’ll first understand why most to-do list applications rely heavily on APIs for their logic and what c

submitted by /u/Webfuse [link] [留言]

Building in public You explain your deploy setup to your assistant. It helps. Tomorrow you explain the same setup again. And the day after. You are not training it. You are re-typing. The tool nobody asked for I did not set out to build a product. I set out to stop repeating myself. My setup is four servers with names that mean nothing to anyone else, a tunnel with a numbering scheme I keep getting wrong, and a dozen small traps that only exist because of decisions I made two years ago. Every new session started from zero. So I gave the assistant a place to write things down, and a way to read them back before it started working. Two calls: one to save what was learned, one to recall it. That was the whole idea. For six weeks it had exactly one user. Nobody else could have used it, because I had not written a single line of documentation. Six weeks of being my own only customer That stretch turned out to be the most valuable part, and not because of what got built. Because of what got measured. When you are the only user, every rough edge lands on you within a day. A recall that returns the wrong thing costs you the next hour. A save that silently drops a field costs you the next week, when you go looking for it. I kept a count of the times the memory actually prevented a mistake. Not a feeling, a count. After six weeks it was high enough that I stopped arguing with myself about whether the thing was worth the effort. The uncomfortable part: several of those saved lessons were about mistakes I had already made twice. The tool did not make me smarter. It made me stop paying for the same lesson. The moment it stopped being a personal tool The thought that changed it was not a market analysis. It was smaller and more honest: if I find this useful, and my setup is not special, then somebody else is retyping their own servers right now. That is a weak argument on its own. Plenty of internal tools are useful precisely because they fit one person. So I looked for the part

submitted by /u/norman-complete [link] [留言]

submitted by /u/existential_ducks [link] [留言]

📺 Prefer to watch? 90-second YouTube Short · 💬 Telegram Originally published on software-engineer-blog.com . You fixed the CSS. You deployed. You opened the site and checked it yourself — perfect. Then a customer sends a screenshot of last week's layout. Nothing is broken. No deploy failed, no CDN is lying to you, no file is corrupt. The browser is doing exactly what you told it to do, several days ago, in a header you probably never wrote by hand. This is the part of web performance that gets skipped, because caching looks like a setting rather than a contract. It is a contract. And like any contract, the interesting part is not what it gives you — it is what you can no longer do once you have signed it. Throughout this post I will use one running example: PlantPal , a small plant shop. One stylesheet ( app.css ), one logo ( logo.png ), one API endpoint ( /api/products ). The floor: a page load is not one thing Before caching means anything, you have to see what it is acting on. Loading PlantPal's homepage is not a request. It is roughly 40 separate requests — the HTML, the stylesheet, a few fonts, the logo, a dozen product images, the JavaScript bundle, the product API. Each one is a full round trip: DNS is probably warm, but you still pay connection setup, the request, the server's think time, and the bytes coming back. The numbers for a first visit: ~40 requests 1.2 MB transferred 2.1 s to a usable page Which gives us the only sentence in this post that you actually need to remember: The fastest request is the one the browser never sends. Not a faster server. Not a closer edge node. Not a smaller file. No request at all. Everything below is a way of getting closer to that. max-age: buying silence The blunt instrument is Cache-Control : HTTP / 1.1 200 OK Content-Type : text/css Cache-Control : max-age=31536000 31536000 is one year in seconds. You are telling every browser that receives this response: keep this copy and use it for a year without asking me again. O