SSH tunnel in remote Windows loads infinitely

I have the following configuration: I need to maintain a web application on a remote Linux server. When I work from my company, I connect through PuTTY with an SSH tunnel for the ports localhost:80 or localhost:8080. Until now, this has always worked.

Now I am in the home office. Because the Linux server only allows connections through our company's public IP, I log in there via VPN and use a remote desktop connection to a Windows virtual machine in our company. There, I have PuTTY and Firefox to work. I can connect to the Linux server with PuTTY, but in Firefox (also on the remote desktop), when I call the forwarded port, it hangs infinitely. (Also, there is no error: the connection is not available). In the Linux shell, I get HTML output immediately with wget, so it is not that the service does not respond. What can that be?

Even weirder: My colleague uses the same settings (we even defer the PuTTY settings from the registry) and finds no comparable issues.

Is it possible to make an infinitely self-similar fractal in SVG?

When I say self-similar fractal, I don't mean a fractal that is finitely detailed I mean a infinitely Detailed SVG (that is, when you zoom in, you don't find any limits for the fractal). Is this possible? For example, could you build an infinitely detailed version of the Serpinski triangle in SVG?

Sudoku Generator in Java: Unable to find non-repeating numbers in region, row and column 3×3. The program runs infinitely

Here is the code I wrote:

import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Random;

public class Main {
    //This function finds a number, which fits in a specified spot in the sudoku grid.
    //I think the problem lies somewhere in this function, I don't know where
    public static int generateNumber(int xCords, int yCords, int()() sudokuGrid){
        Random rand = new Random();

        int generatedNumber = rand.nextInt(9)+1;

        boolean isGood = false;
        boolean isGoodRow = false;
        boolean isGoodColumn = false;
        boolean isGoodSquare = false;

        int howManyTimes = 0;
        while(isGood == false){

            generatedNumber = rand.nextInt(9)+1;

        isGoodRow = checkRow(xCords,yCords,generatedNumber,sudokuGrid);
        isGoodColumn = checkColumn(xCords,yCords,generatedNumber,sudokuGrid);
        isGoodSquare = check3x3(xCords,yCords,generatedNumber,sudokuGrid);


            isGood=(isGoodSquare&isGoodColumn&isGoodRow);

        howManyTimes++;
        //Returing 0, if no number fits (it isn't the best approach, I don't have an idea how to make it better)
        if(howManyTimes == 10){
           generatedNumber = 0;
           break;
        }

        }

        return generatedNumber;


    }
    //this function checks if a number doesn't repeat in the row
    public static boolean checkRow(int xCords, int yCords, int generatedNum, int()() sudokuPlane){

        boolean flag = true;
        for (int columns = 0; columns < yCords; columns++) {
            // A cell containing the number 0 is an empty input box in Sudoku grid
            if (sudokuPlane(xCords)(columns) == generatedNum) {
                flag = false;

                break;
            }

        }
        return flag;
    }
    //this function checks if a number doesn't repeat in the column
    public static boolean checkColumn(int xCords, int yCords, int generatedNum, int()() sudokuPlane){

        boolean flag = true;
        for (int row = 0; row < xCords; row++) {
            // A cell containing the number 0 is an empty input box in Sudoku grid
            if (sudokuPlane(row)(yCords) == generatedNum) {
                flag = false;
                break;
            }
        }
        return flag;
    }
    //this function checks if a number doesn't repeat in the 3x3 grid inside the sudoku
    public static boolean check3x3(int xCords, int yCords, int generatedNum, int()() sudokuPlane){
        boolean flag = true;

        int n = 0;
        int m = 0;

        //Here I separate the sudoku grid into 9 3x3 grids, then find in which grid the spot lays.
        if(xCords<2)
            n = 0;
        else if(xCords>5)
            n = 2;
        else
            n = 1;

        if(yCords<2)
            m=0;
        else if(yCords>5)
            m = 2;
        else
            m = 1;


        for(int x = 0;x<3;x++){
            for(int y = 0;y<3;y++){


                if(sudokuPlane((3*n)+x)((3*m)+y)==generatedNum){
                    flag = false;
                    break;
                }
            }
        }




        return flag;
    }

    public static void print(int()() sudokuPlane){
        System.out.println();

        for(int x = 0; x<9; x++){
            System.out.println(" ____________________________________");
            for(int y = 0; y<9;y++){
                System.out.print(" | " + sudokuPlane(x)(y));

            }
            System.out.println();
        }
    }

    public static void printToFile(int()() sudokuPlane, PrintWriter writer){


        for(int x = 0; x<9; x++){
            writer.println(" ____________________________________");
            for(int y = 0; y<9;y++){
                writer.print(" | " + sudokuPlane(x)(y));

            }
            writer.println();
        }
    }


