It's very possible to be confused what many ancient writing point to as gods, and angels as their agent, it's never very clear what they are referring to anyway Add to this all the political / power struggle around those topics, of who is more like god or less like god to be all powerful agent obeying the will of the universe ..

But i can tell on this it's very different if you consider god in monotheistic fashion, as a concept, and in that case gods demons and angel are not ET or mutants or being at all, they are just concept, angels or demons are eternal archetypes in the ruling of the universe (archangel concept is not far from archetypal concept)

or if it's more the polytheistic fashion as considering gods and/or angel as somehow supernatural creatures with a material existence, and some power on the world, outside of being archetypal concepts. In that case it's very easy to confuse between loosely defined concept of aliens or ET life, unknown form of life, or being with more power or knowledge off the world, and angels.

 

And after you have the mafia on your back, no thanks 

Gym can have a number of good effects on depression,  on reaffirming capacity to set your objective and realize them, and also good effect on health especially cardio/aerobic is good for oxygenation and eliminating toxins and having more energy, but need also to follow good sceduling, and doing too much exercise beyond your limit can also have bad consequences.

show no mercy to any diktator   live free or die better die standing than living on your knees, bla bla  

https://youtu.be/sr0L0d0rCCY

You can try to rub a dub

https://youtu.be/7faTS2bqFE0 

I think the overall idea is how to write code that is both efficient, scalable, and can define these properties and operations in non ambiguous, easy to read and modify manner.

The main problem of c++ with this to me is that it can hide lot of implicit and potentially unefficient / unsafe code, even if it can give a better impression of readibility, it's not always that obvious to know what is actually going to be compiled and executed. And in the end, it doesn't solve that much core issues with dead locks, memory leak, good resources management etc. Just avoid certain mistake and synthaxic deficience of C compilers.

But the real main issue with multi thread is that with current operating system, you dont have that much hand on the task switcher, and cant control the execution schedule at all and with the interupt based preemption, it can switch to any thread anytime, and there is very little you can do about it.

There are potentially way to work around this, but it's long topic lol

With my micro kernel I recoded à task switcher,  and it can be easy to disable task switching during certain critical section, which avoid lot of problem with visibility of local states, and can give much more as3/js feeling with asynchronous call back rather than interupt preemption who can switch to anything anytime. Im not sure how this behavior can be adapted for execution of binary machine codr with current operating system kernel.

