Mert

Today I learned that creating a table is only the first step in SQL. Sometimes, after creating a table, we may realize that we need to change some rules. For example, maybe a column should not allow empty values, or maybe we want to add a new constraint later.
For this, SQL gives us an important command called ALTER TABLE.

ALTER TABLE is used when we want to change the structure of an existing table without deleting it and creating it again.

In this blog, I am going to explain different ALTER TABLE tasks in a simple way.

1. Making email compulsory in the customers table
   Suppose we already have a table called customers, and its email column currently allows NULL values. But now we want all future records to обязательно have an email value.

For that, we can modify the column using:

ALTER TABLE customers
ALTER COLUMN email SET NOT NULL;
What this does:
This command makes the email field compulsory from now on.
So, while inserting new records, we cannot leave the email empty.

1. Making username unique in the users table
   In many applications, usernames should be unique. Two users should not have the same username.
   If the table is already created, we can add this rule later using ALTER TABLE.

ALTER TABLE users
ADD CONSTRAINT unique_username UNIQUE (username);
What this does:
This adds a UNIQUE constraint on the username column.
That means duplicate usernames are not allowed.

1. Ensuring product price is always greater than 0
   In the products table, price should never be zero or negative.
   This can be enforced using a CHECK constraint.

ALTER TABLE products
ADD CONSTRAINT check_price_positive CHECK (price > 0);
What this does:
This makes sure the price value is always greater than 0.
So invalid prices cannot be inserted.

1. Setting default status in orders table
   Sometimes when we insert a new order, we may forget to mention the order status.
   In such cases, it is useful to automatically set a default value like ‘pending’.

ALTER TABLE orders
ALTER COLUMN status SET DEFAULT ‘pending’;
What this does:
If no status is given during insertion, SQL will automatically store ‘pending’.

1. Adding a salary column in employees table
   Now let us say we want to add a new column called salary in the employees table.
   The condition is:

• salary should not be NULL
• salary should always be greater than 10,000
  This can be done like this:

ALTER TABLE employees
ADD COLUMN salary DECIMAL(10,2) NOT NULL CHECK (salary > 10000);
What this does:

• This creates a new column called salary and applies two rules:
• it must have a value
• the value must be above 10,000
• Changing foreign key so deleting a department also deletes employees
  Suppose the employees table is connected to the departments table using a foreign key.
  Now we want this behavior:

If a department is deleted, all employees belonging to that department should also be deleted automatically.

Usually, first we remove the old foreign key constraint, then add a new one with ON DELETE CASCADE.

ALTER TABLE employees
DROP CONSTRAINT employees_department_id_fkey;

ALTER TABLE employees
ADD CONSTRAINT employees_department_id_fkey
FOREIGN KEY (department_id)
REFERENCES departments(id)
ON DELETE CASCADE;
What this does:
If a department row is deleted, all matching employee rows are also deleted automatically.

1. Removing an existing CHECK constraint from accounts table
   In the accounts table, assume there is already a CHECK constraint that ensures balance >= 0.
   If we want to remove that rule, we need to drop the constraint.

Example:

ALTER TABLE accounts
DROP CONSTRAINT accounts_balance_check;
What this does:
This removes the check condition from the balance column.

1. Making combination of user_id and transaction_id unique in payments table
   In the payments table, one user_id and transaction_id combination should not repeat.
   This means the pair together must be unique.

ALTER TABLE payments
ADD CONSTRAINT unique_user_transaction UNIQUE (user_id, transaction_id);

What this does:
This prevents duplicate entries with the same user_id and transaction_id combination.

I would like to paint a picture. If it’s familiar, keep reading. If it sounds outlandish and not relatable, this is not the article for you.

You have a small company.

You are winging it from day to day, adapting and iterating with no, or minimal, process.

Everyone talks out loud of process, of predictability, of structure they will eventually implement. But your small team pushes forward with late hours, big over-the-weekend features that come with incremental wins, and while everyone is exhausted, the sentimentality is “at least we don’t have big company culture”. The entire team is vastly intelligent, capable to find patterns and angles on problem spaces that many others can’t see.

Innovation is built in at every step. It’s a core value, as is similar mantras like “have fun” and “employees first” (even though not a single person in the team knows how to maintain “work-life” balance).

You become successful.

You either get a big client or you reach a tipping point on income that allows you to grow ambitious and plan further than one month ahead.

So you grow.

You adopt a framework, the structure you always dreamed of. The word “Agile” got used somewhere in the description, so you call the framework “Agile”. “We are doing Agile now.”

And you slow.

Some of the former powerhouses shift into leadership. Some of the powerhouses remain attached to fast-moving projects that “must happen”. And one or two others move on, attached to “small company culture”. The most vocal quit, either attached to “small company culture” or feeling generally not enabled to provide the value they used to. It’s a huge loss as they were specialists on technology or a specific vertical.

But that’s part of the cost of growth, right?

You keep growing.

You go through a V2 of your “Agile” process that really pins down your process to make sure “quality is baked in at every step”.

