Turing Complete with flows!?

Do you have any use cases where “the masses” would need this then, that they couldn’t implement with flows only? As @robertklep suggested, the use of variables will compensate for the lack of it, even though they are global. This would be a bad solution if you’d like to use recursion or trigger flows really fast after another, but both are ill advised in Homey and the latter is actively blocked (effectively blocking the first too).

ps. I doubt the language is Turing complete with these additions (too lazy to check), and I also doubt the masses would care. I haven’t run in to any serious deficiencies because of it, hence my question: what actual problems would it solve?

1 Like

I also doubt, like @Edwin_D, that the “flow language” will suddenly become be Turing Complete just by adding the feature to pass arguments to flows.

Indeed, there is no way with the Start a Flow and the A Flow is Started to pass along arguments.
Mainly because all arguments in a actioncard are always mandatory.

So, if Athom changes the Start a flow Action card; which arguments types and how many would the have to implement?

That is what i did with HOOP.
Did you take a look at H.O.O.P. (Hope) - Examples - Tutorials - Homey Community Forum (athom.com)

In particulair : Method flow | Homey
This flow can be called with 2 text arguments.

Gedeelde Flow | Homey
Or this one, it has 3 texts and 1 boolean arguments

And unless i am mistaken; this is precisly what you want: creating and calling flows while passing arguments, reducing the need for multiple flows and solving the asynchronized issues default flows have.

If this is not what you meen (flows able to pass arguments), please explain (again) what it is you want; maybe i can build it into H.O.O.P…

1 Like

I dont really understand this response: You don’t need to write javascript to use HOOP.
You just use flowcards of the right argument type.

These are the triggers available (and more):

Those can be triggered with condition/actioncards:

No need for JavaScript at all.
And you ofc can pass along tags.

Just to be clear: HOOP does not require you to really program; it turns flows (through the floweditor) into “programmable” objects. But you still only use the flow editor.

It just gives possibilities like:

  • Start flows with parameters
  • Start flows Synchronized
  • Await (a started flow)
  • Error handling (tag) and stacktrace (tag)
  • If-THEN-ELSE within the conditional part, nested and as many as you would like; not just one if-or-or statement.
  • Run any actioncard as conditioncard

The simplest use case is where you would like to effect a collection of devices with, for the sake of argument three parameters, let’s say hue, saturation and intensity.

As you argue the global parameter is an option, but an ill such. What if you have 10 different scenarios of said parameters with 2 groups of devices you like to control separately that would need 30 global variables.

There is an option to create 30 flows but that is also a bad solution. My tests indicate that the selections of which flows are to be executed are done by iterating over alla flows and would slow down the Homey considerably.

With the possibility of parameters just two flows are needed and that would. take care of even 1000.000 possible scenarios of hue, saturation and intensity.

I am not after recursion or fast execution, as this can be accomplished today by calling flows without parameters and using a global variable as a bailout.

PS As for the Turing completeness, it is easy as all functional languages are turing complete and functions with parameters would render flows equivalent with recursion. DS

I think that Athom created flows in the hopes of circumventing another of Turings theorems, the stop problem, and opted out of real functions in calling flows from flows. But the point of that theorem is that you can not opt out. You are stuck with the possibility that a program (flow) can execute forever and there is no way to predict or control if a program (flow) is done or not, and that is very bad for an event driven applications that should run for days or even months on ends.


As I said to @Edwin_D a language is considered turing complete if it allows for calling recursively with parameters, eq functions. That my friend should be common knowledge among CS scholars.

Have you seen the [APP] < group > (2.4.2 - Stable)?

Yes I have. And I have used it extensively until it broke my whole set up and flows. Groups stopped working and devices left groups etc. It might be stable but that does not mean it is without bugs.

The support for recursion isn’t mandatory for a system to be Turing complete (but hey, I only have about 35 years of experience as a programmer, so what do I know…). FWIW, Homey will stop flows from being recursive, even if they would accept arguments.

But this entire discussion has a big XY smell to it anyway: you want easier flow construction and have focussed on Turing completeness (or lack thereof) instead of accepting that what you want is already present (just not in the way you want it).

You are right, a language does not have to be recursive to be turing complete, there are other options too. but you said you did not believe parameters/arguments to flow would render flows Turing complete. But I just have show one example for it to be true, not all.

I am trying to suggest a simple and better solution to a common problem and todays solution. There are plenty of idiotic examples of bad solutions to the same problem. I remember a academic language called Brain Fuck (BF). As the name applies it is totally impossible to program in but it isTuring complete. It even has a translator from C to BF. But that does not make it a good solution.

I am not trying to argue that there isn’t a solution to the problem already, just that the current solution is not as good as allowing parameters. It would not break any existing flows, it would still allow for sub par solutions but usher in a new paradigm in flow design.

Why are you so against an extension that is non disruptive and extends the utility of flows, just because there is a solution present today that is more error prone and takes more effort to achieve than my suggested solution?

And common knowledge among scholars is also that having feathers does not make you a bird. Your assumption that Homey is a functional language is therefore almost Turing complete is lacking.

Also, Turing completeness does not state accomplishing anything should be fun or easy or practically useable. You can make a Turing Complete language that is awful and you can make brillant languages that are not turing complete.

Homey is not a general purpose computing device, so it doesn’t need to be turing complete.

1 Like

I’m not, I’m against the proposition that adding that extension would suddenly make Homey’s flows TC.

It wouldn’t be too hard (especially for a master in CS like yourself) to create an app that would implement your idea.

Well I dare you to argue against a functional construct with parameters and recursion not being Turing complete but that is another thread in another forum.

I used Turing completeness as a selling point not a requirement, but rather a nice side effect of applying parameters and arguments to an already functioning paradigm.

As I said earlier I gave an example of a language that is Turing complete and unusable so there we agree.

I am not trying to make the flow paradigm of Homey into a general purpose computing device. Just make it easier to create elegant solutions.

So this argument is then totally rhetorical? Do I understand correctly, that you are pro this suggestion but against the TC reference?

No, you don’t understand correctly.

Please enlighten me then?

“I’m against the proposition that adding that extension would suddenly make Homey’s flows TC”.

Either it’s already TC, or it’s not. Adding this extension won’t change it.

I feel like my messages are not being read?

(The questionmarks are the number1 flowvariable)

Here is a Flow (method) with 2 aruments: 1 text and 1 number.
When the flow is started, it will executed itself 11 times; 5 times with the text Text1-5, 5 times with the text Text5-10 and then reset with text Restart.

This is what you are talking about right?

Well, you asked to add this for the sake of turing completeness, which is a bad argument, and because if that not likely to be implemented. That is why I asked for real life examples (a better reason).

For now fixing Group app bugs seems like an easier route to your use case. Also the group app is more versatile and easier to understand by the masses in my opinion.

+1 for this feature.

Hoop is great but in my opinion there is some space between homey flows and hoop. And they can exist next to eachother