The revolutionary concept of oOo
Tags: programming
Published: 2023-12-29 19:39:59

Below an attempt to explain the meaning of the "word"  **_oOo_**  in the context of the  *[oOo](https://github.com/oOosys/oOo)*  project by  oOosys on github : 

If you discover for the first time in your life (as child or later on as an adult) that everyone around you including your parents is insanely irrational in many if not even most life situations you have two options: to reject accepting it as true, because it just can't be, so there must be something wrong with you and you need to learn or change yourself to better understand the world around you OR to accept the fact that you need to arrange yourself with being surrounded by more or less irrational acting people and there is as good as nothing you can do to change it, especially because you may also discover that you are yourself to a maybe smaller but anyway certain degree irrational without a chance to get a fully clear view on what actually is without some assumptions which for sure earlier or later *(or never if you stop evolving yourself to keep integrity of an established personality you stick to)* turn out to be at least in some cases not helpful and in other cases even a total disaster. 

What can you do to improve yourself at least a bit in order to arrive at what  *oOo*  actually stays for?

- get a sufficient amount of Alexander Technique "lessons" in order to gain experience with what Alexander Technique is all about. You are limited to gaining experience only, because understanding of it will fail without having own experience showing clearly the positive outcome of the taken lessons. The hard part of understanding Alexander Technique is that it is just not possible to understand. And yes, I am aware of the just stated contradiction, but you need to approach it without trying to understand. It is about forgetting/unlearning of unconscious ways of behavior as a tool able to fix issues/problems with the body and mind. In other words it is about working on what exceeds the current level of what you are able to become aware of ...
- start to use the Sedona Method of letting not useful and not true believes go as a daily tool for mastering the emotional response to what is and the incoming information ( like this one hitting you as you are reading this text ).  
- start to have own experience with usage of the Power-Of-Now concept spread by Eckhard Tolle, which is about stopping the mind activity to experience and see what actually now really is. Mastering the Power-Of-Now allows insights into the actual origins of the own emotional state which are the own thoughts and the own body posture. The fun part of "Power-Of-Now" able to paint a smile upon your face is becoming aware that most people use their minds to think about and interpret own emotions as they consider them being independent from own thoughts and body posture. In other words, the funny thing is, that your mind creates an emotion in first place and then keeps your thoughts busy with wondering how it comes that the emotion is there, developing an explanation and interpretation of it along with a plan for appropriate reaction. 
	
The hard part of getting to the core of the  *oOo*  idea in the context of computing is to change the way of understanding how computer systems work. If you are now getting tired and sleepy instead of becoming excited and full of energy to start with the  *oOo*  journey it is a clear sign that you haven't understood something while reading. Maybe it is a wrong meaning of a word you haven't yet managed to understand properly, maybe a phrase where you fail to see what sense does it make, maybe a wrong believe which tries to stay there by preventing you from letting it go if it isn't helpful. I am myself also regularly getting tired and sleepy ... until I discover what exactly was it I haven't yet proper understanding of.  *oOo*  is more a continuously improving set of guides for a journey as a final product. Feel encouraged to share your private thoughts about it with me at claudio.grondi@freenet.de or share these suitable to be publicly available here. Every kind of response is welcome :) , so you don't need to put efforts into being politically correct or polite ... 

If you succeeded to read all this above and are eager to continue the  *oOo*  journey, below my current state of art knowledge about using the  *oOo*  approach for customizing own way of usage of a computer system I was, after 30 years of failing at it, able to come up with and put it into words: 

My up to now experience is that every SYSTEM needs some guidelines, principles and rules to make its components working together in order to achieve a desired effect or to obtain a desired result. In this context also the  *oOo*  system needs some. Creating the guidelines, principles and rules for the  *oOo*  system is based on the assumption that the lower the amount of rules, the simpler and easier will be to use the system. In other words  *oOo*  strives to keep the amount of rules to a bare minimum. 

The  *oOo*  project on github is at the time of the end of year 2023 based on Linux Mint 21.2 Xfce and upon the for it available software.  *oOo's*  main focus is to solely demonstrate the usefulness of the principles behind the underlying concept. If the by the project provided code and applications can be used without modifications also elsewhere, it is just because of use of most simple and commonly available approaches. Please don't be disappointed if the  *oOo*  project does not provide a bunch of ready to use software. Maybe it won't ever provide it in order to prevent polluting a so powerful idea with details which can take away the power of the guidelines YOU yourself would be able to apply in a much more effective and productive way than I am able to do myself. And yes,  *oOo*  is about **taking full responsibility for the final outcome yourself**. 