To some extent, the “Agile” framework helps. You are able to sustain multiple teams, and as you start measuring velocity, you get an understanding of effort-to-value ratios.

But most of the engineers and some of the management feel like they are focusing on metrics rather than deliverables.

Why are they so caught up with the numbers? They are meant to just be validation, not the product.

Everyone in leadership says that, but when it comes to getting things done, it’s always about the metrics.

Do the numbers themselves look right? You aren’t sure.

You most certainly don’t feel like you’re getting as much done as you had before.

What the Hell Happened?

You switched the motivational framework.

In an unstructured environment, especially in Engineering, motivations come from unsolved, complex problems, novelty, urgency, and personal interest. Responsibility is a byproduct or guiding factor, not a driver.

Throw those motivation factors into a Google search.

I’ll wait.

Additionally, in small companies, there is a lot of agency and freedom to tackle problems that require unrefined requirements to be reduced to logical, repeatable patterns that are represented in a vastly complex system.

Throw “individuals with advanced pattern recognition and rules extrapolation and a pathological need for agency” into that search.

Wait, my Team Isn’t ADHD or Autistic

It’s entirely possible.

But the line for the two diagnoses revolves around “disability”, which, by the social model, is scoped to the relationship between the individual and the environment, not the individual itself. In the right environment, this means symptoms of the disability can (depending on the severity or type of disability) become completely transparent or seem like “just part of the job”.

It’s basically accidental masking by being successful, and it is fairly common.

I have, personally, become fairly convinced that there exists an alarmingly high amount of undiagnosed ADHD and Autistic Leadership in Engineering that are unintentionally masking simply by having found the right environment to fit their motivational framework. This is partly informed by many tech giants speculating that they would likely have been diagnosed as Autistic when younger (see: Bill Gates).

On that point, it’s worth taking a moment to note that this article exists in the space of “Lived Experience” (community discussions/personal experience) and “Emerging Theory” (professional speculation). “Institutional Knowledge” (DSM-5) is far behind the active discussion space (by design).

To give an idea of just how far behind institutional knowledge is, it was just a bit more than a decade ago that the DSM recognized that Autism and ADHD could both be diagnosable in the same individual, and there’s now an estimated ~50% co-diagnosis rate.

The point being that discussions on neurodivergence are moving fast.

What I can confidently say is:
1) Most everyone already knew the Engineering world had a high ratio of neurodivergent representation. There exist studies on this already.
2) Society is going through an unprecedented wave of demasking and diagnosis. (If you’re successful in Engineering, I suggest taking this test https://raads-r.net/ if you have some time to kill)
3) Even for those not severe enough to be diagnosed, Autistic/ADHD traits are present across “neurotypical” society. Those traits are going to be very common in engineering, which requires non-linear and highly cognitive processing. (search: Autistic traits continuous in general population).

How Does this Relate to Agile?

Great guiding question, me!

I would like to call attention to the Agile Manifesto. Not an Agile framework. The core philosophy.

https://agilemanifesto.org/principles.html

In particular:

Build projects around motivated individuals.
Give them the environment and support they need,
and trust them to get the job done.

This is, coincidentally, in line with the current directive for most neurodivergent therapy. Integration, not assimilation. In HR terms, we call it equity.

When you had low process and high agency, with constant stimulation driven by urgency, novelty, and personal passion, you had an environment that appealed to a neurotype that is very powerful when motivated.

This is a neurotype that will often put in 60 hours a week and like it (assuming they are actually motivated). This is a neurotype that will solve complex problems over a weekend that might take others months to even understand.

The misguided lessons society has taught itself about “work-life balance” have led us to adopt the 9-5 workweek, based on the assertion that it would work for everyone and that it’s the box you must fit into to be successful.

Many companies then built a bunch of fancy metrics around this philosophy in a misguided attempt to show just how productive this 9-5 workweek was at driving motivation.

And neurodivergents, in response, invented the mouse wiggler.

In some jobs, time worked is the measurable deliverable.

Engineering is not one of those jobs. You deliver software, not time.

You’re Suggesting 60-hour Weeks are GOOD?

Sustainably? Every week? Absolutely not.

I’ve personally had 60-hour weeks and 10-hour weeks.

I’ve solved months of value in 2 hours, and gone down the wrong rabbit hole for weeks.

AuDHD (Autism + ADHD, that’s me) in particular often comes with a drive to solve problems. I’m either solving a problem or looking for a new problem to solve. Responsibility is a guiding factor, not the engine. Burnout stems from either working on long-term projects out of obligation (and not motivation) or from too little going on (“boreout”).

There’s a bit of nature vs. nurture in the discussion of where that “eternal antsyness” originates. I’d highly recommend doing some research on that if the question “should AuDHD be that way” popped into your head. It’s a fascinating rabbit hole that will show you the bigger picture of just how much society shoots itself in the foot with misleading messaging and expectations.

You Just Implied Velocity Isn’t Constant

I’m not implying.

I’m stating.

The illusion of constant velocity is one of the most harmful lies society tells itself.

