All Questions

With a list/array of colors in hexadecimal format like this:

[ "#fff000", "#238923", "#aaaaa0", "#ff2300", "#2ff014", "#010203" ]

The idea is to order/organize it so that the red ones are first, the green ones second, and the blue ones last. But that is not enough because there are tones and tones of colors, the idea would be that they were organized in a "chromatic" way:

1. Bluish reds (red is the main color, then blue)
2. Reds (red is the main color, blue and green have the same value)
3. Greenish reds (red is the main color, then green)
4. reddish greens
5. Green
6. teal greens
7. greenish blues
8. blues
9. reddish blues

As you can see, it would be like a "color circle" where the ends meet: I put blue before green for red, and green before red for blue. So for example: #331122 (bluish red) would come before #330000 (red-red) which would come before #331100 (greenish red). The sort scheme would be something like this:

   R        G        B
-------- -------- --------
RB RR RG GR GG GB BG BB BR

So the above list would look like this:

[ "#ff2300", "#fff000", "#aaaaa0", "#2ff014", "#238923", "#010203" ]

I can't use an existing sort method in the programming language because it's not really a normal sort and it's not going to go alphabetically. That is why the values ​​for the three colors must be taken into account independently. He would have to do something of his own.

So I'm looking for an answer that:

• Propose a theoretical solution for a large number of colors.
• Also work with a limited number of colors (25-50 which could be used to sort a paginated table).
• Be efficient (algorithmic order) - should you consider hashing/buckets?

Since c++11 the c ++ standards committee has made it a goal to approve a new standard every 3 years. This has been the case to date and we have had the following standards:

• c++14 approved in August 2014.
• c++17 approved in March 2017.
  • What are the new features of C++17? .
  • C++17 What is it? Isn't it C++? ¹ .

Standardization is divided into four working groups:

• Nucleus (Core): Maintenance of the language and standardization of new proposals.
• Evolution : Development of new features for the language.
• Library : Maintenance of the standard library and standardization of new proposals.
• Library evolution : Development of new features for the standard library.

In July 2019, the C++20 standard was considered closed. This implies that no new features can be added (although some could be removed if problems are detected) and approved features are being reviewed for possible improvements or minor corrections.

At this last meeting, it was considered that the Contracts ² proposal (technical document P0542R4 ) would not be incorporated in C++20 and is delayed to C++23.

We are going to list some of the main features that C++20 will incorporate.

¹ Due to some strange oversight, I wrote two threads about C++17.

² According to Wikipedia the contract is:

Design - by-contract is a methodology for the design and implementation of applications and components popularized by the Eiffel programming language . It consists of considering design elements as participants in a relationship similar to a business contract. Thus, components can be designed assuming that certain input conditions (pre-conditions) will be met, while certain output conditions (post-conditions) must be guaranteed, as well as class invariance (properties that remain invariant despite of the processing performed by the component).

C++ Contracts will follow the attribute syntax (added in C++11):

[[contrato modificador: expresión-condicional]]

Contracts have been moved to C++23, the following is subject to change: The available contracts are:

• expects: A type contract expectsis a pre-condition. Indicates what a function expects from its arguments, and that contract is expected to hold throughout the function call.
• ensures: A type contract ensuresis a post-condition. Indicates the state that the objects passed to a function (or the return from it) are expected to have at the end of the call.
• asert: A type contract assertis an assertion. Indicates a condition that is expected to be satisfied where the contract appears.

When a contract is not fulfilled, a function call will be made with the following signature:

void(const std::contract_violation &);

The object std::contract_violationwill contain information about the breach of contract such as where (file, line, function) has been breached.

Modifiers can be applied to contracts, modifiers will affect how code with contracts is generated and whether or not contracts are checked at runtime. The available modifiers are:

• axiom: The verification of the conditions of this contract is expected to have no cost, it is not evaluated at execution time.
• default: Verification of the conditions of this contract is expected to be inexpensive.
• audit: Verification of the terms of this contract is expected to be expensive.

The contracts that will be verified at compile time contain code that will be compiled, you can specify the level with which you want to compile each translation unit and the resulting behavior will be:

• Default: Checks (compiles) contracts marked as default(contracts that have no modifier are considered default).
• Audit: Verifies (compiles) the contracts marked as auditand default.

I've read the documentation for calc()and understand the syntax, but being in CSS, where no code is executed, I can't figure out when it should be used.

The paradigmatic example sounds quite simple to me and I don't know if it is very useful:

/* property: calc(expression) */
width: calc(100% - 80px);

Are there canonical cases for the use of calc()? Could you name an example in which its use is practical for a solution of a real case?

I see that its use is quite widespread across browsers (93% according to Can I use... ). How recommended is it to use it, and what would be its equivalent for browsers that don't support it (IE 8 and earlier, with some issues with IE 9)?

In ECMA Script 6 you can define javascript variables with let and const , in addition to using var . What would be the recommendation to choose which type of variable definition should be used?

When to use an arrow function in JavaScript?

() => { console.log('test'); }

function() { console.log('test'); }