C # new rules for naming methods, variables, classes and properties

I go through the Unity API and find that the nomenclature rules for naming variables, methods, properties, fields, etc. are very different and confusing. For example, sometimes they use variable names with uppercase letters, sometimes they are small. And method name begins with capital letters (why did you make this change?). Can someone please enter all the rules that are consistent on the platform.

magento2 – Magento 2.3: How to hide only free shipping methods based on the zip code

This code hides all shipping methods based on the 2nd value of zip code 0. In this case, all shipping methods will be removed. but i just want to remove free shipping. Can you explain to me how I can do this?

require(('mage/url', 'jquery','domReady!' ,'jquery/ui'),function(url , $)  {
$("(name='postcode')").live('change',function(){
    postCode = $("(name='postcode')").val();
    // console.log(postCode);
    postCode = postCode.slice(1,2);
    console.log(postCode);

            if(postCode == 0){
                    $('.checkout-shipping-method').hide();
                    message = $('#message').length;
                    if(message == 0){
                        $(.checkout-shipping-address').append("Contact  Production Case for Rural Shipping");
                        $("#message").css("color","red");
                        $("#message").show();
                    }
                    else if(message){
                        ("#message").show();
                    }
                }
                else{
                    $('.checkout-shipping-method').show();
                    $("#message").hide();
                }
    });
});

What are the indexing methods?

python – MMO chat system methods

Databases should be used for permanent data, not for short-lived data. Using a database to store short-lived chat messages just to delete them seconds later is quite an anti-pattern. It was common in the early years of PHP that databases were pretty much the only way to exchange data between sessions. However, modern web application frameworks offer ways to communicate between sessions using in-memory techniques without having to abuse a database.

However, if your architecture supports offline messages that are sent as soon as the player is back online, you are not dealing with short-lived data. It's dates that can take days, probably forever. This means that it belongs in a database, so that it does not take up memory and is not lost when the server is restarted.

So my recommendation would be to separate conceptually Chat messages of Offline notifications, The first are fleeting. They are simply sent to all recipients and the server then forgets them. The latter are stored in the database until the recipient connects to the server. The server decides what is a chat message and what is an offline notification. When the recipient is online, it is always a chat message. If the recipient is offline, the server should decide whether it is important enough to create an offline notification or whether it should simply be discarded.

On the other hand, there is an argument for permanently storing all chat messages in the database: you want to log them. This can be useful if you want to investigate reports of abusive behavior. But the question is whether it's worth the cost. Large communities can create a lot of senseless chatter. Is it really worth keeping all of this forever? And then there is the legal problem of data protection. Are you actually allowed to to permanently store all of these messages, which some players are likely to consider confidential? Or maybe you are required Log communications when law enforcement agencies want access? This is a question for your local lawyer.

finance – What financial forecasting methods are available to assess the profitability of a cash flow?

I am sorry for this question. I'm looking for forecasting methods to assess the profitability of a cash flow

I have no experience in this industry, I did some searches in the documentation, but I couldn't find much stuff.

Does Mathematica have anything better than Excel IRR? Any suggestion of where to look is appreciated. I will use the suggested references to improve this question.

Architecture – Does it make sense to combine Fixed TimeStep and Semi-Fixed TimeStep for different update methods in a game loop?

I recently started developing my game engine and I read about game loops and the differences between Fixed TimeStep and Semi-Fixed Timestep. Both can be found on the Internet, but I will publish the most famous article: https://gafferongames.com/post/fix_your_timestep/

As a reminder of both methods:

As far as I can see Semi-solid time steps fixes many problems with different delta times between frames by implementing a while loop that picks up deltas in steps of a certain size until the delta time for the frame is <= 0.0f. If the delta time is less than the step, the delta time is sent to the update function instead. This loop protects against changes in the frame rate, but does not allow deterministic execution, since the delta time sent for the update is not always the same.

Fixed time step Fixes this by implementing an accumulator and calling update only if the accumulated delta time is greater than the step value used by the updates. Ie: If we have a step of 0.2 s length and the elapsed delta is 0.3 s, we take a step and save the remaining time of 0.1 s for the next picture.
Constant updating with the same step enables deterministic behavior regardless of the frame rate.

On my engine I implemented two different update methods that can be used to implement different behaviors: FixedUpdate () and Update (). Both methods follow the same basic principle as that of Unity Engine.

The implementation of the fixed step loop was fairly simple since I just had to stick to the basic theory. But When writing the update method, I doubted that it was a simple update call with the specified delta time in this frame or a semi-fixed step loop, Pseudo code below:

float FixedUpdateTimeStep = 1/60.0; // Fixed update called 60 times per second
float LastFrameTime = GetCurrentTime();
float TimeSinceLastFixedUpdate = 0.0;

while ( !quit )
{
    float CurrentTime = GetCurrentTime();
    float FrameTime = CurrentTime - LastFrameTime ;
    LastFrameTime = CurrentTime;
    TimeSinceLastFixedUpdate += FrameTime;

    // The article seems to use this branch at the end
    // to avoid adding deltas to big but I think this
    // will break determinism if the game was an online
    // one? Thinking of computer A and B and one of them
    // slowing down therefore not computing same deltas.
    //if ( FrameTime > MaxFrameTime )
    //    FrameTime = MaxFrameTime;

    // Fixed update.
    while ( TimeSinceLastFixedUpdate >= FixedUpdateTimeStep )
    {
        TimeSinceLastFixedUpdate -= FixedUpdateTimeStep;
        FixedUpdate(FixedUpdateTimeStep);
    }

    // Semi fixed update. Does this make sense or I should simply
    // call update with the given dt (maybe clamped to protect from
    // spikes) and avoid this extra loop.
    // calling update a single time is what unity does.
    while ( FrameTime > 0.0 )
    {
        // SemiFixedMaxDeltaStep may be the same value as the 
        // FixedUpdateTimeStep or another one.
        DeltaTime = min( FrameTime , SemiFixedMaxDeltaStep);
        Update(DeltaTime)
    }

As far as I can see Combining semi-fixed time steps for the update method with fixed steps for the fixed update seems to contradict the purpose of the latter, since the whole point of semi-fixed time steps is to achieve better resilience for physics by setting an upper limit for the delta time , even if no determinism is reached.

I think for deterministic behavior I should just stick to the fixed time step and call the update method per frame with the expired delta, however it may be. Could you add a clamp to this last one to avoid very long delta times?

Thank you very much and hopefully I was clear enough!

Centralized Wallet Systems – What Methods Are There to Bypass a Malicious Wallet Provider?

I have a question about centralized wallet providers.
Before I ask, I give you my definition of "centralized": In this context, by "centralized" I mean that a wallet sends your transactions only through its own nodes / servers. To give you a clear example: In such a case, the "Ledger Live" app only uses Ledger servers to validate transactions.

In such a centralized case, the only source of error is evident. Because your transactions would come to a complete standstill if the wallet servers were inaccessible for any reason.

In such a scenario, what exactly could a person using such a centralized wallet application do to be able to trade freely with their money? What options are there that would work without using the central wallet app (in this case Ledger Live)? You can assume that the user has 24-word mnemonics from a ledger device.

I think this is a big problem and I honestly don't understand why in the Bitcoin / Decentralization era, many popular wallets continue to validate transactions centrally. Why not connect multiple trusted nodes to decentralize the letter transaction process? But that's another philosophical question, I think. I look forward to your answers to the first important question.

Thank you very much

Do the encrypt_and_digest () and decrypt_and_verify () methods of the Pycryptodome module in Python 3 also perform the electronic signature process?

Do that encrypt_and_digest() and decrypt_and_verify() Methods in the Pycryptodome also perform the electronic signature process?

I saw on the internet that the electronic signature is to sign the message with my private key so that any entity (with my public key) can verify that I have sent the file.

But since then encrypt_and_digest() Method already encrypts the message with my private key and then checks the integrity of the message with decrypt_and_verify()Then the question is raised whether they also carry out the electronic signature process (authenticity) or whether they only carry out this process in order to generate the MAC (integrity).