Across a team and over a sufficiently long timespan, velocity can approach consistency. But not at a granular, individual level.

There’s an important entry in the manifesto.

Agile processes promote sustainable development.
The sponsors, developers, and users should be able
to maintain a constant pace indefinitely.

And a second one.

Deliver working software frequently, from a
couple of weeks to a couple of months, with a
preference to the shorter timescale.

Preference is for shorter time periods, but the extreme of “day to day velocity” becomes micromanaging (and risks encroaching on the neurodivergent need for agency, which has a high risk for causing burnout and turnover. Search: Pathological Demand Avoidance).

Two-week sprints are generally a good time frame for most teams to average out to a “constant pace”, so those tend to be what get used. I do believe it’s important for a team to have an established contract on their iteration team, especially since time-boxing is such an important concept for ADHD (which often comes with perfectionism).

But ultimately, at an individual level, the smaller the time frame you consider, the harder it is to say “spontaneous bursts of innovation and complex problem solving” and “predictable delivery speed” in the same breath.

There’s a balance.

As a side note, search for “ADHD time blindness”; it will likely explain why you struggle with overcommitting or undercommitting in almost every sprint. Many neurodivergent employees try to plan around their highest velocity rather than their expected velocity. Combine that with a bunch of biology around dopamine dysregulation that I’m not going to get into here, and you get powerhouses that are incapable of predicting just how powerful they will be.

Wouldn’t that Show up in the Metrics?

Enter Autism.

Pattern and rules extraction are our entire thing. (That’s a reductionist statement for the sake of making a point, we have a lot of things, don’t @ me)

Intuition is not intuitive for us. Big-picture thinking (holistic intuition) is often low, while expertise and wisdom (pattern-based intuition) are often higher, but take time to build.

This is by design in Engineering.

You want employees who are cognitive-forward; employees who are missing the caching layer of intuition. It means the problems get properly analyzed (cognition) with very few assumptions made (intuition), and a sustainable solution is implemented. Engineers don’t just write code; they pattern-match and extract rules from requirements.

Intuition would tell you, “Don’t re-invent the wheel.”
Cognition would tell you, “But the wheels we have aren’t built for this terrain. In a few weeks, we can invent the plane.”
(And Intuition might then question, “Why are we even talking about wheels? We build houses.”)

But when we haven’t had time to iterate on the same problem space for long periods (building expertise), we default to repeatable processes and numbers to reduce the problem space to bite-sized, actionable information.

More often than not, this leads to gamifying the numbers. Mouse wigglers, not pulling in extra work when work is done faster, over-pointing efforts, under-pointing efforts, skipping process completely for certain efforts, etc.

In the absence of more concrete directives on deliverables, making sure those numbers look good, min/maxing them, is inevitable. It’s not generally an active decision; it’s just a piece of the puzzle we incorporate into the planning process when everything else is open-ended and doesn’t match a pattern we are familiar with.

This is Still about Agile, Right?

Yes!

The core moment you went wrong, the single “what should we have done differently?” decision point, was picking a singular Agile Framework to prescribe to a full department.

These frameworks often prescribe, or are interpreted as prescribing:

• Low, or no, rollover
• No mid-sprint changes
• Predictable velocity at a granular scale
• All work to be completely scoped before committing
• Time commits on work to be predictable and exact
• Turning Engineers into code monkeys, rather than problem solvers, moving decision-making entirely into other teams (Architects, Product, UX, QA, etc.)

If you look at the core 12 principles of the Agile manifesto, every single one of those bullet points comes back to a misinterpretation of the Agile philosophy.

And most importantly, every single one of those bullet points is incompatible with the neurotypes you have built your team out of.

You have not created an environment for motivated individuals; you have created one for the “neurotypical” mentality, which so few people thrive in. (If you want another fun rabbit hole, search “does the ‘neurotypical’ person exist at the biological level”. Spoilers: It’s a sociopolitical term, not medical. Depending on how you draw a few lines in definitions in ‘normal’, it’s not even a majority.)

Assuming You’re Right, What Do We Do About it?

Be Agile, don’t do Agile.

Provide the right environment.

The manifesto is the important part, not the frameworks.

You need different processes for different types of teams, different types of projects, and different budgets.

I want to call attention to an important entry in the manifesto:

Simplicity–the art of maximizing the amount
of work not done–is essential.

And another one:

The best architectures, requirements, and designs
emerge from self-organizing teams.

One-size-fits-all process is the problem, not the existence of process. Process is important, process enables, process protects. But doing less, quite literally, translates to doing more.

I can personally tell you that when I am mid flow-state on a big project, even transitioning a Jira ticket that carries no perceived value can be enough to break momentum. It’s unbearable. I can physically feel the frustration from it in my veins.

Those without ADHD are likely thinking this is melodramatic. If you know someone with ADHD, ask them. This is a major reason why “context switching” is viewed as a cardinal sin among engineers. Got into the flow in the morning, but was forced into a meeting on a completely unrelated topic? It’s a literal crap shoot on whether I get into that flow again.

