Enabling Tasker to be able to write itself (thoughts for implementing it relatively fast)

In short, with the bigger end in mind it's for implementing machine learning (artificial intelligence); but here I am talking about making Tasker to write itself and what it enables to do.

Should accentuate that the main idea here is not directly about adding machine learning capabilities to Tasker. The main idea of this one is more about enabling Tasker to be able to do some of those basic things that are needed for users to build own AIs if they want to. What I talk about in this post will enable bunch of things. And it also provides fundamental groundwork for Tasker to be able to implementing machine learning.

Furthermore, the devices we carry will be getting more powerful and its sensors will be used for getting data. And users overall will become more programming-savvy. For this new world we are entering into more and more will be requiring it. When Tasker in the past was about bringing programming to Android users. It will soon to be about bringing AI programming to Android users.

Tasker is really great: It's mostly built out from what the creator of Tasker recognized as fundamental aspects of programming, to allow user to do most amount of things with least amount of elements (these least amount of elements seemingly are somewhat more fundamental aspects that enable writing a program). It has been great at bringing methods of programming down to some of the fundamentals aspects that allow to build useful sequences of behavior outside of our brain as extension of us. 

But there are some capabilities to do certain fundamental things missing from Tasker, - some fundamental aspects that making unnecessarily complicated for us to doing certain basic things with Tasker (one of such aspects is what I am referring to right here in this post). What is most limiting bottle-neck, seems that Tasker currently cannot add actions that can write new variable names, profiles and tasks. If this will be added, it will open door for many new very powerful things that could be created with Tasker. 

For instance, you could use Javascript to somewhat write a variable name from some conditions-dependent variable value. Yet what gives power is about not complicating what is not inherently complicated. If simple idea is complicated to implement, then it likely involves clutterous data such as to have a somewhat work-around solution, and so it involves "noise" that diffuses the "signal". It makes for us harder to see signals from the noise if much is built up around complex workarounds, and we will be able to do less, being less capable to building things, to engineering usefulness into our lives. 

Now we may ask that how hard could it be to implement this "making Tasker to be able to program itself? It may sound like it is a big thing, but it is not at all. Not at all if reasoning up from fundamentals as to what it takes to make it happen. At the below I will attempt to show you why implementing this one is not dramatically different or more time-consuming than any other important thing that could be built into the system.

So lets say, what if somebody would say something like this one:

"Implementing an idea like this wouldn't just be a quick add. This would most certainly require that Tasker be built from the ground up."

Here is what my reply would be: 

Definitely would NOT be about writing Tasker from scratch, if really envisioning what the fundamental parts of this would be: 

To implement this main idea to Tasker, it's about making a copy of triggers that are used in Tasker (such as with list of those triggers in front of your eyes, when tapping on a button - as tapping on any of these triggers - then whatever Action is associated with the button it sets this Action to the implementation sequence as what is shown in Task view. Once there is a copy of those trigger buttons, it is about adding (connector between each counterpart), which is the code (replicated to each counterpart) that is hitting the "tap on the screen trigger" as what's currently used in Tasker. So the "tap x on the screen" is run by Tasker itself, from within the Task view as one of the scheduled Actions in the sequence (from where, Tasker triggers this whatever you have specified as this specific Action to be added to specific place). 

In other words, if one taps some button on the screen, it triggers a chain of sequences to follow. It is to run this from the task by directly triggering the code, rather than from the input from the screen that triggers the same code that launches the sequences. It involves no major changes in Tasker (it's simply copying list of Tasker actions, then writing code for one Action - which when tapped it will put it in the Task view with saved specifications that would normally be specified with a handful of tapping on the screen, - mostly it's copying and modifying, such as when code is written for one Action it is same for others, and similarities will be connected automatically by multiplication/replication, as same connects to same, for why replicating list of Actions). 