( http://www.emn.fr/z-info/bossa/acp4is-scheduling.pdf )

The best example of system like this i can think of is direct show with the filter graph, it allow good scheduling of execution with explicit  typing, using com IDL, and massive sur typing . But the code with c++ is still indigest lol and it needs to be in cahoot with the kernel & drivers to works well.


If you are looking for high level language the most basic made with all those issue in mind,  there the ACPI aml language, and there are open source interpreter,  it can give good idea of simple hardware level language who deal with smp, threading, timeout, events,interupt etc even if the synthaxe remain very basics,  it is still good lean & mean base for this kind of languages.


https://acpica.org/documentation

5.6 ACPI Event Programming Model

http://www.1024cores.net/home/scalable-architecture

Just throwing  this here in case you never saw it

Best site on scalable arch & all



That's exactly the principle I follow in my framework. The over head is still ok. My goal was to get performance on same scale than js, and Im more than there, even with the thread safe runtime. Still much slower than direct access, did test with the raytracer & +10millions access / sec, using this tree system for all single variable was 5/10 times slower than direct binary access, but with the benefits it has regarding control of data state, easy conversion from arbitrary json/XML,  and memory safety, it still worth it for anything that is potentially sharable, and for really fast local access, can always use compiler built in type & direct pointer.

Ive been experimenting with this concept a lot, and outside of the still ok runtime overhead, but with now day cache & all it is ok, and it provide only benefits, as well for low level programming, pci bus, drivers, usb, hid etc to application level & network protocol, it's super useful on every level and solve lot of problem with a good runtime especially to bridge between low level & high level, even to have layer that need to transport complexe object or tree being blind to the data, like message processing, or with json rpc, in a completely low coupling manner.

The pb is C and C++ lack too much runtime meta data to be useful as it for multi thread. It has to use some part in asm like memory barrier, atomic operations, or thing like openmp or language extension to understand the multi thread / dapp problematic. C11 is supposed to fix some part of this, but when ..

And there is not really good general purpose language who really fix all the issues.

Until the late 90's it was still different imo, because internet was restricted, with 56k etc it was not really common to stay connected all day, and it was still expansive /hour, so mostly you would just go on the irc or forum to reach someone you really need to reach or ask a question and disconnect. After with adsl and all the h24 connection and messenger, now the social networking, it become a bit information boulimia :p and too much time wasted in drama, and social / ego issue, I remember at first how the noob were mocked as Blogger who spend their day talking their useless opinion or life on blogs :p now it's hard to find a place where people really talk about project and not who they know, who they follow, or empty Dick contest and drama. Now it's like ten trolls fud der paranoaics and fan boy for 1 tech post at best lol

Depends if the cofee machine is in the same room :p

Beyond this, there is the whole Turing Halting pb, and the whole theory saying Turing like computer program are fundamentally unpredictible , even with 100% tape based standalone computer, add interrupt, thread to this, and you are not far from chaos

All framework or high level language do is adding more restriction in the synthaxe to have more determined state and less freedom, to increase predictibility.

But I believe much more in good runtime rather than more complex language and compiler , all expérience like intel atom who wanted to rely on compile time order didn't show very good result.


There are experience with Lisp to define complete grammatical language interpretation that are interesting, but anything in between for me nah  


My goal is more to get to something like this with protocol message parsing based on data definition tree template, to have good runtime type checking, and compiler/system independant code who can be executed in distributed environment with a layer above the compiler to deal with data location/availability/sharing with the layer of the data tree, directly from C language compiled to binary machine code.


https://github.com/iadix/purenode/blob/master/protocol_adx/protocol.c#L1363

With this there is all the comfort of high level language with soft typed reference tree, and still  easy to compile to cross compiler/system  binaries.

But I will probably develop higher level language script at some point to encapsulate modules and api and interface better, I looked into CHARM ( https://en.m.wikipedia.org/wiki/Charm_(programming_language) )some time ago, it seemed to fit my purpose.

Blockchain is still bit more délicate to handle than the average code. It's almost nasa style where the code must have minimum update and works well everywhere the same, as it directly hold value the code must be really well studied inside and out, and lots of bugs or flaw can easily creep in, and have dramatic conséquences on the functioning of the project.

The ideal currency is a bit like the speed of light in relativity, you cant speculate over it's value.

I can't assume a lot about him, i don't know him enough

Maybe he is someone who already spent thousands hours coding plenty of things, and for whom actual implementation in any language is not really the biggest challenge, vs doing the best research on all the new tech and new idea, to come up with something really well studied and that can benefits from all the mistake and experience of the past with other projects

Satoshis stayed in the shadow for a while to before to release a true whitepaper and implementation no ?

Need to avoid jumping too much in the scam paranoia and negative prediction too maybe

He doesn't seem too much on the hype technobabble side though

I know the problem he is talking about are legit issues, but there is not really any silver bullet for those issue today unfortunately, only partial solution who often come with too much draw back for general purpose.

They are very complex issues, and some research is needed on those topics, and i think it completely cross the blockchain world too, because blockchain are bound to evolve as distributed application with all these issue rising, and it's clear i can see there are many projects apparently heading head on full speed into a concrete wall.  Because many issue related to blockchain operation in distributed application rise many complex issue that only have been partially resolved today. I think ethereum is completely a case of this.

A little bit pessimistic no ?

I will try to git a shot on how the problem i ran through and what solution i picked in the past years I have read your whole convo on the git, but your post are often scattered on different places and thread, so i don't know where it's better to answer it

I hope it doesn't bother you, if you prefer to keep your thread clean on your idea and project, no problem !

I will probably end up writing more detailed  and clear paper on this, but i don't have such document for the moment.


The first thing that got me into thinking around this, is the feature in AS3 and also javascript to parse arbitrary json / xml data to runtime class. Like json key/value pairs are called an object , and can be loaded as an object in javascript or AS3, same goes with xml.

My thinking got that the main problem of C and C++ stem from that all the type need to be known at compilation time, and are hard coded by the compiler in the executable, and all the code to access those data is hardcoded to fit with how the compiler want to represent this data internally, and there is no way to know for sure how it is going to end up, and that on many level it's a bad idea, and as it has been said in the discussion on the git, and also from other discussion i seen on other boards, it's generally not a so good idea now day to bet on compiler to be too complex. With the cpu who already have instruction pipelines , can do lot of things with reordering, optimizing cache, pipeline things, it's very hard to know exactly what is on to happen at runtime on silicon level and it's generally better to leave optimization as much as possible in runtime where all the machine state are determined in the course of execution, rather than try to pre order, or pre optimize things through language and compiler who can never take in account execution temporality, and runtime states.

I saw the discussion went on rust too, and there was a very good discussion on this topic on devos too, with a guy who was firm supporter of rust to develop os, but another person explained that in fact the whole concept of rust unsafe code make it actually virtually useless, specially if you want to see the broad picture at system level, it's impossible to have an operating system made only out of safe code, and from the moment you have 'unsafe code' it mean the whole rest of the program is vulnerable to issues in those unsafe zone, which make the real usefulness of rust rather low all together. Maybe for some purpose it can still make memory handling more easier in certain case, but if the application has to make use of any unsafe code, and ultimately there will always be unsafe code executed somewhere in the whole software stack to the cpu, so it's more fake impression of security, or maybe a better way to organize data and code to avoid certain mistake, but certainly not silver bullet.


So the way i went with my things, is to have a whole system of software typed variable ( actually json - like tree of variable), that are totally handled via software instead of relying on compiler built in types and operators, like this the big advantage is that there can be a whole layer above any memory / variable access, with all the runtime information on states of everything and still retaining C in language for maximum portability and performance.

In the system, anytime the application want to use a new variable, or object, or json tree, it create a new typed software variable in the tree, and then get a reference counted pointer to it, in sort to totally eliminate pointer ownership, and it make it very easy to pass a reference to complex json like tree structure with a simple pointer to the root node in the variable tree, and the callee can determine all the content and type at runtime, even if the class or structure or type have never been defined in the language and the compiler have no idea of it.

It's possible to keep track for every of such variable in which function they have been allocated and when, the number of reference to it, as all the access to the variable are made through reference pointer, can relocate the data in memory completely transparently for the application, for doing either temporal optimization, or defragmenting the memory, or to fit with the promise thing in the context of distributed application when you don't have to necessarily know where an object or data is located to be able to access it.

With this system, as all variable access are put out of the hand of compiler specific type, using the system of reference pointers, it become very easy to optimize data access, even through different thread, based on runtime state and information, also in case of threading, or complex interaction, all the data can marked and either 'locked' or 'duplicated' more or less automatically from the moment they are marked as such by the application, and it make it very easy to handle many cases in runtime, rather than trying to have a somehow deterministic approach based on compile time information.

And also it deal with the main problem of C dealing with dynamic data, and it can become very easily bothering when a C program has to manipulate many list of different structure with dynamically allocated size, and direct memory pointer, but with this system, it become totally easy to create as many list of as many different object type with zero bother and zero memory leak.

On the os level, it mean an application can get all the data and states from drivers and kernel level and output them in json like tree, without having to even know anything about the kernel code at all, just knowing the key name used to store the information the application need, i already made a full device explorer rooting from pci bus up to usb device with a single unique UI controller who just display the tree of data coming from bus devices.

I'm also working on system to make all io/dsp like function more transparent, and have good management of io asynch event (network, usb, audio), but that's also another part of the system, it's not that useful all together for blockchain because actually there is not so much many thing that can benefit for parallelisation, as its lot of very sequential operation, so it's not something i'm probably going to dig too deep yet, it's also why i made the raytracing demo to have a toy to play with multi threading and parallelism, but the system of reference pointer and runtime data definition make it also much easier to handle at runtime.

I hope it's not bothering you, and is a least a bit interesting Anyway as i said i'm going to write more extensive information on this probably in the next month on my website, it's just quick shot at trying to put it out there, if you have any comment or critic don't hesitate !

In any case im reading many thing you write been thinking on same line on language & asynchronous /  promise things and how to get around limitation of C with memory/GC and multi threading

I went a completly different way though

Did you ever get to look into AS3 too ? It seem to have lot of good js-like properties , dynamic type, good OOP, asynchronous events etc,I found it quite inspiring.

As for not producing anything, sometime it's also much better to just work on theory and see all solutions and possibilities and put everything down on paper before to rush into coding the last broken concept.

Im for one firm believer some new paradigm for programming need to emerge, to deal with all the issue you are talking about

But I guess also it's not necessarily the best to be too active on forums etc if you already have fatigue and difficulty to concentrate on work, it can bring even more stress and cost more energy than coding, and can easily get your head  messed up with incorrect advise or useless problem , and cost more energy than the benefit it bring. I always noticed all the social internet coming in the 90/2000 has decreased programmers Productivity a lot after you spend more time argueing ultra theorical point and eventually get your focus more blured on tons of not so useful question and often some amount of drama, accusations, Dick contest & all

But again good luck with everything, im also bit time less and all, so I dont have much time to write all this kind of technical paper on theory , but I have plenty of reflection on these idea, and already quite working implementation for lot of it

Related to the discussion I think

February 25, 2017. Class 2 of 12 of "Lyndon LaRouche's Economic and Epistemological Method" class series. Speaker: Jason Ross. Economic science is a science of composition, not components. Can the value of a new technology be expressed in a scalar relationship to the cost to develop it? No. In this discussion, Jason Ross takes up several of Lyndon LaRouche’s ironic economic concepts to provide an effective framework to understand economic “value”: physical chemistry, infrastructure as an economic “platform,” and the unique characteristics of the human mind that make it all possible. -

Part III, LaRouche's Method: The Value of Productivity

https://youtu.be/kmapZ8Niz-o

Yes it's what I I used to say for kidding, bitcoin is like philosopher stone to turn cpu processing into gold


The people who invented asymetric crypto in the 70 though they invented it already, but it still missed many part to works well .