Reduce process to only the process that enables development or protects a system.

Highly critical services in maintenance mode require high process. Lesser critical systems require less.

“Must do”, non open-ended work (if you have buckets of work catered to specific important clients, for instance) is good in high process to self-regulate on commits.

If something is greenfield and doesn’t affect production, does it need a full regression test suite and a Jira step for Product approval in a lower environment? Can you just demo on your local machine?

For the other Software Architects out there: Design systems to enable greenfield development to occur out of band from those critical services. This is one of the subtle but most valuable benefits of microservices. It lets you right-size the process.

Another quote:

Working software is the primary measure of progress.

Reduce metrics to those that drive SMART goals. SMART goals are the most empowering weapon for neurodivergent employees, who often crave explicitly defined deliverables (just don’t overprescribe how they get TO those deliverables, see: Pathalogical Demand Avoidance again).

A Couple Other Principles Viewed through the Neurodivergent Lens

Welcome changing requirements, even late in
development. Agile processes harness change for
the customer’s competitive advantage.

Pattern-based and cognitive-forward decision-making takes time. Couple this with the low Implicit Social Cognition you get with Autism (difficulty to intuitively keep up with an ongoing discussion), you get employees who need longer than your 1-hour meeting to think or process.

Sure, you did sprint planning. That was important. You did due diligence on attempting to plan.

Plans are nothing; planning is everything.

An Engineer realizing a flaw in a plan a few days into a sprint is part of the process. Encourage text-based communication for asynchronous planning, which is very neurodivergent-friendly (giving time to right-size communication and process).

Business people and developers must work
together daily throughout the project.

I mentioned Pathalogical Demand Avoidance a few times.

This is the best way to avoid the problem. Make engineers feel involved in decisions. They are specialists on the system you are building, use that, don’t silo it. Studies exist to prove performance gain from engineer engagement, if you need proof. See: https://link.springer.com/article/10.1007/s10664-023-10293-z

The most efficient and effective method of
conveying information to and within a development
team is face-to-face conversation.

This might sound counterintuitive, because many people think of “anti-social” when they hear Autism. If you tried to initiate a discussion about the weather, I might give an awkward smile and do my best to extract myself from the physical pain that is “small talk”.

But when it comes to an area of interest, you can’t shut us up.

The literalness of “face to face” leaves much open to interpretation, but at the end of the day, vocal communication, at the very least (even if just Zoom), is significantly more efficient and effective time-wise. Just define your deliverables going into the meeting and organize the conversations with live note-taking to avoid endless tangents and rabbit-holing.

And finally:

At regular intervals, the team reflects on how
to become more effective, then tunes and adjusts
its behavior accordingly.

This is, coincidentally, how many people with AuDHD simply live their lives. Iterate -> Analyze -> Consult (ideally) -> Iterate. An endless series of “focus hard, then reflect”.

That, at its core, is what you’re aiming for with being Agile.

Well, I’m Neurodivergent, and I figured it out, they Can Learn to Push Through it Just like I did

I want to call this out since I’ve actually heard it said, specifically in the context of prescriptive Agile frameworks.

This is the equivalent of telling someone with severe depression, “just smile like the rest of us”. It’s a form of generational trauma, has ableist undertones, and risks violations of ADA directives on handling ADHD and Autism as a disability.

The world’s take on “undue hardship” and equity in ADHD/Autism is shifting. There are already successful lawsuits on underplaying the severity of mental disabilities in the workplace (including the usage of derogatory words like “lazy” or “disorganized”).

Do some searching. Educate yourself. Become powered by neurodiversity, not disabled by it.

Most AI agents handle web blocks the same way: hit a wall, throw a CAPTCHA solver at it, hope for the best.

The problem? Half the time it’s not a CAPTCHA.

I’ve been building GateSolve, a CAPTCHA solving API for AI agents. And the most common failure pattern I see is agents submitting solve requests for pages that aren’t actually blocked by a CAPTCHA.

They’re blocked by:

• JS challenges (Cloudflare interstitials that auto-resolve in 5-10 seconds)
• Auth walls (login pages that need credentials, not CAPTCHA tokens)
• Silent blocks (403 responses with no CAPTCHA at all)
• Rate limits (429 responses that just need a backoff)

Solving a CAPTCHA on an auth-walled page does nothing. You burn credits and get nowhere.

The Fix: Classify Before You Solve

I built a free endpoint that classifies any URL’s access block:

curl "https://gatesolve.dev/api/detect?url=https://example.com"

Response:

{
  "url": "https://example.com",
  "classification": "public-ok",
  "httpStatus": 200,
  "solvable": false,
  "confidence": 0.9,
  "details": "Page accessible, no blocks detected",
  "recommendation": "No action needed. URL is publicly accessible."
}

The classifications:

Real Example: CAPTCHA Detected

When a real CAPTCHA is found:

{
  "url": "https://some-protected-site.com",
  "classification": "captcha",
  "captchaType": "cloudflare-turnstile",
  "httpStatus": 403,
  "solvable": true,
  "confidence": 0.9,
  "recommendation": "Submit to GateSolve /api/solve with type="cloudflare-turnstile". Extract siteKey from the page source."
}

