204 karma · joined September 25, 2010
This isn't a defense of the guy by the way since all of this schtick is to ride positive PR as a billionare looking to enter political office in a climate where people aren't exactly enthused about billionares.
Personally I think it's better than Mad Men.
Some people are just insane at that game.
Just like in marketing it's all about how you frame a question to a person. Realistically most people share common beliefs at the fundamental level in what they want to see out of the power structures in our society. In other words, the vast majority of people in this country want to improve upon their material conditions. The rest of the circlejerk is just grifting.
It legitimately comes down to however you frame a question to someone.
Like for me I hold down my right thumb key (which is also space if i were to just tap it) and that changes the layer allowing me type symbols like (){}[]<>.
In practice it's as if you were using shift to capitalize something and it becomes second nature very quickly.
Getting used to chording and layers is what allows you to eventually use less and less keys like the split 36 key board I use these days: https://kagizaraya.booth.pm/items/1235510
This was also going from 60% to my first split/ortho.
Took me another couple of days to get used to chording and these days I use a 36 key split board.
So your mileage may vary, but it's definitely not going to take you months typically.
For example, Google Cloud Code which lets you deploy/manage cloud run and k8s from it.
The very next year they changed it to C++ and I wonder how things would have turned out differently had I been a year younger.
The node that merges context would simply have a requirement/dependency on the results "provided" by each branch. It would wait to execute until those requirements were met.
The user wouldn't need to know about the data model still, the "merge node" would just intrinsicly wait for the results provided form the seperate branches.
Fundamentally when each node completes the system itself just needs to check against the list of nodes to see if its dependencies have just been met and keeps track of which nodes have been already executed so that they don't end up getting triggered again when the next check happens.
There will always be a need for some sort of workflow level state or context management that governs all of this orchestration that you would want to persist to a database somewhere if this is a long running workflow but this is a systems concern and the user doesn't need to know about it.
That was just a long way of me more or less saying that it doesn't matter how many branches there are, all that matters ultimately is that a node waits to execute when its requirements are met.
In a nutshell it's just a runner and uses a project called moleculer which is a microservice framework that I'm more or less just using as an rpc client to execute the tasks of the workflow.
One thing I've been debating with myself is how I should work with the dataflow. Would you say it's better to have the results of every node merged into a singular context across an entire flow that is passed to every other node/block (ie. always one input, the context, one output the context), or would it be better to explicitly declare and pass in inputs/outputs.
Here's one project that does it that way: https://github.com/danielduarte/flowed
One benefit of this seems to be that nodes can run in parallel the moment their dependencies are met without having to care about each other.
I poked around on your site and I like what you have to offer. You appear to do it the singular context way which I suppose makes sense because it seems like every block is an individual lambda. This also seems like overkill for my purposes because I'm interested in being able to do granular things if I wish such as a simpe rule action. I'm not sure having an individual lambda to run "if email exists return true" would be practical. That and the warm up time/latency.
The other thing is managing something like npm dependencies might be annoying across blocks.
Being able to create arbitrary API endpoints is nice though.
I wish there were something a little more in between than all of these enterprisey offerings.
One approach that comes to mind to solve this sort of end user issue would be to explicitly define all inputs/outputs for the dataflow of a node as "requires" and "provides". In this manner each node would run in parallel the moment their requirements (ie. dependencies) are met. Additionally, since what each piece of data a node needs and provides is explicitly defined you could technically automatically wire nodes together without having to even really needing know the underlying data model itself.
So it just means needing to define clear unique labels for each port. In a UI a user could just drop nodes into a space which would automatically wire up to matching ports. You can then display which needs are not met and even have an interface for choosing matching nodes that fit what might be missing.
In the end all you would really need to know is how to compose the pieces of logic to get the desired outcome.
I'm a novice at this stuff though so take that with a grain of salt.