I have to disagree here. Most of the popular languages are procedural and is mere evolution of writing for a machine--machine code, assembly, C, and scripting languages have the same structure.
I fully support new program building systems that breakaway from this. It could be in the form of DSLs (in particular declarative), visual programming, Excel formulas. This is still a kind of code, but not the procedural code which I think includes many incidental complexities not inherent to problems to be solved.
I am a functionnal programming zealot too (although I am mostly doing rust these days) but I think it is less about procedural vs functional than it is about the abstractions used and the overall "power" (as in, it does a lot of work for you) of the compiler. My argument is that a more generic but extremely powerful compiler (because it had more work and iteration that went into it) will beat any specialized poorly made compiler any days.
Python, Rust, Typescript, Scala, etc, etc... they all support lambdas in one way or another and have reached some kind of local optimal for the tradeoff that they are making. My claim is that you are never better off these days inventing a non-embedded DSL, and if embedded DSL you build, do it as a simple library in one of the nice modern language.
These modern languages with lambdas are what enable writing in a functional style. One can choose to use single-assignment 'var's and map/filter etc, at that point you're not using the procedural aspect of the language which is great, but why not start with a language that more than allows it.
Exactly!
This is what the "serverless" model was supposed to solve but that got hype cycled into something else.
Now the same thing is happening with nocode.
I like the idea behind windmill but I would prefer writing the code in my own ide and checking it into git. Is this possible?
There is a github action to automatically deploy from github to windmill: https://github.com/windmill-labs/windmill-gh-action-deploy
That gh action is what I use myself for the public templates that hydrate every workspace on:
https://github.com/windmill-labs/windmill
Fun fact, the way it works is that it just tarball a subdir of your repo and send it as an input of a normal windmill script that then just extract it to your workspace (for all the diffs that it finds).
Note: It is still a one-man, early startup for now. I am looking for a technical co-founder and applying to YC. The stack is Rust, Svelte and Postgres :)
Note2: I am also looking for early customers and would be happy to customize windmill to your needs if you were to trust us.
We should not reinvent programming languages. They have been expertly crafted to be the most powerful and expressive abstractions. Specializing them into DSL is counter-productive: specialized DSLs lack all the nice features of mainstream PL that have been iterated on for many more manhours that could ever be sunk into any startup's DSL. I would argue that the best of both worlds are embedded DSL, but the best embedded DSL are simple libraries that do not require staged meta-programming. Of course, normal libraries provide no-lock in so it has less commercial values.
Most of the benefits of those so called no-code or low-code platform is not in the coding abstraction but in the platforming aspect that makes it easy to deploy and integrate your apps with secrets, schedule and permissions. This is exactly the minimalist approach taken by windmill.