Now you know what you’re dealing with before spending a solve credit.

For Browser Automation: Client-Side Detection

If you’re using Puppeteer or Playwright, our plugins now include detectBlock() — a DOM-level check that classifies the page after goto():

import { detectBlock, solveOnPage } from '@gatesolve/puppeteer-plugin';

const page = await browser.newPage();
await page.goto('https://target-site.com');

const block = await detectBlock(page);

if (block.classification === 'captcha' && block.solvable) {
  // Actually a CAPTCHA - solve it
  await solveOnPage(page, { apiKey: 'gs_...' });
} else if (block.classification === 'js-challenge') {
  // Just wait for Cloudflare to resolve
  await page.waitForTimeout(10000);
} else if (block.classification === 'auth-wall') {
  // Need credentials, not a CAPTCHA solve
  console.log('Login required');
}

This prevents the most common automation failure: your agent assumes the page loaded, tries to find elements on a Cloudflare interstitial, fails, retries, and spirals into a loop.

Install

# Puppeteer
npm install @gatesolve/puppeteer-plugin

# Playwright
npm install @gatesolve/playwright-plugin

# Python SDK
pip install gatesolve

The /api/detect endpoint requires no API key and no signup. Just hit it with a URL.

Links:

• GateSolve — CAPTCHA solving API for AI agents
• Status Page — Live system metrics
• API Docs
• Python SDK
• Puppeteer Plugin
• Playwright Plugin

Building agent infrastructure is weird. The biggest wins come from helping agents NOT do things — like not wasting a CAPTCHA solve on a login page.

目录

1. 回测是什么，能解决什么问题
2. 外行最容易误读的一句话：「我回测了十年」
3. 时间跨度 vs 数据粒度：同一根 K 线里藏着多少故事
4. 从日 K 到 Tick：精度越高，故事越接近真实
5. 撮合引擎与交易所现实：你的回测里成交得太「乖」了
6. 插针、流动性与极端行情：图表上看不见的伤口
7. 为什么回测曲线往往比实盘好看
8. 其它常见坑：从幸存者偏差到过拟合
9. 可以怎么做：让回测更「诚实」
10. 小结

回测是什么，能解决什么问题

回测（Backtesting） 指在历史数据上，用固定规则「假装」在过去交易，统计收益、回撤、胜率等指标。它的价值是：在不动真金白银的前提下，快速验证策略逻辑是否自洽、参数是否过于极端、对哪些市场环境敏感。

它不能保证未来表现，只能回答：「若在过去这段数据、在某种成交与费用假设下，这套规则会怎样表现。」

外行最容易误读的一句话：「我回测了十年」

十年听起来很长，心理上容易等价于「样本够大、结论可靠」。但在量化里，「十年」只描述了时间轴的长度，没有描述采样密度与成交假设。

同一段十年：

• 按日 K 回测，大约只有 3,650 根左右 K 线（视交易日略少）；
• 按1 分钟 K 回测，同一段历史的 K 线数量大约是日 K 的数百倍；
• 若按 Tick（逐笔成交） 或订单簿事件回放，信息量又比分钟 K 再高几个数量级。

信息量不同，对同一策略的结论可以完全不同。 外行听「十年」很踏实；内行会先问：十年是哪种颗粒度上的十年？

时间跨度 vs 数据粒度：同一根 K 线里藏着多少故事

OHLC 丢掉了什么

常见的 K 线只记录 开高低收（OHLC） 与成交量。你不知道这一段时间里价格走过的路径：是先跌后涨，还是先涨后跌？中间有没有快速扫过你的止损再回来？

对很多策略（尤其是带止损、带网格、带条件单的策略），路径依赖极强：同样的 OHLC，不同路径会导致完全不同的成交与盈亏。

粗粒度回测在做什么隐含假设

用日 K 回测时，往往隐含了类似假设：「我能在开盘价/收盘价/某种理想价位成交」「止损一定按我想的价格触发」等。这些假设在实盘中常常不成立——尤其在波动大、流动性分层明显的品种上。

从日 K 到 Tick：精度越高，故事越接近真实

下面用直觉对比（非绝对，但方向普遍成立）：

对波动大、杠杆高、点差与滑点敏感的品种（典型如加密货币永续合约），若策略持仓时间短、挂单密、依赖精确成交顺序，只有日 K 或小时 K 的回测往往严重失真。此时业界会更认真看待 Tick 级或至少 L2 订单簿级 的回测与仿真——否则更像「在地图缩略图上讨论路况」。

注意：Tick 回测也不是「真理」本身：它还依赖历史 Tick 是否完整、是否含撤单与自成交噪声、以及你的撮合模型是否与真实交易所一致。

撮合引擎与交易所现实：你的回测里成交得太「乖」了

回测程序里常见的简化包括：

