🔴 AKDENIZ Bölgesinde Bir Deprem Meydana Geldi
📍 Konum: AKDENIZ
📊 Büyüklük: 3.5 ML
⏰ Tarih: 24.10.2026 20:34
🌊 Derinlik: 23.1 km
🔗 Detaylar: https://depremoldu.net/deprem/317762/akdeniz-depremi-2026-10-24
ℹ️ Kaynak: Kandilli
Search
13 results for “deprem”
-
-
Indian exchange CoinDCX confirmed it absorbed a 16 million USD loss after user deposits piled up at deprecated wallets compromised in its July 2025 hack, because an automated sweeping service failed. CEO Sumit Gupta had called early breach reports a false alarm days earlier. https://www.theblock.co/news/business/2026-10-25-coindcx-confirms-16-million-loss-from-retired-wallets-days-after-ceo-called-breach-reports-a-false-alarm-431617 #Web3 #Blockchain #Security
-
We have started to drop more MINGW64 packages, more info on how to migrate away: https://www.msys2.org/news/#2026-10-24-mingw64-deprecation-update
-
The October 23 shutdown got the headlines. Twelve model IDs, one deadline, a lot of us grepping at...#ai #api #openai #webdev #software #coding #development #engineering #inclusive #community
OpenAI's Deprecation Calendar: Nov + Dec + Jan Shutdowns — What to Check Before Each -
La araña con forma de galleta. 🍪
La Box Kite Spider (Isoxya) es una pequeña araña africana de entre 3 y 7 milímetros famosa por su abdomen duro y aplanado que se asemeja a una galleta, la cual tiene espinas laterales para protegerse de los depredadores. 🕷️
#Naturaleza #Nature #MedioAmbiente #Environment #VidaSilvestre #Wildlife #MadreNaturaleza #MotherNature
-
>ansible
>debian 13, with ansible-core 2.19.
>ansible-core EOL next month.
>paramiko "deprecated"They're seriously expecting me to use pipx to install a new ansible that apparently includes "pylibssh". None of this is clear or makes sense; I just want my ssh connectivity to work without a bunch of JSON-formatted warnings (or flat-out errors), and without having to go to war with the firewall people.
-
Weaker Loonie Keeps Euro Summer Affordable for Canadians: Renewed trade tensions between Ottawa and Washington have driven the Canadian dollar down to $1.3855 per U.S. dollar. The depreciation paradoxically maintains affordability for Canadians travelling to Ireland and Northern Europe this season.
https://tnl.st/fty5e7
#article #MilitaryConflict #Finance -
Upgrading FastMCP to 4.1.2 does not close its OAuth credential leak. You also have to pass issuer=.
In 4.0.0 to 4.1.1, the client-credentials and private-key-JWT providers used whatever authorization server an MCP server advertised, so a hostile server could receive your client secret. In 4.1.2, omitting issuer still works, with only a deprecation warning. Set it, then rotate the secret.
-
Hack of the day: When working with ordered datasets, the GNU diff tool can be used for all kinds of filtering and formatting by different combinations of --unchanged-line-format, --old-line-format and --new-line-format. "%L" includes the line in question, and you can omit any output by specifying the given format as "".
For example, only gives lines that the new file omits, but prefixes them with "deprecated_":
diff --old-line-format="deprecated_%L" --unchanged-line-format="" --new-line-format="" old.txt new.txt
There are dedicated tools that allow doing such dataset comparisons, of course, but sometimes you might end up with a limited environment with just very basic tools.
-
Spring AI 2.1.0-RC1 adds message parts across major providers (keeping reasoning and tool calls in order), a new event-log session memory API with JDBC storage, human-in-the-loop tool call confirmation, and support for the pure-JVM jinfer engine. ChatMemory is deprecated for removal in 3.0. 2.0.2 ships too.
https://spring.io/blog/2026/10/23/spring-ai-2-1-0-RC1-available-now
#Spring #SpringBoog #SpringAI #Java #AI -
Once you put a large language model behind a company API gateway, someone asks a simple question.
Who is paying for this?
The model bill arrives as one number. Finance sees one number. Every team in the company sees one endpoint. Nobody can tell you which team burned forty percent of the budget, which use case is growing, or which experiment someone forgot to shut off six weeks ago. That gap between one bill and one endpoint is where metering lives.
We built metering into our LLM gateway before we scaled usage, and it changed how teams behaved. Here is what we learned.
Why LLM metering is not like API metering
With a normal REST API, metering is easy. One request costs one request. You count requests per subscription key, and you are done.LLM calls do not work that way. One request to a chat endpoint can cost five tokens or five thousand. A prompt injection test script someone ran in a loop overnight can spend more than an entire product team's monthly budget in eight hours. If you count requests, you learn nothing. The unit of cost is the token, and the token count lives in the response, not the request.
That detail shapes everything. Your metering code has to read the response body, extract the usage block, and attribute it before the data is gone.
{
"usage": {
"prompt_tokens": 1240,
"completion_tokens": 312,
"total_tokens": 1552
}
}Azure OpenAI returns this on every response. If you do not capture it at the gateway, you have to reconstruct it later from logs, and that is a losing fight.
Capture it at the gateway, not in the app
Every team wanted to do metering in their own application code. We said no. The gateway is the one layer every call passes through, regardless of language, framework, or team. A metering implementation that depends on each team instrumenting their own service is an implementation that covers sixty percent of traffic on a good month.We put a policy on the gateway's inbound path to stamp each request with metadata: the subscription the key belongs to, the product, the environment. On the outbound path, another policy parses the response, pulls the token counts, and ships an event to our analytics pipeline. The policy does not touch the request or response bodies in ways the caller can see. It observes and reports.
<policies>
<outbound>
<choose>
<when condition="@(context.Response.StatusCode == 200)">
<set-body>@{
// parse the usage block and forward a metering event
// key: subscription id, product, environment, model
// value: prompt_tokens, completion_tokens, latency
}</set-body>
</when>
</choose>
</outbound>
</policies>This is pseudo-code, not a real policy file, because every gateway has its own syntax. The shape matters more than the syntax: stamp metadata on the way in, extract cost on the way out, send it somewhere durable.
Attribute everything, including the failures
The first version of our metering only counted successful calls. That lasted about two weeks. Someone ran a batch job against a deprecated model deployment that returned 400s all day. The calls were cheap individually, but there were hundreds of thousands of them, and the model provider still charged for the input tokens on each failed request.Failed requests still consume input tokens. Rate-limited requests still consume them. Requests that hit a content filter still consume them. If you only meter the 200s, your bill and your dashboard will disagree, and finance will believe the bill.
Our outbound policy records every response code. Failures get their own bucket so teams can see them separately, but they are not excluded from the total. The first time a team saw how much they were spending on 400s, they fixed their client code that afternoon.
Give teams their own numbers, not the whole company
A company-wide dashboard that says the LLM bill is fifty thousand dollars a month helps nobody. A dashboard that says your team spent nine thousand, up forty percent from last month, on a specific model, changes behavior overnight.We publish per-team views: tokens and estimated cost by team, by model, by day. The estimated cost part matters. Tokens are abstract. Dollars are not. We maintain a small price table per model and multiply. The estimate is not perfect, and we say that on the dashboard. It is close enough to drive decisions.
The behavioral change was immediate. Teams started batching requests. They cached repeated prompts. One team switched a summarization job from a large model to a smaller one after seeing the per-run cost. None of that happened when the bill was a single line item.
Budgets need teeth, but start with visibility
Once teams can see their spend, the next question is limits. We added budget alerts first, hard stops second. The sequence matters.Alerts went to the team's channel when they crossed fifty, eighty, and one hundred percent of their monthly budget. Most teams self-corrected at fifty. For the ones that did not, a hard stop at the gateway rate-limits further calls until someone raises the budget.
We deliberately did not lead with hard stops. An engineer running a time-sensitive demo who hits a hard limit learns that the gateway is the enemy. An engineer who gets a warning at fifty percent learns to watch their budget. The hard stop exists for the runaway loops, not for normal work.
What we would do differently
Three things we would change if we started over.First, we would meter streaming responses from day one. Token counts arrive at the end of a streamed response, and our first implementation missed them. Streaming became popular faster than we expected.
Second, we would standardize the metadata stamp earlier. We let teams add custom attributes organically, and we ended up with three different keys for the same project name. Normalizing that retroactively was tedious.
Third, we would keep the price table in version control with a review step. Model prices change. When they do, old estimates look wrong. We now treat the price table like code: a pull request, a reviewer, a changelog.
The real lesson
Metering is not a billing feature. It is a feedback loop. The moment teams could see what their calls cost, they started engineering like the cost mattered. Architecture improved. Waste fell. Nobody needed a policy document telling them to be careful with the expensive model, because the numbers told the story better than any document could.If you are standing up an LLM gateway and nobody has asked about cost attribution yet, they will. Build the metering in before the bill becomes a conversation.#ai #azure #devops #apimanagement #software #coding #development #engineering #inclusive #community
Who Is Paying for This? Token Metering at the LLM Gateway -
Last updated: October 2026
Cleaning up AI-generated code means three things, in order: finding out what you actually have, deciding what deserves to survive, and putting guardrails in place so the next batch arrives clean. Most teams start with tooling. The teams that get out of the hole start with triage.
This playbook covers why agent-written code degrades, how to triage an AI-heavy codebase, what the cleanup options actually are, and how to keep the problem from coming back.
Why AI-generated code turns into debt
Coding agents shipped a staggering amount of code in 2025 and 2026. Much of it works. The problems show up later, when somebody has to change it, and they follow recognizable patterns:It's a house of cards. Brittle and inflexible: you can't change one thing without risking the system, so teams cope by never touching it. The code works until the first modification, which is another way of saying it's unmaintained by design.
It can't be verified. Spaghetti structure makes meaningful test coverage nearly impossible to retrofit. Tests that assert the current behavior of tangled code mostly lock the tangle in place.
It buries signal in volume. Agents generate so much boilerplate that reviewers read more code than ever and still miss serious bugs. Review fatigue is a direct function of generated volume.
It hides its own failures. When an agent hits an error, it tends to add another check and retry until the symptom disappears. The root problem stays, with more code piled on top. Grep an agent-heavy codebase for nested try/except blocks around the same call and you'll usually find this archaeology.
It duplicates logic everywhere. The same problem gets solved differently in different places, so one fix leaves copies of the bug behind.
It over-engineers, and it creates dependency. Simple features become frameworks. And when the only party who can maintain the output is the vendor whose agent produced it, you've recreated consulting-firm lock-in with extra steps.
None of this means agents were a mistake. It means generation was never the hard part. Making the result effective, maintainable, and safe to change is the hard part.
Step 1: Triage before tooling
Before touching any cleanup tool, map the blast radius. Three questions per module or service:- Does it carry business logic that must survive? If yes, it needs behavior-preserving treatment, not a rewrite from vibes.
- Does anything else depend on it? Duplicated logic means a fix in one place can leave the bug alive in five others. You need the call-site map before you need the refactoring tool.
- Can you verify it today? If there's no way to prove behavior is preserved, any cleanup is a gamble. Verification capability, not code quality, is what separates "refactor it" from "replace it".
The output of triage is a split: code worth fixing in place, code worth replacing wholesale, and code to quarantine and stop touching until one of the first two becomes possible.
Step 2: Pick the right class of tool for each bucket
Different cleanup jobs need fundamentally different tools, and most bad outcomes come from using one class for another's job.Rule-based refactoring engines (OpenRewrite and its ecosystem, Codemod and the jscodeshift lineage for JS/TS) excel at mechanical, repeatable transformations across large codebases: dependency upgrades, API migrations, pattern rewrites. They're deterministic and auditable. They won't untangle logic they don't have a recipe for.
Coding assistants (Copilot, Cursor, Claude Code and peers) are effective for local, supervised cleanup: a function here, a module there, with a developer reading every diff. They're the wrong tool for fleet-wide debt reduction, because the review bottleneck that created the problem is still the bottleneck.
Governed migration platforms treat the cleanup as a program rather than a series of edits: a plan a human approves, work shipped as reviewable milestones, and behavior verified against the original system. Morph by Modelcode is built on this model, and its answer to the duplication problem is structural: everything Morph writes is brand new, so a full migration produces a fresh codebase with zero dead code and zero duplicated logic, and on modular migrations everything it delivers is clean while surrounding legacy code stays as is until you migrate it. It also ships the integration tests it used to verify each milestone along with the code, so the verification evidence lives in your repo. The trade-off versus assistants is deliberateness: you get governance and proof, not an autocomplete.
The honest rule of thumb: assistants for spot cleanup, rule engines for mechanical sweeps, governed platforms when the debt is structural and behavior has to be proven, not assumed.
Step 3: Make verified the default state
Whatever tooling you pick, cleanup that doesn't change your process just schedules the next cleanup. The teams that stay out of the hole converge on the same guardrails:- A human-approved plan before generation. Scope, target, and acceptance criteria defined before any code is written, by human or agent.
- Small, reviewable changes mapped to that plan. If a change is too big to review, it's too big to trust.
- Behavioral verification, not just unit tests. Run the old and new paths through the same real journeys and compare what actually happens. A green unit test on tangled code proves little; identical observed behavior proves the thing you care about.
- Evidence attached to every change. The reviewer of record, the tests that ran, the results. When an auditor or a future maintainer asks "why did this change", the answer should already exist.
- You decide the patterns. Which frameworks to standardize on, which to deprecate and throw away forever. The moment the agent decides, you're back in the dependency trap.
FAQ
How do I clean up AI-generated code without breaking things?
Triage first: separate code that carries business logic from scaffolding. Fix in place only what you can verify today; replace wholesale what you can't. Behavior comparison against the original system (same inputs, same observed outputs and side effects) is the only trustworthy safety net for code nobody fully understands.Is AI-generated technical debt different from normal technical debt?
Mostly in velocity and shape. It accumulates faster than human-written debt, duplicates logic rather than centralizing it, and hides failures behind retry layers. The remediation principles are classical; the volume is not.Should I refactor AI-written code or regenerate it?
If it's verifiable and the structure is salvageable, refactor with rule-based tools and supervised assistants. If verification is impossible or duplication is structural, regeneration under governance (approved plan, milestone reviews, behavioral verification) is usually cheaper than archaeology. The deciding question is whether you can prove behavior is preserved.How do teams maintain code written by AI agents long term?
By making verification the default state: integration tests shipped with every change, evidence attached to every merge, and human sign-off as a hard gate. Teams that treat agent output like vendor code (reviewed, verified, owned) maintain it fine. Teams that treat it like finished work don't.#ai #programming #softwareengineering #codequality #software #coding #development #engineering #inclusive #community
Cleaning Up AI-Generated Code: The 2026 Playbook -
There is no single correct interval. What keeps a site both patched and working is a fixed cadence, a fixed order of operations, and a rollback you have already tested. Here is the schedule I would put on a calendar, and exactly what happens inside the maintenance window.
The cadence
WhatHow oftenWhere it runsAnything whose changelog says security fixwithin 24-72 hoursproduction, straight after a backupRoutine plugin updatesonce a month, same day, same hourstaging first, then productionPlugins that touch money (payments, checkout, tax, shipping)once a month, staging plus a test orderstaging first, alwaysMajor version bumps (the first number changes)once a quarter, batchedstaging, changelog read line by lineTheme updatesquarterly, or when there is a fix you actually needstaging; customisations live in a child themeWordPress core security and minor releasesas releasedproductionWordPress core major releasesquarterly, after stagingstaging firstCleanuponce a quarterdelete deactivated plugins you do not use
Two things this table is deliberately not saying.First, "turn on auto-updates for everything" is not a cadence. It is a decision to have changes happen at an hour you did not choose, on a site you are not watching. Auto-update is defensible for small, single-purpose, security-relevant plugins. It is not defensible for anything that renders pages or takes money.
Second, "update whenever the dashboard turns orange" is also not a cadence. It means updates get applied in the ten minutes before a demo, which is the worst ten minutes available.
The 15-minute weekly check
Once a week, look, do not update:- Are there updates flagged as security releases? Those jump the queue.
- Is anything still on the list from last month because you skipped it? Skipping twice is how a plugin ends up three major versions behind and un-updatable.
- Has anything been abandoned? No release in a long time, support threads unanswered, and it is still active. That is a replacement project, not an update.
Everything else waits for the monthly window.
Before the window: pre-flight
Do these five things in order. If any of them fails, the window is cancelled.- Confirm the site works right now. Load the homepage, submit a form, log in. You need a known-good baseline to compare against, and "it was already broken" is a sentence you do not want to say afterwards.
- Note the current state of the error log. Tail the PHP error log and the web server error log. Anything already in there is not caused by the update - write the count down so you can tell new noise from old noise.
- Back up, and prove the backup is readable. A backup you have not opened is a hope. More on this below.
- Write down what is installed. Plugin and theme names plus their current state, so you can pin things back.
- Read the changelogs for the plugins you are about to update. You are looking for three things: a required PHP or WordPress version higher than yours, a line containing "breaking change" or "database", and a jump in the first number of the version.
The backup
#!/usr/bin/env bash
set -euo pipefailSITE=/var/www/example
STAMP=$(date -u +%Y%m%dT%H%M%SZ)
DEST=/backups/$STAMP
mkdir -p "$DEST"# 1. Database
wp db export "$DEST/db.sql" --path="$SITE"# 2. Only the trees updates actually touch
tar -czf "$DEST/wp-content.tar.gz" -C "$SITE" \
wp-content/plugins wp-content/themes# 3. Inventory, so you can pin back later
wp plugin list --path="$SITE" --format=csv > "$DEST/plugins.csv"
wp theme list --path="$SITE" --format=csv > "$DEST/themes.csv"# 4. Prove the archive opens before you need it
tar -tzf "$DEST/wp-content.tar.gz" > /dev/null
echo "backup ok: $DEST"Three details that make the difference between a backup and a decoration:
- Store it off the server. A backup sitting next to the site disappears with the site.
- Record the timestamp in the change log, because in a panic nobody remembers which backup is the right one.
- Restore it once, on staging, before you need it in anger. A restore you have never performed is a hypothesis.
Order of operations inside the window
Update one thing at a time and look at the site between each step. Batches hide the culprit.- Deactivated plugins: delete, do not update. An inactive plugin is attack surface with no benefit.
- Low-risk utility plugins first - admin tweaks, log viewers, things the front end does not depend on.
- Content and marketing plugins next - SEO, forms, redirects. Check the front end after this step.
- Anything touching money last among plugins - payments, checkout, tax, shipping. Immediately run a test order in the gateway's sandbox mode.
- Theme last among the code. If the parent theme ships customisations you edited directly, the update will erase them. That is the moment to move those edits into a child theme, not after.
- WordPress core major releases after everything else, never in the same window as a theme rewrite.
If a page builder is in play, update the builder and its addons in the same window. Updating the builder today and the addons next week is how you get the half-broken layout that takes three days to diagnose.
After each step, purge cache
Object cache, page cache, and CDN, in that order. A stale object cache after an update produces bugs that do not exist in the code, and you will spend an hour chasing them.The smoke test
Run the same list every time, in the same order:- Homepage loads, no PHP warnings printed.
- One page built with the page builder renders correctly.
- A form submits and the submission actually arrives somewhere.
- Checkout completes with a sandbox test order.
- Login works, including the password reset email.
- Search returns results.
- One product or post page renders.
- The site looks right at mobile width.
- The error log has no new lines since step 2.
Rolling back: three levels
Pick the smallest level that fixes the problem. Most incidents stop at level one.Level 1 - files only
Use when: the plugin broke rendering, threw a fatal error, or started a redirect loop, and it did not change your database.SITE=/var/www/example
STAMP=20260115T030000Z # the backup from before the update
PLUGIN=broken-pluginwp plugin deactivate "$PLUGIN" --path="$SITE"
rm -rf "$SITE/wp-content/plugins/$PLUGIN"
tar -xzf "/backups/$STAMP/wp-content.tar.gz" -C "$SITE" "wp-content/plugins/$PLUGIN"
wp plugin activate "$PLUGIN" --path="$SITE"Why not just reinstall the plugin from the directory? Because the directory serves the current release. The only reliable copy of the version you were running is the folder you saved before updating. This is the single strongest argument for keeping the pre-update archive.
Level 2 - files and database together
Use when: the update ran a migration - created tables, changed columns, converted content - and the old code will not work against the new schema.SITE=/var/www/example
STAMP=20260115T030000Z# Save the current state first. You are about to lose everything since the export.
wp db export "/backups/emergency-$(date -u +%Y%m%dT%H%M%SZ).sql" --path="$SITE"# Then restore files and database together.
rm -rf "$SITE/wp-content/plugins/broken-plugin"
tar -xzf "/backups/$STAMP/wp-content.tar.gz" -C "$SITE"
wp db import "/backups/$STAMP/db.sql" --path="$SITE"Say the cost out loud before you do this: a database restore also rolls back orders, form submissions, comments, and posts created after the export. Take the emergency export first, then work out what needs to be re-entered. Restoring files without the database, or the database without the files, leaves you with a mismatched site that fails in new and creative ways.
Level 3 - full restore from a host snapshot
Use when: the site is down, the admin is unreachable, and you cannot get a shell in fast enough to do level 1 or 2 by hand. This is the slowest and bluntest option. It works, and it costs you everything written since the snapshot.Roll back or fix forward?
SymptomDo thisWhite screen, fatal error, admin unreachableroll back now, debug on stagingLayout broken on some pagesroll back, then check builder/addon pairingCheckout or form brokenroll back immediately, then investigateA deprecation notice in the log, site works finefix forward, do not roll back for noiseNew feature has a bug, vendor already shipped a patchfix forwardNew feature has a bug, no patch, site workswait, do not roll back a working sitePlugin migrated data and then brokeroll back files and database together, level 2
Two rules of thumb. Roll back when the site is losing money or is unreachable. Fix forward when the only symptom is a log line and the functionality works.Traps worth writing on the wall
- Testing on staging with the live payment gateway. Use sandbox mode, or you will test the payment flow by charging a real card.
- Forgetting the staging URL rewrite. After importing production into staging, run a search-replace from
example.comtostaging.example.comwith a dry run first. Skip it and you will be clicking links back into production. - Updating during a campaign, a launch, or a Friday afternoon. The window exists for a reason.
- Editing the parent theme directly. The next theme update deletes your work with no warning and no undo. Child theme, always.
- Updating a plugin that nothing else depends on, then leaving it untested for a month. The bug report arrives when nobody remembers what changed.
- Never removing anything. A site with forty plugins, twelve of them deactivated, is harder to update, harder to back up, and harder to reason about.
- Skipping the same update three months in a row. The eventual jump is bigger and riskier than three small ones would have been.
The whole process on one page
- Weekly: look for security releases and abandoned plugins. Do not update.
- Monthly, in a fixed window: back up, verify the backup, note the error log baseline, update one at a time from lowest risk to highest, purge cache, run the smoke test, write the change down.
- Quarterly: major version bumps on staging first, theme review, delete what you do not use, restore a backup to prove it still works.
- During an incident: roll back the smallest thing that fixes it, then debug on staging with the broken version pinned.
That is the entire discipline. It is boring, it takes about an hour a month, and it is the difference between a patch you applied and an outage you caused.#security #webdev #wordpress #software #coding #development #engineering #inclusive #community
How often to update WordPress plugins and themes, and how to roll back when it breaks