## [ Politics ] Open question: Can any of you Trump apologists explain why the idea of ​​buying Greenland is floating?

Could it be with the melting of the ice that the resources that are believed to be there will now be more accessible? Why would Greenland / Denmark want to give up what could make them a more important economic entity in the world? This is not like Alaska, where Russia was desperate for money and the state of resources was unknown. Or even buying Gadsden. .

## Object-oriented: is it a good idea to inherit the class in the analyzer module?

Can anyone criticize my approach to writing analyzers please
I need to roll 20 websites, but these are a bit similar websites (clothes / shoes), so I think I'll write an example analyzer with a lot of classes for different elements, and there are 19 more analyzers in each. the inheritance of these classes

Will it be easier in this case to keep the code? Is this the best approach for this task?

I can only say for myself that I want to facilitate the writing of new analyzers, but it will be worse for memory, however, this is not a key factor for my task.

## The OpenBSD PF is blocking I have no idea why

Full rookie in OpenBSD and PF, I have to manage a firewall basically without help.

Well, the question is really simple.

Given the

``````cat /etc/pf.conf | grep -v "#" | grep block
``````

It DOES NOT GIVE OUT,

What am i missing?

## magento2.3 – The installation of Magento 2.3 worked on Ubuntu 18.04, but after restarting Ubuntu, the Magento page will no longer load. Any idea what the problem could be?

I need your help. I am new to Magento 2.3 and, first of all, everything worked perfectly after installation on my Ubuntu 18.04 Maschine, but after my first Ubuntu reboots, the Magento shopping page and administration page no longer load .

My first thought was that Apache or SQL are not running, but I verified it and they have the active state. But Apache2 throws some errors (you can find them in the screenshot). Could these problems be the problem? If so, how can I solve them?

If you don't think this error is the problem, do you have any other ideas?

I would be very relieved if you could help me with this problem, because I already wasted a lot of time and effort with this problem and a proper installation of Magento 2.3. Thank you!

## javascript: is it a good idea to reduce the number of input parameters to a function by packing them in an object?

I am building my own BST algorithm from zero atm in JavaScript.

``````function bst(number, array) {
let currentIndex = 0;
let highIndex = array.length-1;
let lowIndex = 0;
let arrayNotExhausted = true;
let returnedValues = null;

currentIndex = array.length/2;
while (arrayNotExhausted) {
console.log(`The number is \${array(currentIndex)}, currentIndex: \${currentIndex}, high: \${highIndex}, low: \${lowIndex}`);
if (number == array(currentIndex)) {
console.log(`Found the number at \${currentIndex}`);
return true;
}
else {
returnedValues = search(highIndex, lowIndex, currentIndex, arrayNotExhausted, number, array);
highIndex = returnedValues.highIndexValue;
lowIndex = returnedValues.lowIndexValue;
currentIndex = returnedValues.currentIndexValue;
arrayNotExhausted = returnedValues.arrayNotExhausted;
}
}
console.log(`The number \${number} can not be found`);
return false;
}
``````

The code climate complains that a function in the previous code has too many arguments, `search(highIndex, lowIndex, currentIndex, arrayNotExhausted, number, array);`

I am thinking of refactoring my code by packing the six arguments into a single object, for example:

`search(object),` where the object has the six properties, p. ex. `object.highIndex = highIndex, ..., object.array = array.`

Alternatively, I can make some of the variables global variables, but in general, I want to avoid global variables.

## Real analysis – Convergence of a series of functions. Notation / Idea

When we talk about a series of functions, $$sum_ {k = 1} ^ { infty} f_ {k} (x)$$convergent Are we saying that the series is converging to a specific correct function? That is to say: $$sum_ {k = 1} ^ { infty} f_ {k} (x) rightarrow f (x)$$ Or is it a series of functions? that is to say: $$sum_ {k = 1} ^ { infty} f_ {k} (x) rightarrow sum_ {k = 1} ^ { infty} f (x)$$ (This doesn't seem right because all you'll get in the end is $$nf (x)$$.

## Algorithms: If I think I have a publishable idea about a certain problem, how do I publish and proceed?

I am new to research. I am working on a certain problem that has been abandoned by all researchers (in regards to publications). Anyway, I like it for its simplicity and ease of understanding. However, it is a new algorithm for a problem and a new way of answering theoretical questions about the problem.

There is so little research on a certain problem that it would literally take you a day or less to see everything and determine that, in fact, the idea has not yet been analyzed. I am applying the well studied field of integer programming / linear algebra to model each instance of the problem.

Anyway, regardless of whether I respond to an important open problem, I think the approach is valuable in itself, if not for another reason, it makes answering basic questions about the problem much easier, something like how algebraic geometry Answer questions about geometry objects using algebra.

Question:
How do I proceed? Should I spend a month perfecting the paper on my own and putting it on arXiv? Is that everyone?

Thank you.

## Is it a good idea to buy a Huawei Y9 Prime?

I am going to buy a Huawei Y9 Prime because it has good features and is affordable. But I'm not sure if it's a good idea in a situation like this. I want to say that there is a lot of discussion about it in recent days. So what advice would you give me?

## Design – Is this "transparent" test frame a good idea?

Here is an example in R, but the concept applies to any language that supports IO files. I am presenting it in R just because its special operator replacement feature makes the syntax look better.

```````%<-verify%` <- function(x, new.value) {
name <- deparse(substitute(x))
save.file <- paste0(name, '.rds')

if (!file.exists(save.file)) {
message(paste('Generating', save.file))
saveRDS(new.value, save.file)
assign(name, new.value, inherits=TRUE)
} else {
if (!isTRUE(delta <- all.equal(old.value, new.value))) {
warning(delta)
} else {
message('checked')
}
assign(name, old.value, inherits=TRUE)
}
}
``````

Let me explain it in action. Let's say you just received an inherited code base and want to clean up that mess.

``````> get.answer <- function() bitwXor(0xDEAD, 0xBEEF) %% 100
``````

First, you need to run some examples so that the test framework can know the result. should be. When a name is assigned with `%<-verify%` For the first time, its value is stored in a file (which bears his name to avoid collisions in the namespace).

``````> source('test-util.R')
(1) 42
``````

All subsequent `%<-verify%` This name automatically checks the new value against the saved value, and issues a warning if they disagree.

``````> get.answer <- function() 43
Warning message:
``````

Indeed, this prevents the code base from being broken by new changes.

``````> get.answer <- function() 42
Note that you should only use `%<-verify%` in the interfaces that interest you, for example, the exported functions. If you `i %<-verify% i + 1` inside a loop then get ready for a wall of warnings.
Its main merit is transparency, which can simply replace `<-` with `%<-%` and the check is done automatically. People are lazy, so making tests easier to implement basically creates more tests and errors can be detected at an earlier stage.