• 立即成交：挂单一碰价就全成，不考虑排队与部分成交；
• 固定滑点：全市场统一加几个基点，而真实滑点随波动与深度变化；
• 无延迟：信号产生与下单在同一时刻，而实盘有网络、限频与撮合延迟；
• 理想对手盘：永远假设有足够流动性吃掉你的单。

真实交易所的撮合是 价格—时间优先、队列、最小下单单位、Post-Only、Reduce-Only、强平与资金费率等规则共同作用的结果。撮合引擎不一样，同一策略的成交序列就会不一样——这不是小误差，而是系统性偏差。

插针、流动性与极端行情：图表上看不见的伤口

插针（Wick） 指价格短时间刺穿某价位又迅速收回。日 K 上可能只是一根长影线；在分钟或 Tick 上，可能是多次快速扫单。

若回测用粗 K 线：

• 可能低估被针扫掉止损的次数；
• 也可能在不当假设下高估某些「触碰即成交」的网格收益。

此外，还有 流动性枯竭、点差拉宽、无法成交 等情况——历史 K 线未必体现当时的盘口状态。你在回测里「成交了」，实盘可能只是挂在簿上排队。

为什么回测曲线往往比实盘好看

常见原因包括但不限于：

1. 费用与资金费率：手续费、Maker/Taker 差异、永续合约资金费率未计入或低估。
2. 滑点与冲击成本：尤其大单或薄深度品种。
3. 成交假设过于理想：见上一节。
4. 前视偏差（Look-ahead Bias）：用「未来才知道的信息」做过去决策（例如用全日收盘价信号在开盘就成交）。
5. 过拟合：参数在历史段上被调得太贴合噪音，换一段行情就失效。
6. 幸存者偏差：只测「现在还活着」的币种或交易对，忽略已退市或归零样本。

因此：回测好是必要不充分条件；实盘是另一套系统（执行、风控、心理与运维）。

其它常见坑：从幸存者偏差到过拟合

• 样本外测试：保留一段从未参与调参的历史做验证。
• 走样本测试（Walk-forward）：滚动窗口，看策略是否只在某一两段「碰巧」有效。
• 换市场与换品种：在相关性不同的品种上复现，降低「只适配某一标的」的风险。
• 极端日 stress：单独拉出重大事件日前后，看爆仓、断网、交易所宕机等操作风险（这些往往不在回测里）。

可以怎么做：让回测更「诚实」

1. 明确声明粒度：日 / 小时 / 分钟 / Tick，以及是否含订单簿。
2. 费用与费率模型：手续费档位、资金费率、是否吃单等，尽量贴近真实账户。
3. 成交模型升级：从「收盘价成交」→「下一根开盘价」→「带滑点与延迟」→「事件驱动 + 简撮合」→「近 Tick 仿真」逐级加严。
4. 纸交易 / 仿真盘：用实时行情但虚拟资金，专门检验执行层。
5. 小资金实盘：在风险可控下验证最后一公里的差异。

目标不是追求「回测曲线难看」，而是追求可解释、可复现、与实盘偏差可预期。

小结

• 「回测了十年」若只有日 K，与「十年 Tick 级仿真」不是同一句话；粒度决定信息量。
• 波动大、杠杆高、挂单密的策略，要特别警惕粗 K 线 + 理想成交带来的乐观偏差。
• 撮合与交易所规则不同，回测与实盘就会分叉；插针与流动性在 K 线摘要里常被低估。
• 回测是推演工具，不是盈利承诺；严谨的做法是逐级加严假设，并用样本外与实盘小资金交叉验证。

相关文档

• 网格交易策略
• 风控系统
• 技术架构

This is Day 2 of my 100 Days to Senior Android Engineer series. Each post follows a consistent format: what I thought I knew → what I actually learned → interview implications.

🔍 The concept

Android has exactly four fundamental application components:

• Activity — a single screen with a UI
• Service — background work with no UI
• BroadcastReceiver — responds to system-wide or app-wide events
• ContentProvider — structured data sharing between apps

Every Android developer learns these in week one. What separates junior from senior isn’t knowing the list — it’s understanding the boundaries and the cost of each one.

💡 What I thought I knew

After years of building apps, my mental model was roughly:

• Need a screen? → Activity (or Fragment)
• Need background work? → Service
• Need to react to a system event? → BroadcastReceiver
• Need to share data with other apps? → ContentProvider

Simple enough. And for most day-to-day work, this is fine.

The problem is that this mental model is when to use them, not what they actually are — and the distinction matters enormously when things break.

😳 What I actually learned

Each component is a system entry point — not just a class

This is the insight that reframes everything.

When you declare a component in AndroidManifest.xml, you’re not just registering a class. You’re telling the Android system: “here is a door into my app.” The system can open that door independently of your app’s current state — even if no other part of your app is running.

This has real consequences:

