You assume that the majority of people are going to use that free time contributing to society.

I assume no such thing. We were only talking about *motivated* people. The one's who wouldn't be satisified by lounging about drinking beer and watching TV.

What are they doing with their free time?

Topping the charts for "happiness" in the world, ranking high as entrepreneurs, opportunity... etc.

trying to claim people would automatically use the vacated time for the greater good of society is incredibly disingenuous.

That's fair, and I didn't mean to say that. As I said, the context of the conversation was "motivated people who work twice as hard as everyone else"... I assume *those* people would find something fulfilling to do, whether its a "contribution" to society or they spend all their time climbing mountains and skydiving is beside the point -- I'm sure they'll be doing something they find interesting.

We use white space to communicate our programs' block structure to other humans. Why should we use a different syntax to tell the compiler the same information?

What -should- happen is the compiler flags when the whitespace doesn't match the semantics as an error. Then the programmer can reformat it (automatically in most cases) to match the code, or fix the code if necessary to match the formatting.

Computers should conform to the needs of humans. Full. Stop.

Agreed. And by forcing humans to manipulate whitespace directly and manually you are not conforming to the needs of humans. Full. Stop. :)

Humans cannot 'see' whitespace characters -- that's what makes them white space. Therefore it is awkward to manipulate as a result, and is easily mangled or corrupted by many tools which do not religiously preserve whitespace... because its white space ... and the vast majority of tools view whitespace as token separators not semantic unto itself. And this is because this is how humans view whitespace too for the most part. So what python is doing is weird by human conventions.

We're way off in the weeds here, of course, but that's cool. I don't mind playing in the weeds.

Way out there. :)

You've defined a language that can only update eight bits at a time, and additionally you've said it updates them only in certain patterns. That's not Turing complete.

No you are mistaken.

From the point of view of the LANGUAGE, each bit is individually and directly accessible. All the language sees is

0, 1, 0, 1, 0 ...

The implementation of the language however, runs on x86, and uses a byte to represent each 0, and each 1. (as 00000000 and 00000001 respectively.

When the language saves a file out to disk, it writes out its binary bits one bit at a time, but they are each saved as a byte. When it reads them back in, the byte 00000001 is read, and stored in memory as 00000001 in a byte... but the language, just sees 1.

The problem if you try to write a C compiler in the language, is that as far as the language is concerned the first 8 bits of the program it compiled *IS* 11010001, however, what is in the physical computer memory to represent that is 8 bytes each 000000000 or 00000001. What gets written to the file on the disk is the same. The representation of the compiled C program I generated, is mathmatically equivalent to the actual C program ... but it cannot be run as the representation is wrong.

One of the very few things required by the definition of a Turing machine is that is has to be able to update memory one value at a time

The definition of a turing machine places NO restriction on the representation of its "memory".

So you are mistaken or misunderstood what I've done. I am *absolutely* free to use arrays of 8 bit bytes that each contain one of 2 bit patterns to simulate a turing tape.

You've defined a language that can only update eight bits at a time, and additionally you've said it updates them only in certain patterns. That's not Turing complete.

The language doesn't see 8 bits at a time. The arrays of bit patterns are an implementation detail that the language is not 'aware' of.

If we want it to be Turing complete, we can interpret it as one value by saying that the LANGUAGE writes "1" and the HARD DRIVE happens to store that physically with eight molecules.

Ok... yes. Exactly Right. Except that rather than molecules I'm asserting the language simply dumps it to the hard disk using the logical file system already in place (say by Windows or Linux or whatever) the way its stored in memory... as a stream of bytes, containing one of two patterns.

. Fine. The language can write 1010101, 11111, 0000, 01010, or any other series since it's writing one value at a time. Perhaps the hard drive stores "10" physically as 1111111100000000, but the hard drive is going to read back what was written to it. Write a "1", get a "1" back.

Right again. So far so good. The language writes a "1" and it reads back a "1". Yes.

Given that the tape doesn't change what's written to it, the language can write valid machine code and get valid machine code back.

Swing and a miss... ok not a miss... foul ball.

It can read and write "valid" machine code back, subject to the constraint that we view it from within the language / language implementation. If we look at what is actually in the physical computer memory, it is not valid machine code from the physical computers perspective.

This language can compute results that are logically equivalent to machine code, but they are not actually usable as machine code. We can't simply set the ACTUAL CPU instruction pointer to the spot in physical computer memory I'm storing my compiled C program because it is just a sequence of 111111111 and 000000000 ... a representation of the machine code, but not usable machine code itself.

Further because the language *implementation* provides no way of setting the physical bits of the *underlying* computer in an arbitrary way, there is no way to directly compile to usable machine code using this implementation of the language. DESPITE it being a Turing complete language, and despite the implementation being sufficient to simulate a Turing machine.

You can't have it both ways.

Can and do. We have 2 Turing machines!

The language / implementation / system only needs to be internally consistent with the requirements for Turing completeness to be Turing complete. If I *layer* Turing machines such that one runs on top of another one -- which is exactly what I've done by taking an actual computer (Turing machine 1) and implementing my toy language on it (Turing Machine 2). TM1 is therefore effectively simulating TM2 which is fine. But there is no requirement that TM2 be able to directly control TM1 for TM2 to be Turing complete.

TM2 -- might be able to control TM1 -- and in fact in many such layering scenarios this IS possible. But it is not a requirement, and some scenarios exist where TM2 can't control TM1.

Clearly then not all Turing machines are equal in all ways. ;)