    public static void main(String() args) throws IOException {
        int()() sudokuGrid = new int(9)(9);

        boolean isAsigned = false;
        boolean isPossible = false;

        Random rand = new Random();
        PrintWriter writer = new PrintWriter(new FileWriter("sudokus.txt"));


            LOOP:
            while (isPossible == false) {

               for (int x = 0; x < 9; x++) {

                    for (int y = 0; y < 9; y++) {
                        int genNum = generateNumber(x, y, sudokuGrid);
                        //Here if a number returned is 0, this part reruns, trying to make a new sudoku.
                        if(!(genNum == 0)) {
                            sudokuGrid(x)(y) = genNum;
                        }
                        else
                            {
                            continue LOOP;
                        }
                    }
                }
               isPossible = true;
            }

            printToFile(sudokuGrid, writer);

        writer.close();
    }
}

What I want to do is:

  1. Take a place on the Sudoku grid
  2. Generate a random number
  3. Check if it doesn't repeat on the x, y and on the 3x3 square
  4. Returns a number that is not repeated, or returns 0, when no number fits
  5. Assign the generated number to my place
    (if 0 is returned, the sudoku grid is reset and starts looking for numbers from
    the beginning)

I managed to find numbers that don't repeat on the x-axis and y-axis, but after checking if it repeats on the 3x3 square, you can't find any numbers that don't repeat on those 3 places. This causes the program to run infinitely.

I hope someone can tell me what I'm doing wrong and maybe come up with a better way to do what I'm trying to do.

I was looking for other resources, but couldn't find any solution similar to mine, and for me, it is quite difficult to understand how a program works just by looking at it.

Also, I asked about Stack Overflow, but my question went unanswered and was removed as being too general, even after editing. I hope someone can help me here: D

Prove using Gaussian primes that there are infinitely many prime numbers in the arithmetic progression 1, 5, 9, 13, 17, 21, …

Tip: if not multiply them and add i; the result has a Gaussian prime factor q of type (S). Show that q (q bar) is a "new" prime.
I know that (S) means division, which is when q is prime to ordinary integers and is not in Gaussian and p = q (q bar), where q bar is the complex conjugate. Overall, I am very confused on how to test this with Gaussian integers, so any help is appreciated.

Turing machines: show that in each infinitely computable enumerable set, there is an infinite set of decidable elements

I encountered this problem: Show that in each infinitely computable enumerable set, there is a decidable infinite set.

As an attempt to solve the problem, I could only think of a construction test. Without loss of generality, that the alphabet be $ Sigma = {0,1 } $. The construction is as follows, suppose that $ TM $ $ M $ recognizes an infinitely enumerable set enumerable $ L $, we can form a decisive language $ D subseteq L $ as follows:

1) lexicographically list all input words $ w $ in $ Sigma ^ * $ and repeatedly perform steps $ a-b: $

a) in the $ k $step, run $ M $ in input words $ {w_0, w_1, …, w_k } $ for $ k $ steps where words $ {w_0, w_1, …, w_k } $ are ordered lexicographically

b) yes $ M $ accept an input word $ w in {w_0, w_1, …, w_k } $ from step 2, include $ w $ in a temporary language $ D_ {temp} $

2) divide the words into $ D_ {temp} $ in two, the ones that start with $ 0 $ They are $ in D $while those that start with $ 1 $ They are $ not in D $, along with all the other words $ Sigma ^ * – D_ {temp} $.

Step (1) is not repeated in a word $ w $ since each execution of step (1) is limited by a finite number of $ k $ Steps. Is this construction ok? Or did I miss something …

cpu – What can we scale a system vertically infinitely?

Vertical scaling has limitations.

These limitations are called Physics and Engineering.

It turns out that Physics doesn't like doing too much work in one place, and our current engineering skills can only squeeze out so much useful work before it becomes useless noise.

Regarding the current performance:

  • You could go and look for the benchmarks for the various systems you are using.

  • You could go even further and compare a benchmark with a workload similar to the workload you have in mind.

Responses to your direct points:

  1. Stupid answer: in 2020, somewhere in the range of 64 GB to 1 TB based on specific hardware, it could be more, but that quickly becomes expensive.

    • Non-stupid answer: = Min(2 ^ bits in the pointer * number of system provided heaps, Max OS support Memory, Max supported Ram Module Size * Available Ram Slots)
  2. Stupid answer: in 2020 a few bytes of Tera.

    • Non-stupid answer: = Min(max file size in File system * Max number of files in file system * number of supported file systems, Max OS Support for File-system size, Number of available Drive Connection Ports * Max size of installable storage modules)
  3. Stupid answer: bits per second. Although you may be talking about the specific performance of the application, in which case concurrent connections or requests per second are better metrics.
    • Non-stupid answer: the slowest point of the network. It is probably the Internet link itself or the application that responds to network requests. Although it could easily be any of the network devices involved.

