local copy<\/a><\/strong> of the solver into an F# script and add an alternative to the solving loop:<\/p>\n\n\n\n\/\/\/ Solve equations in parallel.\n\/\/\/ Still an experimental feature.\n\/\/\/ Parallel distribution is cyclic\nlet parallelLoop onlyMinIncrMax log sortQue n rpl rst =\n\n let solveE n eqs eq =\n try\n Equation.solve onlyMinIncrMax log eq\n with\n | Exceptions.SolverException errs ->\n (n, errs, eqs)\n |> Exceptions.SolverErrored\n |> Exceptions.raiseExc (Some log) errs\n | e ->\n let msg = $\"didn't catch {e}\"\n writeErrorMessage msg\n\n msg |> failwith\n\n let rec loop n que acc =\n match acc with\n | Error _ -> acc\n | Ok acc ->\n let n = n + 1\n let c = que @ acc |> List.length\n if c > 0 && n > c * Constants.MAX_LOOP_COUNT then\n writeErrorMessage $\"too many loops: {n}\"\n\n (n, que @ acc)\n |> Exceptions.SolverTooManyLoops\n |> Exceptions.raiseExc (Some log) []\n\n match que with\n | [] ->\n match acc |> List.filter (Equation.check >> not) with\n | [] -> acc |> Ok\n | invalid ->\n writeErrorMessage \"invalid equations\"\n\n invalid\n |> Exceptions.SolverInvalidEquations\n |> Exceptions.raiseExc (Some log) []\n\n | _ ->\n let que, acc =\n que\n |> List.partition Equation.isSolvable\n |> function\n | que, unsolv -> que, unsolv |> List.append acc\n \/\/ make sure that the equations with the lowest cost\n \/\/ are prioritezed\n let que = que |> sortQue onlyMinIncrMax\n \/\/ apply parallel equation solving to the\n \/\/ first number of optimal parallel workers \n let rstQue, (rpl, rst) =\n let queLen = que |> List.length\n \/\/ calculate optimal number of workers\n let workers =\n if Parallel.totalWorders > queLen then queLen\n else Parallel.totalWorders\n \/\/ return remaining que and calculate\n \/\/ in parallel the worker que\n if workers >= queLen then []\n else que |> List.skip workers\n ,\n que\n |> List.take workers\n |> List.map (fun eq ->\n async {\n return eq |> solveE n (acc @ que)\n }\n )\n |> Async.Parallel\n |> Async.RunSynchronously\n |> Array.toList\n |> List.partition (snd >> function | Changed _ -> true | _ -> false)\n\n let rst, err =\n rst\n |> List.partition (snd >> function | Errored _ -> true | _ -> false)\n |> function\n | err, rst ->\n rst |> List.map fst,\n err\n |> List.choose (fun (_, sr) -> sr |> function | Errored m -> Some m | _ -> None)\n |> List.collect id\n\n if err |> List.isEmpty |> not then (que |> List.append acc, err) |> Error\n else\n let rpl, vars =\n rpl\n |> List.unzip\n\n let vars =\n vars\n |> List.choose (function\n | Changed vars -> Some vars\n | _ -> None\n )\n |> List.collect id\n |> List.fold (fun (vars : Variable list) (var, _) ->\n match vars |> List.tryFind (Variable.eqName var) with\n | None -> var::vars\n | Some v ->\n let vNew = v |> Variable.setValueRange var.Values\n vars |> List.replace (Variable.eqName vNew) vNew\n ) []\n \/\/ make sure that vars are updated with changed vars \n \/\/ in the remaining que\n let rstQue = \n rstQue\n |> replace vars\n |> function\n | es1, es2 -> es1 |> List.append es2\n \/\/ calculate new accumulator and que\n let acc, que =\n acc\n |> List.append rst\n |> replace vars\n |> function\n | es1, es2 ->\n es2 |> Ok,\n es1\n |> List.append rpl\n |> List.append rstQue\n\n loop n que acc\n\n loop n rpl rst<\/code><\/pre>\n\n\n\nBy copying the solver module into a script:<\/p>\n\n\n\n
\nYou can refactor or extend the code incrementally<\/strong> without touching production.<\/li>\n\n\n\nYou can run the solver interactively<\/strong> on sample equations.<\/li>\n\n\n\nYou can introduce features (like parallelism) without fear.<\/li>\n\n\n\n You gain instant feedback<\/strong> from FSI.<\/li>\n\n\n\nWhen satisfied, you copy the improved code back into the main project.<\/li>\n<\/ul>\n\n\n\nRunning the Existing Tests from the Same Script<\/h3>\n\n\n\n The really nice part is that you don\u2019t just get to run ad-hoc experiments: you can also pull in your existing test suite and reuse it directly from the script.<\/p>\n\n\n\n
In the same .fsx file, we load the existing tests from the main solution and define a small test module that compares the behavior of the sequential and parallel solvers:<\/p>\n\n\n\n
\/\/ load the existing tests\n#load \"..\/..\/..\/tests\/Informedica.GenSOLVER.Tests\/Tests.fs\"\n\nopen MathNet.Numerics\nopen Expecto\nopen Expecto.Flip\nopen Informedica.GenSolver.Tests\nopen Informedica.GenUnits.Lib\n\nmodule Tests =\n\n module ParallelTests =\n\n open Informedica.Logging.Lib\n open Informedica.GenSolver.Lib\n\n let logger =\n fun (_ : string) -> ()\n |> SolverLogging.create\n\n \/\/\/ Solve equations sequentially\n let solveSequential onlyMinMax eqs =\n Informedica.GenSolver.Lib.Solver.solveAll\n false \/\/ useParallel = false (sequential)\n onlyMinMax\n logger\n eqs\n\n \/\/\/ Solve equations in parallel\n let solveParallel onlyMinMax eqs =\n Informedica.GenSolver.Lib.Solver.solveAll\n true \/\/ useParallel = true\n onlyMinMax\n logger\n eqs\n\n \/\/\/ Helper to compare equation results\n let eqsAreEqual eqs1 eqs2 =\n match eqs1, eqs2 with\n | Ok eqs1, Ok eqs2 ->\n let s1 =\n eqs1\n |> List.map (Equation.toString true)\n |> List.sort\n let s2 =\n eqs2\n |> List.map (Equation.toString true)\n |> List.sort\n s1 = s2\n | Error _, Error _ -> true\n | _ -> false\n\n let mg = Units.Mass.milliGram\n let day = Units.Time.day\n let kg = Units.Weight.kiloGram\n let mgPerDay = CombiUnit(mg, OpPer, day)\n let mgPerKgPerDay = (CombiUnit (mg, OpPer, kg), OpPer, day) |> CombiUnit\n\n let tests = testList \"Parallel vs Sequential Solving\" [\n\n test \"simple product equation gives same results\" {\n let eqs =\n [ \"a = b * c\" ]\n |> TestSolver.init\n |> TestSolver.setMinIncl Units.Count.times \"a\" 1N\n |> TestSolver.setMaxIncl Units.Count.times \"a\" 100N\n |> TestSolver.setMinIncl Units.Count.times \"b\" 1N\n |> TestSolver.setMaxIncl Units.Count.times \"b\" 10N\n |> TestSolver.setMinIncl Units.Count.times \"c\" 1N\n |> TestSolver.setMaxIncl Units.Count.times \"c\" 10N\n\n let seqResult = eqs |> solveSequential true\n let parResult = eqs |> solveParallel true\n\n eqsAreEqual seqResult parResult\n |> Expect.isTrue \"sequential and parallel should give same results\"\n }\n\n test \"sum equation gives same results\" {\n let eqs =\n [ \"total = a + b + c\" ]\n |> TestSolver.init\n |> TestSolver.setMinIncl Units.Count.times \"total\" 10N\n |> TestSolver.setMaxIncl Units.Count.times \"total\" 100N\n |> TestSolver.setMinIncl Units.Count.times \"a\" 1N\n |> TestSolver.setMaxIncl Units.Count.times \"a\" 50N\n |> TestSolver.setMinIncl Units.Count.times \"b\" 1N\n |> TestSolver.setMaxIncl Units.Count.times \"b\" 50N\n |> TestSolver.setMinIncl Units.Count.times \"c\" 1N\n |> TestSolver.setMaxIncl Units.Count.times \"c\" 50N\n\n let seqResult = eqs |> solveSequential true\n let parResult = eqs |> solveParallel true\n\n eqsAreEqual seqResult parResult\n |> Expect.isTrue \"sequential and parallel should give same results for sum\"\n }\n\n test \"multiple equations give same results\" {\n let eqs =\n [ \"ParacetamolDoseTotal = ParacetamolDoseTotalAdjust * Adjust\" ]\n |> TestSolver.init\n |> TestSolver.setMinIncl mgPerDay \"ParacetamolDoseTotal\" 180N\n |> TestSolver.setMaxIncl mgPerDay \"ParacetamolDoseTotal\" 3000N\n |> TestSolver.setMinIncl mgPerKgPerDay \"ParacetamolDoseTotalAdjust\" 40N\n |> TestSolver.setMaxIncl mgPerKgPerDay \"ParacetamolDoseTotalAdjust\" 90N\n |> TestSolver.setMaxIncl kg \"Adjust\" 100N\n\n let seqResult = eqs |> solveSequential true\n let parResult = eqs |> solveParallel true\n\n eqsAreEqual seqResult parResult\n |> Expect.isTrue \"sequential and parallel should give same results for complex equation\"\n }\n\n test \"chained equations give same results\" {\n let eqs =\n [\n \"x = a * b\"\n \"y = x * c\"\n \"z = y * d\"\n ]\n |> TestSolver.init\n |> TestSolver.setMinIncl Units.Count.times \"a\" 1N\n |> TestSolver.setMaxIncl Units.Count.times \"a\" 10N\n |> TestSolver.setMinIncl Units.Count.times \"b\" 1N\n |> TestSolver.setMaxIncl Units.Count.times \"b\" 10N\n |> TestSolver.setMinIncl Units.Count.times \"c\" 1N\n |> TestSolver.setMaxIncl Units.Count.times \"c\" 10N\n |> TestSolver.setMinIncl Units.Count.times \"d\" 1N\n |> TestSolver.setMaxIncl Units.Count.times \"d\" 10N\n |> TestSolver.setMinIncl Units.Count.times \"z\" 1N\n |> TestSolver.setMaxIncl Units.Count.times \"z\" 10000N\n\n let seqResult = eqs |> solveSequential true\n let parResult = eqs |> solveParallel true\n\n eqsAreEqual seqResult parResult\n |> Expect.isTrue \"sequential and parallel should give same results for chained equations\"\n }\n\n test \"with value sets gives same results\" {\n let eqs =\n [ \"dose = qty * freq\" ]\n |> TestSolver.init\n |> TestSolver.setMinIncl Units.Count.times \"dose\" 10N\n |> TestSolver.setMaxIncl Units.Count.times \"dose\" 100N\n |> TestSolver.setValues Units.Count.times \"freq\" [1N; 2N; 3N; 4N]\n |> TestSolver.setMinIncl Units.Count.times \"qty\" 1N\n |> TestSolver.setMaxIncl Units.Count.times \"qty\" 50N\n\n let seqResult = eqs |> solveSequential false \/\/ use full solving with value sets\n let parResult = eqs |> solveParallel false\n\n eqsAreEqual seqResult parResult\n |> Expect.isTrue \"sequential and parallel should give same results with value sets\"\n }\n ]\n\n let run () =\n tests\n |> runTestsWithCLIArgs [] [| \"--summary\" |]<\/code><\/pre>\n\n\n\nWith this in place, you can now:<\/p>\n\n\n\n
\nEdit the solver implementation in the same script.<\/li>\n\n\n\n Run Tests.ParallelTests.run() in FSI.<\/li>\n\n\n\n Immediately verify that your new parallel implementation behaves the same as the existing sequential one across realistic scenarios taken from your domain.<\/li>\n<\/ul>\n\n\n\nThis is the essence of taming<\/em> a brown field with F#: you don\u2019t just change code\u2014you bring the code, the tests, and the runtime together in a single interactive environment<\/strong>, and let FSI give you fast, tight feedback loops while you evolve a mature codebase.<\/p>\n\n\n\nConclusion: From Green Field Ideals to Brown Field Reality<\/h2>\n\n\n\n Green-field projects are where we learn languages and frameworks. Brown-field projects are where we actually use<\/em> them.<\/p>\n\n\n\nIn a green-field setting, everything is possible: you control the architecture, the abstractions, and the direction of the code. In brown-field systems\u2014like GenPRES\u2014you inherit real constraints: production behavior that must not change, performance characteristics that matter, and code that has accumulated knowledge over time. The challenge is not writing new code, but changing existing code safely<\/strong>.<\/p>\n\n\n\nThis is where F# Interactive truly distinguishes itself.<\/p>\n\n\n\n
By lifting real production modules into an .fsx script, you create a safe experimental zone<\/strong> inside a mature system. You can refactor, optimize, and even introduce new execution models\u2014such as parallel solving\u2014while continuously validating behavior against the actual test suite<\/em>. The feedback loop is immediate, the risk is contained, and confidence grows with every evaluated expression.<\/p>\n\n\n\nSeen in this light, FSI is not just a REPL or a learning tool. It is a brown-field engineering instrument<\/strong>.<\/p>\n\n\n\nIf the earlier Informedica post showed why<\/em> FSI is such a powerful tool for exploration and understanding, this follow-up shows how<\/em> to apply it pragmatically to evolve a real, non-trivial codebase. And with newer approaches\u2014such as running FSI through an MCP-enabled server\u2014you can even extend that interactive loop to include AI-assisted workflows without sacrificing the shared state and immediacy that make FSI so effective.<\/p>\n\n\n\nBrown-field development doesn\u2019t have to mean slow, risky, or opaque change. With F#, FSI, and a disciplined interactive workflow, it becomes iterative, observable, and surprisingly enjoyable.<\/p>\n\n\n\n
That, ultimately, is how you tame the brown field<\/strong>.<\/p>\n<\/div>
<\/path><\/svg><\/i> <\/div>","protected":false},"excerpt":{"rendered":"
Introduction If you\u2019ve read the previous Informedica post on F# Interactive (FSI) and why it\u2019s a powerful tool in your development toolbox, then this post takes the next step.\u00a0The first post introduced what FSI is and why it\u2019s useful. This post shows how you can harness it practically on a brown-field project such as GenPRES.\u00a0 … <\/p>\n
Continue reading “Taming the Brown Field with F#: Interactive Refactoring for Mature Codebases”<\/span><\/a><\/p>\n<\/div>\n
<\/path><\/svg><\/i> <\/div>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[9],"tags":[],"class_list":["post-437","post","type-post","status-publish","format-standard","hentry","category-programming"],"_links":{"self":[{"href":"https:\/\/informedica.nl\/index.php?rest_route=\/wp\/v2\/posts\/437","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/informedica.nl\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/informedica.nl\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/informedica.nl\/index.php?rest_route=\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/informedica.nl\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=437"}],"version-history":[{"count":22,"href":"https:\/\/informedica.nl\/index.php?rest_route=\/wp\/v2\/posts\/437\/revisions"}],"predecessor-version":[{"id":482,"href":"https:\/\/informedica.nl\/index.php?rest_route=\/wp\/v2\/posts\/437\/revisions\/482"}],"wp:attachment":[{"href":"https:\/\/informedica.nl\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=437"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/informedica.nl\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=437"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/informedica.nl\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=437"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}