No, we do not know the nature of humans as there is no control case. It can be observed that humans are very social. It can also be observed that religions are social, you need at least two people to have a religion, one person just has faith. In essence faith is the opposite of religion as faith is a personal belief system and religion is a social belief system.

Religions like to claim a common "faith" basis but there is no way to prove that the practitioners actually share the same "faith". That goes back to the difficulty of two humans to agree on anything without a common external baseline. I suspect that if two practitioner of a religion attempted to map out their beliefs in all aspects of the "faith" they would always find a point of disagreement. Social stigma is a big part of keeping practitioners in line and agreeing with the religion's hierarchy. Hence another indicator to the social aspect of religion.

If you were to take all C/C++ programmers and make them use Rust, Rust would fail. Never underestimate the ability of a person acting with a little knowledge to break your stuff.

There are no unsafe languages, just unsafe developers.

And why should we pay attention to someone who cannot spell codebase ( TFS author corrected the blog post) nor take the time to use a spell checker when writing a post about how a particular programming language is unsafe?

Switching jobs means that some domain knowledge becomes obsolete but you do not change the type of programmer that you are. I've worked in many places and in 6-7 different domains, most of those in non-business logic roles. In each role I've worked with customers, functional developers, architecture developers, QA, and documentation. What I have found in switching jobs/roles is that things generally do not change, new job -> same crap. I remember one job, it sure seemed like it was going to be fun. Next thing I know I'm learning about factories, not a bad thing, until you realize that somebody decided that if one factory was good then if everything had a factory it must be better. :) Each job comes with a pile of code/architecture/infrastructure that started out as somebody's "Great New Idea" that more or less turned into the same pile as the last pile.

As you move along the programming spectrum eventually you reach a point where you realize that learning each new thing in detail is not necessary since all new languages are variations of older languages(*), all frameworks are variations of older frameworks, and remember that no one takes responsibility for what they write (except perhaps djb). The thing to remember is that the stuff we work with was written by humans, humans tend to think along similar lines, human code piles tend to smell the same.

(*) Except prolog, I think that was written by aliens.

The problem with most arguments against taxes on robots is that they assume that automation via robot is the same as automation via a non-robot. The big difference here is that robots can be used to build robots with little human interaction, in a sense robots are a another species of worker that is able to propagate. Even if you argue that it still takes humans to build robots, the number it takes to build a robots will decrease over time since automation of any task involved in building a robot is already a goal.

The advent of computers, or spreadsheets, did not entail the same scope of human labor replacement as that of the proliferation of robots. At the time of their introduction there were labor needs that could absorb the excess worker population. Granted it was a downward movement for a segment of that population, as in for the bulk of that excess worker pool the amount of physical labor required to do the job went up. This was driven by the fact that the new technology jobs that were created required fewer people than the jobs that the technology was replacing.

Then there came globalization. Globalization was essentially the employer looking for robots but not finding them. The next best thing was to find cheap 'human' labor someplace else. This is pretty much a natural process, it just moves the jobs from one pool of high labor cost to one of low labor cost. It doesn't remove the jobs, there are still humans working the jobs. So now that we've moved the jobs that can be moved to the cheapest human labor pool, the only place to go for cheaper labor is robots.

So we are back to an excess of population. Too many people for the jobs remaining. Too many people making more people. What to do?

Some of the newly unemployed people and the new unemployable people being born will go onto figure out new ways of making money but the bulk of them won't. With fewer people working fewer people will make money. Ditto on the people spending money. It won't matter how cheap it is to make a product if nobody has the money to buy it.

But does that mean they, the governments, are going to tax robots?

No, it does not.

There is still a sufficient population of working people to pay for the products that the robots make. There are still service jobs that are easier done by people than robots. There are still people that can be taxed. The people making the rules today are the same type of people that look at a resource that seems to be endless, and assume that it is. That is how they see consumers, an endless supply of consumers to buy their products. Consumers are different than workers because consumers represent income whereas workers represent cost. It could be summed up as "As long as somebody else has workers I will have consumers so I will do what I can to get rid of my workers."

Eventually there will be no workers to buy the products in sufficient quantity to support the economy.

Maybe there will be space colonies by then.