WP Cron's works are repeated infinitely

I am writing a script to add a named Cron job that updates a single user, which runs every 5 minutes or so.

My problem is that the job runs for each user again and again every second or so. Here is the code that I placed inside my functions.php file.

This is my first foray into the functionality of WP Cron with WordPress and I would like to know if I configured the jobs correctly.

function so_custom_cron_schedule( $schedules ) {
    $schedules('every_5_minutes') = array(
        'interval' => 300,
        'display'  => __( 'Every 5 minutes' ),
    );
    return $schedules;
}
add_filter( 'cron_schedules', 'so_custom_cron_schedule' );

function update_social_user($user_id){
  $user = get_userdata($user_id);
  if(!$user){
    return;
  }
  var_error_log('running for '.$user_id);
}

function assign_cron(){
  $users = get_users(( 'role__in' => ( 'administrator', 'seller') ));
  $args = array(false);
  foreach($users as $user){
    $hook_name = 'update_fb_'.$user->ID;
    add_action($hook_name,'update_social_user');
    if(!wp_next_scheduled($hook_name,$args)){
      wp_schedule_event(time(),'every_5_minutes',$hook_name,array($user->ID));
    }else{
      var_error_log('Already set');
    }
  }
}

assign_cron();

Is the range of $ A, A ^ * $ the same in an infinitely dark Hilbert space?

Leave $ A: H rightarrow H $ be a linear operator bounded in the Hilbert space $ H $ with rank $ r (A) $. Then it is $ r (A) = r (A ^ *) $? This is trivial for Hilbert spaces with finite light, but what about spaces with infinite light?

Leaderboards: what are the known game mechanics to not allow the player to become infinitely rich and still be fun to progress?

I want to make an online game with a leaderboard. A player must be able to gather tools / resources to continue exploring / harvesting. The problem I want to solve is that someone can find an infinite way to harvest things like money, food, ammunition, craft resources, etc., but I don't want it to happen, because: 1] it can ruin the leaderboard 2] potentially disconnects old players from new players because they are interested in different things without having anything to talk about to share the gaming experience. The player should sometimes be forced to start over, but it should still be fun.


For example, games about zombies. AFAIK, the game that Project Zomboid had the number of zombies grows and resources are limited in such a way that I was losing somehow. Why would it still be fun? Because there is a challenge in how many days can you survive.

Another example: Kingdom of the Mad God. There you enter the leaderboard only when you die. Then, once you reach the goal, you start from level 1 again. You can't be in the rankings and keep progressing. Why not ruin the fun? Maybe because you don't lose the loot you have stored in a "vault" and while you're on level 1 and can't use most of your loot immediately, it's still there, not lost.

Rogue games like Nethack, Stone Soup, Cogmind: basically, the world has a limited size and once you clean the level you have nothing more to do than move on to the next level. It's still fun because once you master your skills in the game, competition changes from maximizing your progress to minimizing the steps you have used to reach the ultimate goal. Like spent steps, time, skills used, etc.

Rust: In this game, players play against each other and lose almost everything when your base is attacked. The base is an object in the 3D world and to attack it, the opponent must make almost a straight hole towards the center. So The amount of resources you have to spend to shield your base is X ^ 3, where X is the amount of resources needed to attack you. This makes it impossible to arm yourself infinitely and eventually assault you anyway. Why is it still fun? Maybe because everything is cleaned once in a few weeks and there are game updates That makes it not boring to start over because the game will be a little different.

There is a game mechanic in The Elder Scrolls Online that prevents commercial guilds from becoming infinitely rich, as I understand it. I am not the guild owner, so I may be wrong, but every week there is an offer that forces the unions to pay as much as they can to win an offer To say simply, have a profit during the week. AFAIK all offers are gone and this is how the amount of money that guilds have in the MMO game without wipes is limited.


I want my game to have some kind of "death" that restores progress to keep players away from having an infinitely large base, an amount of money, etc., while it's still fun to start over. What are some other game mechanics that I missed?

postgresql – Schema design for infinitely expanding variables

I am putting together a scheme for a progressive story that will track user choices. Because it will be developed for at least one year, I need a scheme that is safe to handle constant additions. I have the feeling that constantly adding new columns to existing tables is a bad practice. My other consideration was that, using Postgres, I could store a JSON that could be read and replaced over time, but then nesting could be a problem if I wanted more complexity.

Are the best practices to create a scheme in which not all possible variables are known?