With the advent of ChatGPT and other LLMs in year 2023 it became obvious to everyone ready to see and accept it, that a "stupid" machine following some simple rules is capable of creating program code out of a precise description expressed in a spoken language. The free version of ChatGPT in year 2023 achieved in my tests best results while creating Python code out of requests written in English. By the way: ChatGPT explanations of code exceed usually the quality of by a human created ones. In other words ChatGPT can be used as a code documentation tool and a transpiler from spoken to a programming language demonstrating this way the usefulness of a spoken language for coding of computer applications. Interesting in this context is that according to ChatGPT programming languages are much better suited to express ideas and for communication between program developers compared to the spoken language. In my eyes this fact demonstrates the limitations of current LLMs, which are mirroring also not true, but in Internet widespread information. The issue here is that LLMs are not (yet) capable of creating own attitude based on deep reasoning about all of the available facts including facts about the LLMs themselves. 

Another in this context valuable observation ( you can easily verify yourself ) is to take a look at the sizes of the executable and code files and compare them with the size of their documentation.  In many cases the size of the documentation is by far larger than the size of the executable or the library. This shows that documentation is what actually makes a software project and the code itself is a secondary part and only the result of the documented requirements. This is the main reason why  the decision was made to allow deliberate texts as valid  *oOo*  script code. In an  *oOo*  script the code is what need to be marked as such to enable filtering it out among all the other text. The markers should use private areas of Unicode code points in order to avoid collisions with any other Unicode content used as comments and documentation, but please don't wonder that for  demonstration purposes  *oOo*  uses by available fonts covered Unicode points instead of providing an own font file. Feel free to design your own glyphs representing the required marking creating an own font file covering one of the available private areas of Unicode points. 
The observation related to the power of the natural English language is the reason why the  *oOo*  system is based on the assumption that the English language is extremely well suited as a programming language and that the documentation (i.e. comments) is more important than the code itself. In other words the code of an  oOo  system program code requires marking of phrases relevant to the executable code, where any other known to me programming language out there (status, end of year 2023) requires explicit marking of comments. An  *oOo*  program code allows any byte sequence in the code file without the need of marking it as a comment, so you can make also THIS file/text executable (best using the #!/usr/local/sbin/oOo  shebang as first line) and it will be accepted as code with the effect of the file being opened in a default text editor. 

Next worth to mention and interesting observation in the context of  *oOo*  is that the Linux bash shell command prompt in a Terminal along with the file system provides already many of the features each programming language duplicates for the bare sake of purity meeting this way common, but screwed user expectations expressed in one sentence as: "How can I do ... this and that ... using this specific programming language?". The code of a "Hello World!" application provided in all of the programming languages out there is an excellent example of unnecessary duplication of the shell `echo 'Hello World!'` command.  Try it yourself. Start a Terminal emulator and type  `echo 'Hello World!`  at its command line to experience bash command prompt is enough to achieve this functionality. If you don't like to type "echo" and would prefer to type  `write 'Hello World!'`  use  `alias write=echo`  at the shell prompt first. And if you decide that  `o 'Hello World!"`  will be a more concise way ... why not? Use  `alias o=echo`  and enjoy the one letter command resulting in printing the by it followed text after typing  `o 'Hello World!'`  .  And what if this is not concise enough for you? Use  `hw='Hello World!'`  and enjoy the output of `o $hw`. But what if you don't like the "$" and this is still to much to type? Use  `alias hw='echo "Hello World!"'` and enjoy the output after typing  `hw`  at the command prompt. 

_Further reading in the spirit of **oOo** by another authors on DEV_: 
- https://dev.to/primalskill/the-black-box-of-software-development-4eoh
- https://dev.to/feketegy/i-challenged-myself-to-create-an-app-in-less-than-24-hours-4odk
- https://dev.to/feketegy/a-brief-history-of-javascript-frameworks-2g44

_Further reading about the insane madness of what is going on in the area of computer and software technology (non-DEV links)_: 
- https://sassenrath.com/computing.html
<font size=-2>Notice that from the perspective of oOo Carl's statement 
> _"Companies like Microsoft mistakenly think that we either have plenty of time to burn or perhaps actually enjoy endlessly fooling around with their system."_
is flawed, and how Microsoft thinks proved over decades to be right ...</font>

_Further reading about **oOo** provided by oOosys here on DEV_:
- [The oOo Way (part 0): "What Is a Mindset and Why Does It Matter?"](https://dev.to/ooosys/the-ooo-way-part-0-what-is-a-mindset-and-why-does-it-matter-3c6i)
- [The oOo way (part 1) : "Proof of concept"](https://dev.to/ooosys/the-ooo-way-part-1-proof-of-concept-2a9m)
- [The oOo way (part 2) : "I spy with my little eye ..."](https://dev.to/ooosys/the-ooo-way-part-2-i-spy-with-my-little-eye--44kn)
- [The oOo way (part 3) : "Why using programming languages for programming is a bad idea?"](https://dev.to/ooosys/the-ooo-way-part-3-why-using-programming-languages-for-programming-is-a-bad-idea-27p8)


- [The oOo way (Appendix 1) : whichf](https://dev.to/ooosys/the-ooo-way-appendix-1-whichf-143m)
- [Tho oOo way (Appendix 2) : Can Linux *which* be improved?](https://dev.to/ooosys/can-linux-which-be-improved-p3j)