They ARE of course equal in the specific way identified by the Church-Turing thesis, which effectively states (amongst other things) that any TM can simulate any other TM (implying that any TM can 'host' another TM).

But it does NOT make any claims about the hosted (or simulated) TM being able to control or directly reprogram the simulator simulating it (ie re-program and control its own host). And it turns out there exist TMs which CAN directly reprogram the TM hosting them, and TMs that cannot.

So to illustrate:

x86 PC (TM1) can simulate ARM PC (TM2), and then of course TM2 can turn around and emulate an x86PC (TM3)... etc ad nauseum per Church-Turing.

Suppose in this case though that TM2, being an emulation of an ARM based system was implemented such that not only can it arrange its own "simulated memory" in arbitrary ways, but can also effectively arrange the memory of TM1 in arbitrary ways, it can also, at least in theory, emit machine code and directly reprogram the TM1 that is simulating it.

It can control and program the *actual* TM1, not just TM3 which is itself a simulation of the same type of computer that TM1 is.

Church-Turing only requires that TM2 be able to simulate TM3, not control TM1.

contrast to:

x86 PC (TM1) can simulate my-toy-turingmachine (TM4), and TM4 being Turing Complete CAN simulate an x86PC (TM5)
Because the implementation of TM4 lacks the ability to arrange the memory of TM1 in arbitrary ways it cannot directly control TM1, even though it can simulate a machine equivalent to TM1. (In this example that's TM5)

If you're copy-pasting enough code from web forums

Ah yes, because teaching yourself from online resources like the web is a bad idea. And one should always retype everything from scratch despite it already being more or less what you want one window over.

and emails for this to be a problem

Well, not so much in practice, because it's a waste of time, so we have to diddle around with little attachments etc because trying to put any code in the email body directly is likely to barf on itself.

It would be nice not to have to though.

I'd suggest the language is not the only thing that's idiotic.

Of course you would. Attacking my intelligence is really the only way to defend your fanboi love of phython's, despite its ridiculous semantic whitespace.

Because defending semantic whitespace on its own merits is hard.

You know what though, I'd be perfectly happy to use a C++ / C# / Javascript ... IDE that validated formatting to set standard and flagged down anything that wasn't right. So you could look at it and then either fix the code to match how you formatted or (a 1000x more likely) click "automatically reformat" so the formatting matches the code.

That really gives you the best of both worlds. Assurance that the formatting reflects the semantics (a good thing), without actually defining the semantics with whitespace (the idiotic thing).

As opposed to pasting misformatted shit that causes confusion and bugs?

Yes, as opposed to that. Which almost never happens.

And I have the IDE reformat code pretty regularly (and before check-in) so the rare case of mis-formatted code that someone might actually be confused by doesn't stick around long.

Whereas in the course of maintenance and composition I mangle (or encounter mangled) python code that needs to be reformatted manually all the time.

So yeah, I'll take the almost never happens and usually is harmless scenario in other languages over the happens all the freaking time and is routinely a PITA scenario that is Python.

I'm a C++ programmer by trade but there's no way I'd wish that language on a student

Agreed. Its not a learning language.

I only wish Python would allow stricter interface constructs...

I only wish python didn't have semantic whitespace. That's it. Otherwise i like it just fine.

I want the compiler/IDE/whatever to pretty-print and reformat my code to reflect program semantics, not have me spend my time formatting it to DEFINE program semantics.

A programming language that can have its code be destroyed by copy-paste / email / web-forum formatting mangling is simply idiotic.

The fact that people often choose to run a program in a sandbox doesn't mean anything about the language(s) the program is written in.

The fact that you can theoretically put any language into a given sandbox or theoretically take it out of one is not equivalent to a real ability to actually do it in the real world today.

It's not easy in any language. It's possible in any.

Imagine a turing complete toy language which only operates on binary values. The only implementation of that language allocates a byte to hold a one or a zero. An "8 bit integer" would require 8 bytes of computer memory. Horribly wasteful I know, but its still a turing complete language.

You cannot implement an x86 C compiler in this language. (At least not today.) Not because the language itself is incapable of computing it, but the implementation of the language lacks the ability to output valid x86 C code that an x86 CPU will execute. If for example, my executable program needs to have its first byte as 110100011, this language cannot output that. I'll get

00000001, 00000001, 00000000, 00000001, 00000000, 00000000, 00000000, 00000001

which can be shown to be mathematically equivalent by a simple function of ignoring the leading 7 bits of each byte and placing the remaining 8th bit into a single byte. BUT this language lacks the capability to actually do THAT in practice.

I could even write an x86 CPU emulator in my toy language and use it to run my "equivalent to x86 but not x86" machine code. The emulator would emulate the 32-bit CPU registers with 32 bytes each containing 1 bit, etc...

But no matter how much I twist and contort, I can't get 11010011 into a single hardware byte. I don't need to do that for the language to be turing complete, since it can *simulate* the ability to do that, without actually doing it.

And THAT is my point. Church-Turing is satisfied by simulation. A simulation of a thing isn't necessarily precisely the same thing as being able to actually do the thing directly.

Now of course, one could re-implement the language differently (allowing bits to set within a physical byte), and then one could do this. But the reimplemention would have to be done in a different language -- one simply could not bootstrap what was needed from the original implementation of the language.

Despite it being Turing complete.

I don't follow why you even think I'm arguing that mechanization could or would directly solve this problem?

Why are the children abused and neglected? Seems like there is a cycle in place -- were the parents have unmet problems -- those would need to be identified and resolved to break out of the cycle.

Clearly the fact that the neighborhood is "depressed economically" is a factor -- but the choice of economic system or degree of mechanization isn't going to automatically provide parenting, education, or hope.

Mechanization may alleviate some of the economic factors, but I don't expect it is a solution by itself.

It will be fine. The guy planting the explosives is going to be wearing a red shirt (for safety). Last name was Smith or Jones or something, didn't catch the first name.

Excellent! Then it WILL be fine. At least for me.
Not for him maybe, but he won't be missed, we barely knew him.

What level of mechanization makes it possible?

Essentially: post-scarcity of labor as a mechanized resource.

Humans won't be required to perform labor to produce food, shelter, and menial maintenance tasks.

In such a hypothetical society it makes sense for the society to collectively own that mechanized army of labor.

The problem with your assessment is that...

Is nothing. I concluded my post with the observation that there are lots of genuine problems with communism. This is one of them. You've provided an example, good job.

The hypothetical solution to this problem is mechanized labor of sufficient sophistication that it can perform these jobs. The availability of this automated labor, in sufficient quantities such that humans do not HAVE to clean sewers or haul trash etc. A post-scarcity society.

This is exactly the mentality that escalates to murdering those who work harder than others in order to reap larger rewards.

No, its really not.

You call everyone who fits that bill "criminals."

Calling them "criminals" was to illustrate a point. That's what any society calls any one who violates the rules of society for any reason -- good or bad, well intentioned or not.

A person who takes excess wealth from the obscenely rich and gives it to those who cannot afford hood. (aka Robin Hood) is very well intentioned ... but he's also indisputably a criminal. While the obscenely wealthy man who watches his neighbors die in the street, while engaging in gluttony, he is a fine upstanding citizen.

Should robin hood be the criminal? Should the glutton be the upstanding citizen? Those are the rules of our current society.

In a communism, yes, the person who works harder(*) and expects to be rewarded beyond his share of the wealth would be a criminal.

First, you reacted as though this was barbaric, unjust, and tantamount to murder. But why? What is the inherent good in taking more than an even share? How is that heroic?

Second, you assert he "worked harder". That is a common presumption in your sort of argument. But did he? Maybe he was just born smarter, and he was able to discover better ways of doing things, without working harder at all. Should he be elevated above all his peers, or should everyone be elevated by his discovery? Which outcome is more heroic?

Or perhaps he doesn't work very hard at all, and still wishes to receive a greater share of the wealth? Is that also heroic?

What if he can trick you into thinking he does something particularly valuable, has he earned a greater share of the wealth?

What if he's nothing special in any regard at all, perhaps even a bit lazier and duller than normal, but his grandparents on his mom's side were quite clever and they ammassed some extra wealth, what is your argument that suggests he entitled a life of luxury?

. A carpenter who works twice as many hours should not have the excess taken from him simply because the average carpenter works half as long.

You've loaded the argument backwards. In a true communism he is not paid directly for his labor in the first place. So the amount he receives in the first place simply doesn't correspond to the hours he worked. There is no excess wealth he gains that is "taken away". In that society he doesn't view working longer as a way of "getting more" stuff, as the two simply aren't connected.

I work twice as long in number of hours tilling fields and planting crops. As a result, I produce twice as
much as anyone else. According to you, I'm a criminal for having twice the income.

In a true communism, that would only be true if you tried to withhold the crops from the commune for some reason. Given the crop yield, like everything else, is communal property, if you work twice as hard and produce twice the crop, the commune as whole is a bit wealthier. Not you.

And you are not a criminal, but likely respected by your peers for contributing so much.

Now you can ask me why, in such a system, you would feel -motivated- to work twice as hard if it just makes the commune as a whole, instead of yourself, slightly wealthier, and that's a perfectly valid question.

You probably wouldn't feel motivated to work twice as hard and spend 20 hours a day in the fields.

Why is that "bad"?

I expect you would be motivated to do something else with that time... create music or art, teach the children to fish or program computers, or perhaps you will experiment with new farming techniques to try and discover a better way of farming so that commune will collectively have to work even less, enabling everyone to spend even more time on non-farming pursuits... or whatever else you find personally fulfilling instead of trying to amass excess wealth.

Are you going to try to convince me that this would be somehow a "worse" system?

Since the only way communism actually works given human nature, it necessarily requires ruthless dictators to enact.

We have yet to see human nature in an environment where there are sufficient resources for everyone without labor.

"Human nature" manifests the way it does in a competition for scarce resources and a society that measures success in terms of the resources you've gathered.

Now suppose the resources aren't especially scarce, and society might well decide to value something else instead.

it necessarily requires ruthless dictators to enact.

Or perhaps it will come naturally in a post scarcity world. Or perhaps we'll come up with something else, and the circumstances in an actual post-scarcity world will lead us to forms of society we just haven't considered yet.

If an interpreter for language A can be written in language B, then B can therefore do everything A does, by running that interpreter.

Mathematically speaking yes. Practically speaking no.

Do you have an example in mind of two languages that can do very different things?

Postscript is Turing complete. Now go write an interpreter for C / C++ with it, and use it to play Call of Duty.

You can write an interpreter for C/C++ with it.

Hypothetically speaking it would compile and run the source code for Call of Duty.

Practically speaking however, it would not work. This abomination would not have access to directX, game controller inputs, sound, multiplayer / networking because postscript doesn't have those things, and therefore the interpreted C code would not have those things.

Those things aren't required to be Turing Complete, but they are required to play Call of Duty on a modern PC precisely the same way one might play it.

You could create something mathematically equivalent of the computation required for Call of Duty, but you could not "play" it precisely the same way.

If one were to build the relevant api/libraries and make them available to postscript then you could, but that doesn't exist right now and its worth pointing out that those graphics, sound, networking, and input APIs could not themselves be written entirely in postscript.

So while postscript and C are mathematically equivalent in a Church-Turing thesis sense they really aren't equivalent on real hardware in the real world.

You could not start with what is in the world today, and writing postscript, only postscript code, and nothing else, come up with a playable call of duty.

On a physical keypad maybe. Not the one on my phone, where the slighest bit of alignment can result in a bad entry.... trebly true if we're talking passphrases using the alpha numeric keyboard.

Muscle memory is an assist, not a complete solution.

If you disagree, kindly tell me what you do with people in your ideal communist society who want to put in above-average effort, and reap the extra rewards.

How are those *fundamentally* different from the people in my current society who want to take more than their allocated reward? Pretty sure we don't MURDER them.

Exiling the motivated will simply rapidly impoverish those that remain.

Calling them "the motivated" is a fallacy out of the gate. It has naught to do with motivation, and everything to do with them being criminals by the standards of the society.

I know plenty of people who are motivated to produce art, music, entertainment, and science for little to no unreasonable 'extra' reward beyond what they could otherwise earn for less effort. They do it because they enjoy these pursuits. You seem to discount them existing and suggest that the only reason anyone is motivated is so that they can "reap all fruits" for themselves. This is not the sole source of motivation, and it is arguably not the best source either.

Take a small commune of farmers, one farmer smarter than the others, discovers a technique to improve production -- shares it with the others, and they all benefit from increased leisure time. Why do you argue he would be NECESSARILY not motivated to do this? Because he doesn't gain an edge over his peers? That's absurd.

Communisum has a lot of real problems but having to "murder" people who are "motivated" is not one of them.