ClojureScript Support

[furkan3ayraktar]

Until now, Polylith did not support ClojureScript files. There were several reasons for this, mainly because the Polylith team needed more experience with ClojureScript. That has changed in the last two years, mostly because I started to work almost 100% with a beast ClojureScript project. As a result, our initial thoughts about supporting ClojureScript have also changed.

Discussions on adding ClojureScript support started with @tengstrand recently asking me a simple question: “Do you share code between the frontend and the backend?”. Rather than simply answering with a no, I shared a recent discussion within my team about using Polylith in our ClojureScript repository.

In our project, we do not share code between the frontend and the backend. The backend and frontend projects live in different repositories, and we do not have any significant shared code that could be valuable to extract into a commonplace. However, there are other benefits of adding ClojureScript support to Polylith. We realized that our 50K LOC-strong project started to become too complicated even though we kept a good workspace structure inspired by the Polylith. If we used Polylith, with a good naming strategy for the bricks, we could have the best ClojureScript project in the world. Okay, if we want to support ClojureScript in the poly tool, how should it work? Together with @tengstrand, we developed the following proposal.

Clojure uses the clj file extension for source files, and ClojureScript uses cljs. A project cannot mix clj and cljs source files. The bridge between them is the cljc file extension. From this basic rule, we came up with the following suggestions to enable the poly tool supporting ClojureScript:

• We add a new :type attribute to the workspace. It is defined in the workspace.edn, and can only have the values :clj or :cljs.
  • If a workspace type is :clj, the poly tool will consider clj and cljc files as the sources and ignore the rest.
  • Likewise, if a workspace type is :cljs, the poly tool will consider cljs and cljc files as the sources and ignore the rest.
  • We do not see any value in mixing ClojureScript and Clojure in a single workspace. However, we do see value if the code can be shared between workspaces of different types, even though, in our case, it will very rarely be the case.
• We introduce a new restriction to the bricks. A component or base must only include pure sources, either clj, cljs, or cljc files. This way, we can depend on a cljc component from a clj or cljs component, even between workspaces.
• The poly tool already supports having multiple workspaces within the same git repository. We can leverage this support and create two (or more) Polylith workspaces within a single git repository: one with type :clj and another with :cljs. Then from one of the workspaces, we can depend on a shared code in a cljc brick in the other workspace using the :local/root syntax.
  • By default, :local/root dependencies outside the workspace are considered external and appear in the command outputs under libs, not deps. If we want to consider the dependencies to the bricks in the other Polyliyh workspaces as deps, we add a new configuration attribute :workspaces in the workspace.edn file. This configuration points the poly tool to the location of the other workspaces in the file system and assigns them an alias to show them nicely in the command outputs, e.g. s/anothercomponent.
  • The poly will only read either clj or cljs bricks and project code or a mix of either clj+cljc or cljs+cljc. Other types of source code will be ignored.
• If we have multiple Polylith workspaces in a single git repository, we can open either the whole repo in an IDE or open them separately. Depending on the IDE, there may be support for code navigation and refactoring if opened as a single project. We can then start a REPL for the development project of each workspace. The shared code will be available for any REPL that refers to it.
• We can implement a custom external test runner for ClojureScript and run ClojureScript tests incrementally via the poly tool.

An example directory structure for a git repository with multiple Polylith workspaces:

myrepository
├── mybackend
│ deps.edn
│ workspace.edn
│ ├── bases
│ ├── components
│ ├── development
│ └── projects
├── myfrontend 
│ deps.edn
│ workspace.edn
│ ├── bases
│ ├── components
│ ├── development
│ └── projects

workspace.edn file for mybackend project:

{:type "clj" ; 👈 new
 :vcs {:name "git"
       :auto-add true}
 :top-namespace "polylith.example"
 :interface-ns "interface"
 :projects {"myproject1" {:alias "mp1"}
            "myproject2" {:alias "mp2"}} 
 ;; 👇 new
 :workspaces {:myfrontend {:dir "../myfrontend"
                           :alias "f"}}

workspace.edn file for myfrontend project:

{:type "cljs" ; 👈 new
 :vcs {:name "git"
       :auto-add true}
 :top-namespace "polylith.example"
 :interface-ns "interface"
 :projects {"web" {:alias "w"}
            "electron" {:alias "e"}}
 ;; 👇 new
 :workspaces {:mybackend {:dir "../mybackend"
                          :alias "b"}}

If the backend project has a component called shared and if the frontend project uses it, the poly tool commands can display it as b/shared using the alias from the workspaces configuration as a prefix.

What do you think about this idea? Is the workspace a good level to separate Clojure and ClojureScript? Does it make sense to keep the Clojure and ClojureScript in separate workspaces within the same git repository and allow sharing bricks between them?

[olymk2]

not sure I really get this structure, the structure I have been using is simply in projects i have projects like backend-api frontend-ui web-worker etc with bases to match and components that comprise of clj code or components that contain cljs for frontend stuff and cljc components where I require interop or want to share code between the frontend and backend.

running two workspaces seems a strange idea when the concept of a projects seems well suited to have fronend backend electron or any other type, the place where I have mainly struggled is around tooling and hot reloading of components with shadow and figwheel which seems to be because those tools are not that keen on relative paths from what I can tell from the warnings.

on a side note i tend to prefix a lot of my components with things like ui- and api- to indicate that the component is providing frontend code or is specifically for working with a specific api.

no idea if this is helpful but that's my thoughts guides on how to get things like the hot reloading working well would actually be very helpful in this regard.

[dmg46664]

In this case I would have for starters a:

• desktop CLJ workspace.
• mobile CLJS react-native workspace.
• backend CLJS lambda workspace.

I have an integration test project that dockerizes the backend and runs against multiple JVM clients (because blocking and deref'ing is easier). I guess that's another workspace?
There are components like a parser that would have to be designated to one of these workspaces even though conceptually with a mono-repo single workspace polylith structure one doesn't have to have any cognitive dissonance about where it lives.

I note that I have .cljc code that is tested by .clj code simply because it's easier to run the tests which has sufficed. I imagine that comprehensive testing domain code could have even more elaborate structure necessitating .cljc being tested by multiple dialects.

I'm not eager to change our structure, but happy to watch these developments from the sidelines :-)
My 2p is that if clojure-and-friends* offers a feature eventually there will be a project that requires its exploitation.

[tengstrand]

We could easily support mixing frontend and backend code in the same workspace (answering @olymk2 and @seancorfield from this Slack thread).
I still think it's a good idea letting different commands know if they deal with frontend or backend code. The test command needs to know which test runner to use, and the deps command will benefit from showing only clj+cljc or cljs+cljc (mixing languages that can't talk with each other in a dependency graph doesn't add any value).

I think we can combine support for having both "pure" workspaces (as we suggest) and mixed workspaces. If we have a mixed workspace, we could let the type be set to clj at the root of workspace.edn together with a "frontend" workspace in workspaces with :dir set to "." and type set to "cljs". We could also support setting :prefix to e.g. ui- and optionally remove that from brick and project names in commands like info, deps, and libs (showing only frontend bricks and projects, in this case)

If we start a shell, we could use switch-ws workspace:frontend to switch to the frontend code, and then e.g. run the test command for the cljs code. Then we could switch back with switch-ws to work with the backend code.

Having easy access to different workspaces would be convenient. The polylith workspace has five sub workspaces in its examples directory, and today I have to type switch-ws dir:examples/doc-example to switch to the doc-example workspace from a shell, or switch-ws dir:../sandbox/clojure-polylith-realworld-example-app to switch to the real word example app. With support for workspaces I could use the more convenient switch-ws workspace:doc-example and switch-ws workspace:real-world (the real-world workspace could be specified in the user config file).

I sometimes clone other Polylith repos, e.g. the usermanager-example app, or the polylith workspace where I checkout different branches or hashes, or workspace files that I ask people to send me when I try to understand their problems. If I just want to have a quick look at one of those workspaces, it's convenient to use switch-ws, and if I want to have easy access to them, I could put them in the workspaces map in the user config file.

[furkan3ayraktar]

Since we run tests in the context of a project, if the cljc component is included in two projects, one Clojure and another ClojureScript, both projects will test it individually in their dialect. This is a standard scenario in Polylith and should not require custom logic once there is support for ClojureScript in the poly tool.

I think the challenging part is deciding how to handle the development project. Currently, we suggest adding all bricks and their tests in the workspace to the development project so that the developer has access to all code from a single REPL. In the scenario of mixed dialects in a single workspace, this will not be the case anymore. There must be at least two REPLs (hence two dev aliases), one for clj+cljc bricks and another for cljs+cljc bricks. Shared cljc components need to be duplicated on both sides. To have a simpler and more straightforward development experience, I lean towards splitting dialects at the workspace level.

[seancorfield]

What about a full-stack project that has a single deployable artifact for the server (Clojure), that includes the (compiled) frontend code to be served as static resources (ClojureScript)? That project is going to have both types of code and need both test runners.

Or are you just flat-out saying that such a project cannot be supported by Polylith, and that you'd be forced to have two projects here and somehow have to deploy the frontend and the backend separately?

(I'm not advocating for the former since, at work, our frontend is a completely separate repo and it's JS anyway, but I'm curious about what types of projects you are proposing would/would not be supported by Polylith)

[furkan3ayraktar]

I’m not in favor of those kinds of projects, and I might be too much opinionated about this 😂. With this disclaimer, here is my answer:

However, even in that scenario, to build the compiled frontend code, which will be bundled as a resource into the backend, I would recommend having a ClojureScript project that tests and builds the artifact, and then the backend Clojure project can include that artifact into its resources and build its own final artifact. Even without Polylith, one needs to have a similar two-step process to achieve a single artifact since the sources of two dialects can’t be mixed.

To me, this is a project-specific build scenario that is outside of Polylith’s scope. The poly tool will help with providing a good practice where there is a project for each artifact, and the test can run in the context of the project; which is not more than a tools.deps based configuration.

[seancorfield]

Even without Polylith, one needs to have a similar two-step process to achieve a single artifact since the sources of two dialects can’t be mixed.

Well, it can be a single "task" in build.clj that runs various steps.

Splitting that into two projects seems fragile since then you lose the guarantee that what gets built for the backend is really using the "same" version of the compiled frontend.

If you're genuinely building and deploying your frontend and backend separately (e.g., we deploy our frontend as a Docker image to ECS, and our backend as a JAR across the cluster), then yes having two separate projects seems very reasonable.

As I say, I'm just trying to establish which project structures are impossible to support in Polylith because of tooling restrictions and which are just discouraged by virtue of folks being opinionated.

[furkan3ayraktar]

Yeah, let's explore the possibilities. I’m up for intentionally restricting things in the poly tool if it really makes sense, but otherwise open to supporting as many workflows as possible. It is already an opinionated tool, which is mostly a good thing.

I see a Polylith project as a configuration that knows how to create a Classpath from given dependencies where dependencies are bricks and external libraries. A Polylith project is just a deps.edn file in the end.

In the scenario of a non-Polylith project with the fronted packaged into the backend artifact, we must still have two configurations where one defines how to prepare a classpath for the frontend and the other for the backend (I used classpath term also for the frontend here for simplicity). Then, we may have a single task for building the final artifact using those two configurations. The proposed solution could achieve this by having two Polylith projects that each knows how to prepare the necessary classpath respectively, and a single build script that lives at the root can use these configurations (projects) to orchestrate the build process to create the desired artifact.

I remembered now that we use similar build processes already in the Polylith repository and also in our backend project at work where we have a build.clj at the root, and it utilizes Polylith projects to orchestrate a single build pipeline.

[tengstrand]

Yes I agree @furkan3ayraktar, it feels cleaner to me to put all clj code in the backend workspace, and all cljs code in the frontend like this (alt 1):

myrepository
├── backendws
├── frontendws

Or like this (alt 2):

backendws
├── bases
├── components
├── development
├── frontendws
│   ├── bases
│   ├── components
│   ├── development
│   ├── projects
|   ├── deps.edn
|   └── workspace.edn
└── projects
├── deps.edn
└── workspace.edn

The cljc code could live in the backend workspace, or if it's only used by the frontend it could live there. We are not saying that you can't mix clj and cljc code in the same workspace, just that the main commands, like test, info, deps, and libs would only read either clj+cljc or cljs+cljc code.

If people really want to mix clj and cljs code in the same brick or project, that would work too (but feels strange to me) because the poly tool will ignore all cljs files if the workspace is of type clj and the other way around.

But if people are convinced that a mixed workspaces is needed and is the best choice for them, then I think we should support it.

But right now, I can't see any downsides with our "pure" proposal, except maybe the tooling issue that Sean mentioned in Slack. Maybe you can elaborate a bit on that @seancorfield ?

[seancorfield]

The tooling issue that I encountered was for VS Code and clojure-lsp: there's a pretty strong assumption that the "root" of the Clojure code -- the "workspace" in Polylith terms -- is colocated with the "root" of the repo (or workspace in VS Code terms).

For quite a while, we had multiple "workspaces" in our repo, a la your "pure" proposal, and it was almost impossible to get LSP working properly with VS Code if you opened the repo directly. I tried a variety of workarounds, with different configurations, at the suggestions of the maintainers, but finally gave up and moved the main Clojure "workspace" up to the top-level of our repo -- at which point everything worked smoothly out-of-the-box.

Hence I am strongly against any Polylith setup that does not have the workspace at the top of the repo -- or would require trying to open VS Code for multiple subdirectories inside a repo (i.e., opening VS Code in the Polylith workspace, rather than the repo root).

I want one VS Code instance open at my repo root with all my code -- both Clojure and ClojureScript -- accessible in a natural way from that same directory.

As for the REPL setup, aren't there some IDE/editor configurations that support both a Clojure REPL and a ClojureScript REPL concurrently, where the cljs REPL is started up from the clj REPL -- and the editor knows how to evaluate code of either type into the appropriate REPL? (I think there's a limitation with VS Code of only one active REPL connection but that certainly is not true of Emacs/CIDER/Piggyback, right?)

[furkan3ayraktar]

I haven’t tested VSCode with either my scenario or the one that @tengstrand suggested here. However, @tengstrand‘s suggestion seems like it should work. Before we decide anything on this, we should definitely test different scenarios in the IDEs.

About the REPLs, in a shadow-cljs project, VSCode/Calva allows switching between different REPLs run by shadow. If we run two or more REPLs from a multi-workspace Polylith repository, we should be able to connect them from VSCode, and Calva may recognize Polylith projects in the future and make the switching easier later on.

@PEZ Do you have any thoughts regarding the suggestions in this discussion or the concerns raised by @seancorfield?

[PEZ]

I'm not sure I completely follow. But if it is feasible to use shadow-cljs for starting the REPL, Calva could be used to support working with both Clojure and ClojureScript from the same VS Code workspace/window. Maybe we should schedule a call with screen sharing and it could get clearer to me what the trade offs and options are and where Calva can help now and possibly be made to help better.

[olymk2]

Thiis is where I have struggled in my project I now have a couple of frontend projects the main code is in bases and I have added the figwheel or shadow config in side the base, you need to enter a file inside the base and jack in so that it picks up the figwheel or shadow config, this seems to mostly work except for hot reloading of components which I have never quite figured out.

I am using emacs and cider the ht reloading is the one thing I would really like to get sorted, a force refresh will do the job but its not as nice as just having the changes detected and the page refreshed.

[furkan3ayraktar]

We had an excellent discussion with @PEZ and @tengstrand today. I want to share the outcome and hear what you think.

As @seancorfield already mentioned, not having a deps.edn file at the root of a repository may cause some issues. Although VSCode/Calva was totally fine with it and clojure-lsp could understand the codebase and pick up cross-workspace relationships between the bricks, we found some other issues around the development experience. We claim that Polylith gives the best developer experience and want to keep it that way.

@PEZ’s expertise in the topic showed us that we could run a single REPL over multiple workspaces with mixed Clojure dialects. The suggestion is to have the following directory structure if you want to split your workspace into multiple workspaces:

my-repository
├── backend
|   ├── bases
|   ├── components
|   ├── development
|   ├── projects
|   ├── deps.edn      👈 modified
|   └── workspace.edn
├── frontend
|   ├── bases
|   ├── components
|   ├── development
|   ├── projects
|   ├── deps.edn      👈 modified
|   └── workspace.edn
├── deps.edn          👈 new
├── shadow-cljs.edn   👈 new
└── repository.edn    👈 new

With the structure above, we can Jack-In a single shadow-cljs + deps.edn REPL with the entire repository's code. To do that, we modify the two deps.edn files inside the backend and frontend directories as follows:

backend/deps.edn 👇

{:paths [; dev sources
         "development/src"

         ; test sources
         "bases/rest-api/test"
         "components/foo/test"
         "components/shared/test"]
 
 :deps {poly/rest-api {:local/root "bases/rest-api"}
        poly/foo {:local/root "components/foo"}
        poly/shared {:local/root "components/shared"}}}

frontend/deps.edn 👇

{:paths [; dev sources
         "development/src"

         ; test sources
         "bases/app/test"
         "components/bar/test"]
 
 :deps {poly/app {:local/root "bases/app"}
        poly/bar {:local/root "components/bar"}
        reagent/reagent {:mvn/version "1.2.0"}}}

In addition to the two changes above, we have three new files at the repository's root: deps.edn, shadow-cljs.edn and repository.edn.

Root deps.edn 👇

{:aliases  {:dev {:extra-deps {poly/backend {:local/root "backend"}
                               poly/frontend {:local/root "frontend"}

                               org.clojure/clojure {:mvn/version "1.11.1"}
                               thheller/shadow-cljs {:mvn/version "2.22.10"}}}

            :poly {:main-opts ["-m" "polylith.clj.core.poly-cli.core"]
                   :extra-deps {polyfy/polylith
                                {:git/url   "https://github.com/polyfy/polylith"
                                 :sha       "bd84789c9fe41eaaf19d431f1fc8772808c9eaad"
                                 :deps/root "projects/poly"}}}}}

shadow-cljs.edn 👇

{:deps true

 :dev-http {3000 {:root "frontend/projects/app/public"}}

 :nrepl {:write-port-file true}

 :builds {:app {:target :browser
                :output-dir "frontend/projects/app/public/js"
                :asset-path "/js"
                :compiler-options {:output-wrapper true}
                :modules {:main {:init-fn polylith.example.frontend.app.core/init!}}}}}

repository.edn 👇

{:workspaces {:backend {:dir "backend"
                        :alias "b"}
              :frontend {:dir "frontend"
                         :alias "f"}}}

These changes enable us to share bricks between multiple Polylith workspaces inside a repository and a unified REPL experience for Clojure and ClojureScript. The multi-dialect support can be achieved within a single workspace using shadow-cljs. The poly tool can filter the commands' output by the dialect if the user passes a :clj or :cljs argument to a command.

I've created a working example at furkan3ayraktar/polylith-multi-ws-experiment. If you follow the REPL instructions, you will have a backend server and a frontend application running simultaneously.

[seancorfield]

You don't state what the "modifications" were -- you only show the workspace deps.edn files at the end. Could you clarify what needed to "change"?

You refer to poly/shared in the backend repo but you don't give any example of actual shared (.cljc) code that both front and back end projects could reuse. How would such cross-workspace sharing work?

What is repository.edn -- you don't explain that.

I'm also curious whether this is a shadow-cljs-only solution or whether something like this can be made to work with figwheel-main too? @PEZ (I ask because the cljs project I'm most likely to adopt right now favors figwheel-main -- which I also favor from previous experience with both shadow and figwheel).

[furkan3ayraktar]

Sure, I can explain more in detail. Modifications to the workspace deps.edn are only required for a multi-workspace setup; without those changes in a regular workspace, you can still mix dialects.

The regular workspace deps.edn 👇

{:aliases {:dev {:extra-paths [; dev sources
                               "development/src"] 
                 :extra-deps {poly/rest-api {:local/root "bases/rest-api"}
                              poly/foo {:local/root "components/foo"}
                              poly/shared {:local/root "components/shared"}}} 

           :test {:extra-paths [ ; test sources
                                "bases/rest-api/test"
                                "components/foo/test"
                                "components/shared/test"]
                  :extra-depa {}}}}

Modified deps.edn 👇

{:paths [; dev sources
         "development/src"

         ; test sources
         "bases/rest-api/test"
         "components/foo/test"
         "components/shared/test"]
 
 :deps {poly/rest-api {:local/root "bases/rest-api"}
        poly/foo {:local/root "components/foo"}
        poly/shared {:local/root "components/shared"}}}

We must lift paths and dependencies from :aliases to the top level :paths and :deps for :local/root dependencies at the new root deps.edn to the workspaces to work . The change is due to the :local/root syntax's shortcomings; it does not provide a way to refer to an alias or aliases in the destination.

You can see how the shared component works here in my example repository. Simply, a project can add bricks from other workspaces as a :local/root dependency.

The repository.edn (although the name is still open for discussion) has helpful information for the poly tool. It has the following content, and @tengstrand wants to utilize it further to provide virtual views and easily switch between workspaces.

repository.edn 👇

{:workspaces {:backend {:dir "backend"
                        :alias "b"}
              :frontend {:dir "frontend"
                         :alias "f"}}}

Using shadow-cljs was @PEZ's thought; he thinks it should work with any tool ClojureScript that uses deps.edn. He mentioned that figwheel should also work. If you are familiar with it, you can try it if it works in the example project.

[tengstrand]

I think maybe root.edn would be a better name than repository.edn (that I suggested).

[furkan3ayraktar]

And, don't get us wrong, we are still in search for finding the best possible approach that can reach most people without sacrificing Polylith's benefits 💪

An area that still lacks clarification is that this proposal makes it a little hard to work with profiles since they need to be lifted to the root deps.edn.

[PEZ]

Yes, I have strong shadow-cljs preferences. It shares an important quality with Polylith of having super attentive, and stellar user support and quick turnaround on fixes needed. And it has never let me down. 🥰

That aside, the heavy lifting here is done by tools-deps. I see no reason to think it wouldn't work with Figwheel Main or Krell. Those tools are specifically designed to not care about how the user solves things outside the domain tended to by the tools themselves.

[avocade]

Not contributing anything meaningful today, except to say I’m very excited about this direction 😊

[tengstrand]

Just a reminder. When this is implemented, we should add cljs to Polylith in clojure-toolbox.

[hadils]

Hi! I am trying to use the proposed architecture for a clj/cljs monorepo. My backend is Clojure, my frontend is Clojurescript/shadow-cljs/react-native with Reagent and re-frame. The proposed structure appeals to me and I decided to risk trying it out. Question: am I able to run the poly command in the subprojects? I haven't been able to make that work yet.

Thanks for polylith!

[tengstrand]

Glad to hear you're trying this out!
We haven't started implementing the necessary changes to the poly tool yet. We need to finish a couple of other issues first. This is going to be a huge change, and we'll do our best to ship this in several smaller releases, but the final release will be pretty big anyway. When we have something we will let people know in this thread.

[mitchelkuijpers]

Hi,
Just wanted to describe our situation. We use clojurescript for our front-end and also for our backend (Node.js). We have around 12 different projects and would love to move them over into one mono repository. We use shadow-cljs extensively for all of this since we need to build for Node.js and the browser.

We would not use cljc files and we would not like a separation between front-end and backend code. Just wanted to make sure that the people who write backend with cljs are not being forgotten. We are very excited that polylith will be supporting cljs in the future.

We would also be happy to test out alpha versions if that can help, we have some pretty big codebases.

Thank you for your awesome work on polylith!

[tengstrand]

Thanks for the kind words and your feedback!
The plan is to support your setup (mixing frontend and backend cljs code in the same monorepo).
We welcome your help testing this, when the time comes!

[tengstrand]

My suggestion is that we include support for workspaces to contain both clj and cljs code (and of course cljc) with the limitation that only one language is active at a time. When we have support for multiple workspaces, it will follow the same pattern, that only one workspace is active at a time. So when we execute the info, deps, or libs commands, only clj or cljs code will be shown, not both, but we can switch language from the shell, or explicitly pass in active language as an argument (the default language can be set by each workspace).

[avocade]

Seems to be a good starting point, to keep things simpler and getting it shipped 🙌🏻

Of course having both clj/c/s code in the same project works fine for building projects already (like this one: https://github.com/jeans11/demo-rama-electric, very cool PoC in itself which uses what I now consider to be the Ultimate Stack™, ie Clojure + Rama + Electric + Polylith ☺️👌). But having the poly tool work as intended would be great 🚀

[tlonist-sang]

Very excited for this change! My repository consists of Clojure/ClojureScript(with reagent) and currently only backend part is made with polylith. It will be much better to reason about the whole if frontend codes are also defined within the same workspace and with a separate project (namely, just frontend) right next to backend project. Even more, the domain models, which we define with component bricks, can be directly shared with the frontend part of the workspace for validation.

So when do you see these changes being applied for production? 😃

[tengstrand]

I need to finish issue #431 before we can support ClojureScript. I don't want to guess when everything is ready for production, but it's a lot of work!

[adityaathalye]

This is an interesting development (pun intended :).

Thinking aloud, using a "compiler strategy" (for lack of better words) sounds like a far better strategy than adopting some arbitrary source-placement convention (e.g. "backend" v/s "frontend").

Thinking aloud more... can it be a completely general capability? Because Polylith itself is a general project management idea.

Crudely, say a developer declares a file set + compiler/builder configuration (could be inferred based on some heuristics and source/configuration file analysis in a project's definition). Then Polylith need not know or care what language it is building / running / testing --- Clj (JVM), or Clj (.NET/CLR), or Cljs, or Cljx, or Jank, or SCI, or Squint, or JS, Java, C# ... or even Python, because people are using Clojure x Python.

[furkan3ayraktar]

I'm closing this discussion in favor of #525 where we're continuing the conversation.