Excessive profanity, always talking about themselves (I and me) are also hallmarks of aggressive speakers. Aggressive speakers are seen as knowing what they are talking about, especially when the topic is subjective or the audience is mostly ignorant of the topic.

(Sigh, the preview doesn't show numbers in the list so be warned if there are double numbers)

There are 4 possibilities that I can see:

1. 1. All entities are part of the simulation.
2. 2. You are an observer in the simulation, all other entities are part of the simulation.
3. 3. You are a part of the simulation, somebody else is an observer.
4. 4. All entities are observers in the simulation.

Breakage results in:

1. 1. If you can contact somebody extra-simulation, and the technology exists to copy you out of the simulation, you get out. Maybe everybody else does as well but maybe not. Everybody you know is gone, your experience in the simulation may or may not be usable in your new existence, maybe you spend the rest of eternity being a lab rat.
2. 2. You get out and are somebody other than who you were. Why would you be the same person extra-simulation that you are in the simulation? Maybe your 'real' body is a slug? Feeling squishy yet?
3. 3. Oops. Maybe you can play scenario 1.
4. 4. Did you ask before you broke the game? Slugging slug fest with you as the target.

There's that saying "A bird in the hand is worth two in the bush." or "The simulation you know is worth more than the simulation you don't." After all, if this reality is a simulation maybe the next layer out is as well. It's turtles all the way up.

Gluing things together is how programming works. You start by gluing the small bits together to make bigger bits and so on and so on. Eventually you come to realize that when you need to use "Super Glue" to hold the bits together it's probably broken. Usually you glue bits together at discrete places, if you have to work on bits that have had the glue brushed on in large amounts, that's call accretion, avoid those bits, maybe put a layer of wax around them with tiny spots for glue.

I suspect very few 12 year olds are going look at this. Wolfram may be genius but a usability expert he is not. The Wolfram Language, his name, looks like something a mathematician would come up... "Let's see I've used all the math symbols already so let's start using all the punctuation symbols to do other actions! And I can combine punctuation symbols for more actions so I don't have to type too much!"

Where space is expensive, terseness is needed. Everywhere else it's the terseness that is expensive. Steep learning curve, expensive debugging (both logical and functional), and expensive mental context switches for people who want to be multi-lingual.

On the other hand if it becomes a high demand language then those who master it will definitely have job security.

So the blogger uses 2 polls in his article, one his own twitter poll of 101 responses, hardly meaningful. The other is a the 2015 Stack Overflow developers survey, that survey had 21,314 respondents for the education question which is certainly better than 101. He uses the graph for education to backup his statements which has the following data:

41.8% I'm self-taught
37.7% Bachelor of Science in Computer Science (or related field)
36.7% On-the-job training
18.4% Masters degree in Computer Science (or related field)
17.8% Online class
16.7% Some university coursework in computer science (or related field) but no degree
6.1% Industry certification program
4.3% Other
3.5% Intensive code "boot-camp" or night school
2.2% PhD in Computer Science (or related field)
1.0% Mentorship program

He then goes on to say "Only a third have a computer science or related degree and nearly 42%, the largest group, are self taught."

Turns out the percentages add up to 186.2%, the horror, some people had more than one source of education or they lied about their education. Now it's probably safe to assume that if the poll respondent had a PHD they didn't also claim a Bachelor and Masters degrees, that would mean that 58.3% of the poll have a computer science or related degree. If you include the response of some university course work it turns out that 75% of the respondents had some level of university training. It would seem that according to Mr. Hadlow's sources that university training is important.

Perhaps Mr. Hadlow should head back to university, his math and logic skills need refreshing.

Scoping by invisible characters is bad enough but modifying operator precedence by invisible characters? Why do people think that using spaces, the invisible character, as syntactically meaningful characters is a good idea? For readers of English the space is only important to separate meaningful bits and now we have a language that you will need to count spaces to determine operator precedence?!?! Of course it always cooler to use binary progressions so the operator precedence feature uses sequences of 1, 2 4, and 8 spaces. I can only hope that the language is a joke as per it's original name, nimrod.

Maybe it would be useful if they dumped the space dependency, but after reading that I quit taking it seriously.