Maykon Meneghel

What you just learned → The middle button is the whole chapter. await suspends a function, it does not move it — the continuation resumes on the main actor and the expensive work still lands in a frame. Async code that never leaves the main thread is the most common performance bug in mobile, and it is invisible until somebody profiles it.

// The whole fix is three decisions.
HStack(alignment: .firstTextBaseline, spacing: 12) {
  if let image { Thumbnail(image) }        // no image, no box
  VStack(alignment: .leading, spacing: 2) {
    Text(position.symbol)
      .font(.headline)
      .lineLimit(nil)                      // let it wrap
    if let error { Text(error).foregroundStyle(.red) }
    else { Text(position.summary).font(.subheadline) }
  }
  Spacer(minLength: 12)
  Text(position.pnl, format: .currency(code: code))
    .monospacedDigit()
}
.padding(.horizontal, 16).padding(.vertical, 12)
.frame(minHeight: 44)                      // grows, never clips
.dynamicTypeSize(...DynamicTypeSize.accessibility5)
.accessibilityElement(children: .combine)
.accessibilityLabel(position.spokenLabel)

// Same three decisions, same order.
Row(
  crossAxisAlignment: CrossAxisAlignment.start,
  children: [
    if (image != null) Thumbnail(image!),
    const SizedBox(width: 12),
    Expanded(                              // min-width: 0, in Flutter
      child: Column(
        crossAxisAlignment: CrossAxisAlignment.start,
        children: [
          Text(p.symbol, style: t.titleMedium, softWrap: true),
          error != null
            ? Text(error!, style: t.bodySmall!.copyWith(color: cs.error))
            : Text(p.summary, style: t.bodySmall),
        ],
      ),
    ),
    const SizedBox(width: 12),
    Text(p.pnl, style: t.titleMedium),
  ],
)
// Directionality mirrors the row; Semantics gives it one spoken label.

What you just learned → The layout drawn to the comp survives one of the seven conditions below — the one it was drawn for. The difference is not taste, it is which question the layout asks: not "is the type large?" but "does this fit?". Ask the second one and a longer translation stops being a bug report.

What you just learned → Swapping the token for a one-time code is the fix everybody reaches for first, and on its own it opens two holes for the one it closes. A code needs PKCE so only the app that began the flow can spend it, and single use so it cannot be spent twice. Half a security migration is worse than none, because it feels finished.

What you just learned → Polling once a second cost eight times the bytes of holding one socket open, and still missed a quarter of the ticks. Frequency is not freshness — the only way to stop being late is to stop asking.

SELECT * FROM readings WHERE reading_id = 128374

—

What you just learned → Without an index the database reads every row to answer you. With one, it jumps straight there. Same query, same data, same server — a thousand times faster.

What you just learned → You did not make the code faster — you made more of it. Horizontal scaling trades money for latency, and an autoscaler makes that trade for you, automatically.

tradx · strategy graph

This is what Tradx does, in miniature. You do not write the loop — you wire the logic, and the engine runs it over the candles. Move the parameters and watch the graph and the trades change together.

Two people, pull requests, and reviews neither of us skips.

RSI period 14 Enter above 30 Leave below 70

Tune on this half The half you never saw

Trades 0

Return 0%

Win rate 0%

Tune it until the number is beautiful. That is the easy part, and it is what every backtest screenshot on the internet is showing you.

What you just learned → A backtest is a hypothesis, not a result. Anyone can tune a curve until it is beautiful on the data they already have; the entire craft is knowing what that number is worth on the data they do not.

What you just learned → Two models, one loss function, and a knob between them. Grade the forecaster on being close and it answers with the average of everything, which is safe and useless. Grade it on being believable and it answers with something that moves like the sensor and knows nothing. Every model I ship is that trade made on purpose, written down, and measured.

What you just learned → A mesh says where the surfaces are, and an engineer drew every one. A splat field says where the light is, and nobody drew any of it — it was fitted until the render stopped disagreeing with the photograph.

I build the app, and I build what it talks to. The screen, the state on it, the API that fills it, the database under that, and the model that reads it. Most people own one of those. I have shipped all of them, and I still know which one is the hard part.