Some hot topics ......

I am not interested in reading books such as compilation principles for the time being. On the one hand, I have no time, on the other hand, I am more focused on implementation, and I am overburdened with formal idiots and mathematical idiots ......

The UNIX philosophy looks very powerful, but it doesn't actually focus on implementation skills (it may be incorporated into some program implementation forms-such as shell scripts-it's reasonable to suspect that the related entries are just a flaw
Is difficult to implement. This may indirectly lead to insufficient popularity in the market (a reference operational standard: ensure that a general operation name is used as a keyword, before Google
In addition to Windows and Unix-like (or dare to ignore IEEE ),
POSIX) general PC operating system. On the other hand, at the same time, the C language's "concise" design is not endless-for example, there is not enough clear details to develop cross-platform Abi; for example, for large Miscellaneous
The development and use of C ++ provides an opportunity-even Java can boast that it is "simple ". For decades, almost all UNIX-like operating systems (specifically, the kernel) have been run in C language.
It is not ironic to know the basic implementation.

　
Since the C language era, the general "advanced" language has become popular on a large scale, but users have not noticed the essential differences between humans and machines. For implementers (General digital computers)
Even if there is a translation program, in fact, this kind of advanced language cannot be implemented either (for the moment, even languages without identifiers such as brainf ** K are not "popular" "advanced" languages.
Language. For example:
Int main (INT argc, char * argv [])
{
Return argc;
}
And
Int main (INT how_egg_pain_the_c_1_age_is, char * what_the_fxxk [])
{
Return how_egg_pain_the_c_1_age_is;
}
After the tool chain of the compiler (as long as it passes through the translator, there is no need to call Preprocessor here -- linker is applicable to the platform), for the target
There should be no difference in the platform-ai with the ability to monitor compiler input and then speculate on the intent of the code writer, conservatively estimated that the Earth cannot achieve it in a century.

In a sense, the meaning of language features such as name and identifier is simply that the implementation of the programming language looks closer to the natural language, so that
The code is easier to write and read. Obviously this is only meaningful to humans; for machines, it is irrelevant as long as they can run (for the author of translation programs-essentially several humans, No matter what tools are used
--
It is "voluntary" to pass on the opportunity cost of human users of language to themselves ). The semantics that machines can implement is lost here. However, whether it is inappropriate or not, humans may always jump. Then, the language "should
How to design it is purely an internal conflict between humans. However, the design and implementation bundle seem to be the customs of this planet, so there is not much predictable guarantee for the design of things. It is only known if they have been used.
Path. (In this regard, computers were not as expensive as they were now .) What can the user realize about the language (such as bjanae
Stroustrup refers to the "idea". It is nothing that can be expected by itself or peers. It is likely that this leads to a heavy impact on the number of users who do not know the truth for indicators such as language occupancy.
Necessity, as well as the commercialization needs, propaganda needs, Camp needs, and philosophical needs.

Looking back at the C language, I feel a little uncomfortable like English. The first is "simple"-although many people should understand that this is only the reason why C ++ and so on come and go.
Provides more functions, some of which are completely irreplaceable (such as templates ). Just for the language features, it doesn't matter if you advertise "simple". I don't need it if it's a big deal. However, the content of the language itself is too hard to organize.
Click the chicken ribs. Here are two examples:
1. ISO
In c99, only identifier is ignored. Or it is enough in terms of grammar, but name has a more natural and direct meaning in natural language. Comparison with ISO
C ++ 2003, name and identifier are both clear. Well, pure C does not have a namespace. The requirements for the reference are associated with the word elements rather than the printable syntax units.
There is really nothing to do with the obvious disadvantage of the language users. I am sorry.
2. ISO c99 defines a bunch of constant instead of literal (same as ISO
C ++, no matter how complicated or vague the constant behavior is, literal and constant are always differentiated ). The term constant (including translated
Whether or not I am using a rather messy version, I am afraid the Standards Committee may not know this (it seems that a large number of people are still mixed with C ++ ), it can only be interpreted as a deliberate disregard.

In addition, there are objects, lvalue definitions, and so on. I am too lazy to continue to vomit ......

Not all people take the time to read the standard, just to confirm the interface of the language design (translated into an interface or interface can be, the former emphasizes the contract, the latter emphasizes the impression, here both mean side
Important, simply using the original text), saving the slightly "simple" system constructed by several words, but exerting the special characteristics of natural language ambiguity, indirectly hindering the understanding of language design, it always makes me feel fooled. This
The document design philosophy of abusing the Occam Razor principle suddenly reminds me of the same feeling of defining "New Things" (poor words) in my textbooks ...... In short, there is no language.

The other unpleasant thing is that some users (well, It's hard work for the compiler. This is an internal conflict between the people of the Earth and you will not be hurt by mistake ). First, the misunderstanding of the language can be ignored,
To harm others. As for this, I have seen many influential instances. Second, various fields that waste others' time (noisy design, noisy characteristics, noisy specifications, and noisy platforms)
, Noisy naming convention ......) The (pseudo) Language philosopher (in order not to waste time, this article is omitted later ).
+ 0800;

@ + 0800;

 

　　
Continue to complain ......

What are humans better than computers? In terms of semantic expression, I thought it could be done by humans.
Think
"Month"
Bright when you don't look at it, it doesn't exist. "and" it's not a price you don't need ", this is probably something that modern generic computers cannot do with any algorithms based on stack. This may be worrying --
The implementation of concurrency semantics, logistics network, and weak artificial intelligence is not an exaggeration yet (this should not be an exaggeration-
-), This problem cannot be placed on the table and becomes a engineering problem, which then affects the capital direction or supply chain configuration. It is too far away from most academic teams.

However, there is something that can be outputted. This is the C language (in fact, this only represents --).

　
C is recognized as a high-level language. So, to what level is advanced ...... At least it looks like an algorithm language, right? It is a pity that there are static types (either the type directly associated with the underlying programming model
......) Check. If you want to write a generic Program (for example, void * callback parameter), it is not safe. To write an OO program, you have to Ctrl + C/Ctrl + v (pre-processor is a good thing, unfortunately
Too limited, and still prone to errors ). Is it close to the underlying layer? Row: first, discard the platform's neutral nature. If you have to ensure cross-platform
To exclude unreliable va_args
Not even the direct operation call stack is supported; not to mention the operation control flow (the thread or something can be compensated by the database for the moment, I don't know how to implement a continuation or coroutine (I admit I can't write it without referring to other people's code.
Even if you write it out, you have to add a lot of comments to prevent you from forgetting how to implement it.
This completely becomes unable to be maintained. Do not think about the custom exception model or anything (the exception feature of C ++ is clear in syntax in a sense.
Yes
It's a miracle ...... Block
Shenma
)....... People who have to be familiar with specific hardware systems are eligible to be called "system programmers". I do not know how many people on the earth are qualified (I am not saved in this regard, I will never be counted ).

　
Let's take a look at it and switch to the next scenario: You often need to know what went wrong, but you don't always have the opportunity to have time and energy to solve the problem. To control the behavior of the compiler during compilation --
You can only stop compilation-change code-and continue. Maybe I should change the implementation of the compiler, but in this world, the compiler does not seem to allow users to say anything after accepting the command line. It can only be compiled successfully,
Or a heap of complaint. The fact is that it may be possible for me to write a analyzer, But if I write a back-end translation program framework, it looks like it is actually egg.
Pain, and at least not capable of this. Writing a compiler is not as easy as inventing a language to ignore side effects (for example, it cannot be maintained)
Semi-finished products
Code) the Ideological experiment cost is too high. I should learn more about the civil workflow.

Again, the language is still not powerful ...... (Well, we have a central idea)

+ 0800;

 

Today, my complaint is over and I will continue my homework ...... Let's talk about it later.

EOF