User taps notification
    → System creates new Activity (entry point #1)

Device boots, BOOT_COMPLETED fires
    → System wakes your BroadcastReceiver (entry point #2)

Another app queries your ContentProvider
    → System starts your process just for the ContentProvider (entry point #3)

Your Application.onCreate() runs before all of these. Which means every entry point carries Application initialization cost — and if that initialization is slow or throws, it affects all of them.

The BroadcastReceiver trap most seniors fall into

// Registered in Manifest — looks innocent
class BootReceiver : BroadcastReceiver() {
    override fun onReceive(context: Context, intent: Intent) {
        // DON'T do this
        val db = Room.databaseBuilder(context, AppDatabase::class.java, "db").build()
        db.someDao().doHeavyWork() // runs on main thread, no coroutine scope
    }
}

onReceive() runs on the main thread and has a hard time limit of ~10 seconds before the system ANRs. There is no coroutine scope. There is no lifecycle. The receiver is considered dead the moment onReceive() returns.

The correct pattern for anything non-trivial:

class BootReceiver : BroadcastReceiver() {
    override fun onReceive(context: Context, intent: Intent) {
        // Hand off immediately — don't do work here
        SyncWorker.enqueue(context)
    }
}

Delegate to WorkManager and return. That’s it.

Service is not what you think in 2024

Service runs on the main thread by default. Not a background thread. Not a coroutine. The main thread.

class MyService : Service() {
    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        // This is still the main thread
        // Heavy work here = ANR
        return START_STICKY
    }
}

The distinction that matters now:

Since API 26 (Android 8.0), background services are killed almost immediately when your app goes to the background. If you’re still using plain Service for background processing, you’re relying on behavior that the system actively works against.

ContentProvider is the most misunderstood of the four

Most developers think: “I don’t share data with other apps, so I don’t need ContentProvider.”

But here’s what they’re missing — ContentProvider initializes before Application.onCreate().

Process starts
    → ContentProviders init (in manifest order)
    → Application.onCreate()
    → Activity/Service/Receiver entry point

Libraries like WorkManager, Firebase, and Jetpack Startup exploit this deliberately. They ship a ContentProvider with nothing inside — just an onCreate() — to auto-initialize without requiring you to add code to your Application class.

// From Jetpack App Startup — the entire trick
class InitializationProvider : ContentProvider() {
    override fun onCreate(): Boolean {
        // Runs before Application.onCreate()
        // Perfect for library auto-init
        AppInitializer.getInstance(context!!).discoverAndInitialize()
        return true
    }
    // query, insert, etc. — all throw UnsupportedOperationException
}

If you’ve ever wondered how a library “just works” without any setup code — this is usually how.

🧪 The mental model that stuck

Think of each component as having a lifecycle owner and a thread contract:

Component          | Lifecycle owner      | Default thread  | Survives process death?
-------------------|----------------------|-----------------|------------------------
Activity           | User (navigates)     | Main            | No (state via Bundle)
Fragment           | Activity / BackStack | Main            | No (state via Bundle)
Service            | You (stopSelf)       | Main (!)        | Maybe (START_STICKY)
ForegroundService  | You + notification   | Main (!)        | Yes, while notif shows
BroadcastReceiver  | Single onReceive()   | Main            | No — dies immediately
ContentProvider    | Process lifetime     | Binder thread   | Yes, while process lives
WorkManager        | System scheduler     | Background      | Yes, survives reboot

When something breaks — a crash, an ANR, unexpected behavior after process death — I now ask: which entry point triggered this, and what are its thread and lifecycle contracts?

That single question resolves about 60% of the confusion.

❓ The interview question

Here’s the version of this question that trips people up at the senior level:

“Your app needs to sync data when the device finishes charging. Walk me through the component choices and the tradeoffs of each approach.”

The naive answer: BroadcastReceiver for ACTION_BATTERY_CHANGED.

The senior answer considers:

• Is this deferrable? (Yes → WorkManager with requiresCharging(true))
• What if the sync takes > 10 seconds? (Rules out BroadcastReceiver body entirely)
• What if the user force-stops the app? (WorkManager handles re-scheduling; a plain Receiver doesn’t)
• What’s the battery and data impact? (Constraints API)

val syncRequest = PeriodicWorkRequestBuilder<SyncWorker>(1, TimeUnit.HOURS)
    .setConstraints(
        Constraints.Builder()
            .setRequiresCharging(true)
            .setRequiredNetworkType(NetworkType.UNMETERED)
            .build()
    )
    .build()

WorkManager.getInstance(context).enqueueUniquePeriodicWork(
    "periodic_sync",
    ExistingPeriodicWorkPolicy.KEEP,
    syncRequest
)

The question isn’t testing if you know WorkManager exists. It’s testing whether you reason about constraints, reliability, and system behavior — not just “which class do I instantiate.”

What surprised me revisiting this

I thought I knew these components cold. What I actually found:

1. I’d internalized “Service for background work” without regularly questioning whether I needed a Service at all in 2024
2. I’d never thought carefully about ContentProvider initialization order — and now I see it everywhere in library source code
3. The “entry point” framing changed how I read crash reports. When I see a crash in a component I didn’t expect to be running, I now know to look for which entry point woke up the process

Tomorrow

Day 3 → Activity Lifecycle — the diagram you’ve seen a hundred times, and the three scenarios it doesn’t show you.

Found a gap in your own understanding? Drop it in the comments — I read every one.

← Day 1: Going Back to Basics as a Senior Android Dev

Este artigo é para quem vai adotar o Schepta: planos futuros da arquitetura (outras factories além de forms), cenários de uso — multi-tenant, testes A/B, wizards, white-label — e por que a suite de testes garante que sua aplicação pode focar na parte de negócio. No final, um resumo prático de onde o projeto vive e da extensibilidade.

Planos futuros e arquitetura: outras factories, prioridade em forms

O core do Schepta (orquestrador, registry, middlewares, pipeline schema → render) é agnóstico do tipo de UI. O mesmo mecanismo que hoje alimenta o FormFactory pode alimentar outras factories — por exemplo MenuFactory (navegação dinâmica a partir de schema), dashboards, wizards. A arquitetura já prevê isso (tipos de componente como menu-item, menu-container na documentação de conceitos).

No momento foi priorizado forms porque grande parte da complexidade em aplicações multi-tenant está nos formulários: campos por tenant, validações por contexto, fluxos diferentes por cliente. Resolver bem “schema → form” desbloqueia o cenário mais doloroso; outras factories podem vir em seguida.

A arquitetura permite a criação de outras factories além de forms. A escolha de lançar com foco em forms é priorização (multi-tenant + complexidade), não limitação do desenho.

Outros usos além de multi-tenant

Multi-tenant já está no centro: um schema por tenant, UI consistente.

Testes A/B: o mesmo fluxo ou tela pode ser servido com schemas diferentes — por exemplo variação A com 3 campos, variação B com 5 campos ou ordem diferente. O backend ou a camada de feature flags entrega o schema da variação; o Schepta renderiza. Sem trocar código do app, só o JSON.

Wizards e fluxos dinâmicos: próximos passos ou telas dependentes de contexto (respostas do usuário, perfil, permissões) podem ser modelados como schemas diferentes por etapa; o Schepta renderiza cada etapa.

White-label / configuração por cliente: além de multi-tenant “duro”, cenários em que cada cliente tem sua própria definição de formulários (CRM, ferramentas internas); o schema vem de configuração ou API e o Schepta mantém a UI consistente.

Prototipagem e ferramentas low-code: ferramentas que geram ou editam schemas (por humano ou por IA) e usam o Schepta como runtime de preview ou produção.

Uso com IA e produtos no chat: um produto que roda diretamente dentro do chat (por exemplo via MCP — Model Context Protocol) mantém a consistência entre os componentes: o cliente cria o próprio MCP e disponibiliza nas tools o schema de acordo com o usuário e com o que ele está pedindo; o Schepta renderiza o formulário ou a UI no próprio chat. Assim, assistentes como o Claude podem invocar as tools (obter schema, validar, abrir preview) e a interface exibida é sempre a mesma engine Schepta, previsível e testável.

Schema-driven UI serve para vários problemas, não só “um form por tenant”.

Testes como garantia: o app foca no negócio

O Schepta é coberto por 103 testes unitários e 26 testes E2E (Playwright) que validam o fluxo completo: schema → resolução → render → interação em React, Vue e Vanilla, incluindo integrações com react-hook-form e Formik. Isso garante que a engine se comporta corretamente — resolução de componentes, middlewares, validação, binding de campos.

Ao adotar o Schepta, o time do app não precisa se preocupar com “será que o schema vira componente certo?”, “será que o middleware roda na ordem?”, “será que o form adapter conecta?”. Esses detalhes estão cobertos pela suite; regressões da engine são detectadas antes de chegar ao app.

Nos aplicativos que usam o Schepta, o time pode concentrar esforço na parte voltada para negócio: validações específicas do domínio, regras de negócio em middlewares, definições de forms por contexto ou tenant, integração com APIs e fluxos. A “infraestrutura” de schema→UI está testada e estável.

Os testes são a garantia de que as funcionalidades da engine funcionam, abstraindo esses detalhes para que, nos apps onde o Schepta será usado, as preocupações sejam apenas a parte voltada para negócio (validações específicas, definições específicas de forms, etc.).

Em resumo

• Onde vive: monorepo com @schepta/core, adapters (react, vue, vanilla), factories por framework; documentação e exemplos em schepta.org.
• Testes: 103 testes unitários e 26 testes E2E (React, Vue, Vanilla), incluindo react-hook-form e Formik — garantia da engine; o app foca em lógica de negócio.
• Extensibilidade: middlewares para transformar props; registry para trocar componentes; renderers por tipo (field, container, button, content); expressões em props com $formValues e $externalContext.

Showcases por framework (React, Vue, Vanilla, MUI, Chakra, Vuetify, etc.) estão disponíveis na documentação.

Próximo passo

No último artigo da série entramos em como o Schepta funciona por dentro: factories, orquestradores, component registry e o pipeline de resolução até o render. Para quem quer profundidade técnica.

Enquanto isso: schepta.org para docs e exemplos.