When it runs, as any Action (as can be seen within Task view), the Action triggers the code parts that are normally triggered when manually tapping on buttons on the screen. It is overall about copying the list of actions in Tasker and then making each to refer to its own actual triggers that would normally be implemented when user taps on the screeen. When thinking of making Tasker to be able to write itself, it is only complex when we think of doing it in these very terms as "making Tasker to be able to write itself", and not going further to giving much thought as I just wrote out here, as to what the basic elements are that making it to work to enable Tasker to write itself. 

To say it more metaphorically, it's about taking general idea from the big picture and dividing it down to atoms and bits, as in order to do what at the macro-scale may appear undoable. Breaking things down to basic elements and operating out from those basic/fundamental elements is what enables us to build more clutter-free systems (faster-performing systems). Systems that work faster. It will allow us to achieve certain outcomes quicker. To build software with less time (enables to build more, and thus also, potentially better due having more time left for improving it farther with attention to details, bringing up your rate of improvement/innovation to come up with increasingly more useful systems). It is about increasing speed. Whether to making money faster, to develop your company faster, to be able to buy more expensive tech you want. All because of speeding up your rate of ability to making useful things. It's about getting what you want faster as what matters. 

Now furthermore, one side of the matter is how time consuming it is to implement into Tasker, another is how much impact this time investment will bring. I have somewhat covered that part that it will not take that much more time to implement than any other thing that could be implemented. Yet there's this opportunity cost. Why is this worth doing more than any other thing that could be done instead? Well, if you think about it, it's one of those more impactful things for Tasker to have. And it will not take much time compared to what it enables Tasker for. It wouldn't be some quick add like some minor thing like changing colors of theme a little or whatnot. And I wonder if anything worth doing would be quick add. I think not, or would be definitely very rare.

Yet with this one here, what I am talking about is apparently one of those rare things, which is both very powerful and close to the "quick add" territory as well. If done by one person, it should be doable within weeks. Definitely should take no more than one month. And maybe could be doable within week or two. 

It would increase Tasker's capability to do things dramatically (for Tasker's advanced users, and would extremely likely be attracting more users in general, as how Tasker can now do so and so amazing things).

Overall, artificial intelligence has started this wave that revolutionizing how we live. There is very big opportunity with AI. It's about getting Tasker into this game. Android devices allow sensors, which is the key. It's insanely unwise to let this opportunity by. Tasker has great potential. Google might want to buy it at some point, etc. Implementing this simple idea is what enables to get Tasker into this game (see above). 

(Not everything what I wrote might had come out as I see it but the benefits of implementing such into Tasker should come across if you try to envision the benefits.)

So it is about enabling us to let Tasker (through our specifications) to make own profiles/tasks/actions. Such as when certain conditions meet and to setting things up extremely fast by ways of repetitively differentiating, as well as able to reverse what it did; mathematically setting up more complex things from simpler elements, - multiplying with structured differentiating. 

This is one of those very high-leverage actions that Joao could do for Tasker, to really bring Tasker up for next levels. 

Only thing that can prevent from making it happen is when not enough people recognizing this great potential it brings. The size of reward does matter here. Some easy things are hard to implement too, if there's complete lack of benefit/reward at the end. So overall the intensity of rewards we see to come out from certain behavioral combination sequences are what making it possible for us to want to go for making something happen. It's how much time/effort we are willing to put into it. 

It is definitely one of those easier things to do as what this idea is about, to getting it implemented as I expressed above. It happens to be one of those rare cases where it is rather on the "adding something quickly" side and yet still having this great potential to enable Tasker to becoming able to do much more than now doable. 

I made this post to Tasker's subreddit too (here). Not sure if enough people will recognize this unique value that this can bring us. I think that if not many see it but Joao if you do see it, adding this will enable Tasker to become much more powerful tool. It's about rate of speed (which has a lot to do with: how much faster in relation to how much simpler, that is, as long as we don't improve our internal rate of computing speed of our individual brains, - so one way to make progress is also if it's about doing even with less repetitive input from us, by setting up systems more wisely).