The editor

01

The thing answering your editor is the compiler

Not a grammar that approximates it, and not a second implementation that drifts. The language server runs the same front-end osy validate runs, over the whole workspace — so the squiggle under your cursor and the error from the build are the same sentence, and they cannot disagree.

Screen

02

The editor knows which half of the program each line is

Osy# makes the client/server seam invisible on purpose — you write ordinary code across it, and the compiler decides where each body runs. That is right for correctness and it hides the one thing you still have to know: this line is a network round trip. So the editor draws it.

Ask the editor about a file and it answers for every call in it — the side that call runs on, and the side of the body it sits in. Here is an ordinary game loop. Nothing in it declares a side; the compiler worked all of this out.

component Game() {
  int score = 0;

  on every (TimeSpan.FromMilliseconds(16)) {
1    if (Keyboard.Down(Space)) { score = score + 1; }
    SaveScore(score);
  }

  render { Box(keys: [Space]) { Text($"{score}"); } }
}

line  16  Keyboard.Down    side=client   body=server   crosses=true
line  17  SaveScore        side=server   body=server   crosses=false

Read that the other way round and it is the whole argument for the margin. SaveScore writes to the database and does not cross: the compiler put the whole tick body on the server, so by the time that call runs it is already there. Keyboard.Down reads the browser's held keys — a browser object — so it hands off and comes back. Sixty times a second. Nothing in the source says either of those things, and no amount of reading the file tells you.

03

Tests in the tree, and one keystroke to stop inside one

The Test Explorer is FILE → FIXTURE → TEST, discovered by the language server. A [TestFixture] is a group rather than a test — it seeds the branch the tests under it fork from. A [Skip("reason")] test appears with its reason, because a parked test is a visible reminder that a gap exists.

Screen

04

A debugger that pauses inside your own language

Not a JavaScript debugger, and not a .NET one showing you the interpreter's frames. It stops on the line you wrote, in the file you wrote it in, with your own values in the pane.

→ initialize
{ "supportsConfigurationDoneRequest": true, "supportsEvaluateForHovers": true,
  "supportsSetVariable": true, "supportsSetExpressionRequest": true,
  "supportsExceptionInfoRequest": true, "supportsConditionalBreakpoints": true,
  "supportsHitConditionalBreakpoints": true, "supportsLogPoints": true,
  "exceptionBreakpointFilters": [ "All Exceptions", "Uncaught Exceptions" ] }

→ setBreakpoints  model/orders.osy:9
{ "breakpoints": [ { "verified": true, "line": 9 } ] }

→ launch          tests/orders.test.osy::a_big_order_gets_its_discount
event stopped     { "reason": "breakpoint", "threadId": 1 }

→ stackTrace
  Discount                        orders.osy:9
  call:Discount                   orders.osy:14
  Place                           orders.osy:14
  call:Place                      a_big_order_gets_its_discount:4
  a_big_order_gets_its_discount   a_big_order_gets_its_discount:4

→ variables
  total = 200

→ evaluate  total * 2
{ "result": "400", "type": "Decimal" }

Screen

05

One call stack, across the network — and a run you can rewind

This is the part that has no equivalent elsewhere, because nowhere else is one program. A durable flow IS the debuggee: the same handle addresses a run that is executing right now and one that parked two days ago waiting for a person.

06

What happens when you change it