4.4 kitkat – Custom rom can I trust? Can I install pure android instead?

I have a “galaxy tab E” device, it is old in years, but it is quite new because I don’t use it very often.
The problem is, it has android 4.4.4.
I notice it has a custom rom to install android 7.1.2 Nougat (see this video https://www.youtube.com/watch?v=FmRtueImtlw) It is a rom made by lineage.
First question, can I trust this rom?

Is there a way to install pure android (7.1.2) from google instead? If I download android from google and install it using odin will it work?

Thanks a lot.

Is there a one click way to make a kindle fire a pure Android device?

For non-technical users, is a one click way to get rid of the amazon stuff & install stock Android?

I am trying to help a friend on another continent who has a kindle fire 7 running OS v 5.6.8 (auto-updated just a few days ago, which looks like it might be a problem).

Solutions seem to involve downloading scripts to a PC, then using Android Studio to side-load the scripts to the kindle, then running them, which would beyond my friend, even with assistance – even if they had a PC, which they do not (nor access to one), just the kindle fire.

Does anyone know of a one-click solution, or something close to it, involving only the kindle fire (7 OS 5.6.8)?

programming languages – Paradox? Pure Prolog is Turing-complete and yet incapable of expressing list intersection?

Turing-complete means “can compute every function on natural numbers that a Turing machine can compute”. It means exactly that and only that.

A list is not a natural number, and list intersection is not a function on natural numbers.

Note: it is, of course, possible to encode lists as natural numbers, which would then make list intersection a function on natural numbers. And I have no doubt that, given you chose a suitable encoding of lists, Pure Prolog will be perfectly capable of expressing list intersection.

To put it another way: just because Pure Prolog is not capable of expressing list intersection using the particular representation of lists that was chosen for General Prolog does not mean that there does not exist a representation of lists more suitable for use with Pure Prolog such that Pure Prolog is capable of expressing intersection of those particular lists.

theory – What’s the difference between a pure function that expects a complex object of a particular type and object oriented programming?

What’s the difference between writing OO code that depends on internal state and writing a pure function that expects an argument that is a data structure of a specific type (and thus has internal data that could be different)? So function f(x) where x is a complex object that may be { foo: 'bar', biz: 'blah' } but will have a consistent, defined structure.

Is the pure function no longer pure if the function signature is a data structure that’s complex and changing the values within the data structure passed change the return of the function? Or is it still a pure function because if you pass the same data structure with the same internal values the function will return the same value?

eigenvalues – How to make a cross-correlation between 2 Fisher matrices from a pure mathematical point of view?

Firstly, I want to give you a maximum of informations and precisions about my issue. If I can’t manage to get the expected results, I will launch a bounty, maybe some experts or symply people who have been already faced to a similar problem would be able to help me.


I have 2 covariance matrices known $Cov_1$ and $Cov_2$ that I want to cross-correlate. (Covariance matrix is the inverse of Fisher matrix).

I describe my approach to cross-correlate the 2 covariance matrices (the constraints are expected to be better than the constraints infered from a “simple sum” (elements by elements) of the 2 Fisher matrices).

  • For this, I have performed a diagonalisation of each Fisher matrix $F_1$ and $F_2$ associated of Covariance matrices $Cov_1$ and $Cov_2$.

  • So, I have 2 different linear combinations of random variablethat are uncorraleted, i.e just related by eigen values ($1/sigma_i^2$) as respect of their combination.

These eigen values of diagonalising are contained into diagonal matrices $D_1$ and $D_2$.

2) I can’t build a “global” Fisher matrix directly by summing the 2 diagonal matrices since the linear combination of random variables is different between the 2 Fisher matrices.

I have eigen vectors represented by $P_1$ and $P_2$ matrices.

That’s why I think that I could perform a “global” combination of eigen vectors where I can respect the MLE (Maximum Likelihood Estimator) as each eigen value :


because $sigma_{hat{tau}}$ corresponds to the best estimator from MLE method.

So, I thought a convenient linear combination of each eigen vectors $P_1$ and $P_2$ that could allow to achieve it would be under a new matrix P whose each column represents a new eigein global vector like this :

$$P = aP_1 + bP_2$$

3) PROBLEM: : But there too, I can’t sum eigen values under the form $D_1 + D_2$ since the new matrix $P= a.P_1 + b.P_2$ can’t have in the same time the eigen values $D_1$ and also $D_2$ eigen_values, can it ?

I mean, I wonder how to build this new diagonal matrix $D’$ such that I could write :

$$P^{-1} cdot F_{1} cdot P + P^{-1} cdot F_{2} cdot P=D’$$

If $a$ and $b$ could be scalars, I could for example to start from taking the relation :

$$P^{-1} cdot F_{1} cdot P = a^2*D_1quad(1)$$

and $$P^{-1} cdot F_{2} cdot P = b^2*D_2quad(2)$$

with $(1)$ and $(2)$ making appear the relation : $$Var(aX+bY) = a^2 Var(X) + b^2 Var(Y) + 2ab Cov(X,Y) = a^2 Var(X) + b^2 Var(Y)$$ since we are in a new basis $P$ that respect $(1)$ and $(2)$.

But the issue is that $a$ and $b$ seems to be matrices and not scalars, so I don’t know how to proceed to compute $D’$.


Is this approach correct to build a new basis $P = a.P_1 + b.P_2$ and $D’ = a.a.D_1 + b.b.D_2$ assuming $a$ and $b$ are matrices ?

The key point is : if I can manage to build this new basis, I could return back to the starting space, the one of single parameters (no more combinations of them) by simply doing :

$$F_{text {cross}}=P . D’ cdot P^{-1}$$ and estimate the constraints with covariance matrix : $C_{text{cross}}=F_{text {cross}}^{-1}$.

If my approach seems to be correct, the most difficulty will be to determine $a$ and $b$ parameters (which is under matricial form, at least I think since with scalar form, there are too many equations compared to 2 unknown).

Sorry if there is no code for instant but I wanted to set correctly the problematic of this approach before trying to implement.

Hoping I have been clear enough.

Any help/suggestion/track/clue is welcome to solve this problem, this would be fine to tell it.

dependency injection – What are the disadvantages to using this form of pure DI in Python?

I want to perform dependency injection in my Python application without using reflection. My position on reflection is informed largely by the “don’t hide things” philosophy (I am unable to find a decent reference to this on google at the moment). What that basically means to me is that code ought to be easily discoverable by an incoming programmer (either your own code at some point in the future, or another programmer coming in to edit or extend your code).

It’s important for me to note here that my primary motivation for dependency injection is the ability to easily test individual services and dependencies without using Python’s patch, but instead to rely on an easily accumulated set of reusable mock dependencies.

Setting aside the reflection debate for the moment, here is one way I see that one can accomplish dependency injection without reflection.

The Container

The container houses my Python application’s dependencies. It could be a simple dictionary.

# container.py

dependencies = {}

The Composition Root

The point of the composition root is to have a centralized location where all needed application dependencies are drawn together and configured in whatever way is necessary. Some classes, for example, might need to be instantiated with config-specific parameters. In Python, I have not seen something like this in the wild. It seems like the composition root needs to be imported specifically by an environment-specific, executed module.

The below illustrates an example where a hypothetical dependency TaskManager depends on a service ApiService. TaskManager, in turn, is a service used throughout the application.

# run_prod.py - runs a production-configured instance of my application

from container import dependencies
from services import TaskManager, ApiService
import config
from app import App

api_service = ApiService(config.api_service_endpoint)
task_manager = TaskManager(api_service)
dependencies('task_manager') = task_manager

app = create_app(dependencies)
app.run(host=config.host, port=config.port)

The App

The application itself at this point is more or less a shallow orchestrator of the services injected into it, since all chunks of code that need to be tested in isolation are defined outside of it, and injected into it in this scheme.

# app.py

def create_app(dependencies)
    app = Flask(__name__)
    @app.route('/task/<task_id>', methods=('GET'))
    def get_task(task_id):
        task = dependencies.get('task_manager').find_task_by_id(task_id)
        return task

Another similar approach might be to import the dependency container, rather than inject it as an argument to the create_app function. In that case I don’t need the constructor function:

# app.py

from container import dependencies

app = Flask(__name__)
@app.route('/task/<task_id>', methods=('GET'))
def get_task(task_id):
    task = dependencies.get('task_manager').find_task_by_id(task_id)
    return task

Testing as a primary motivation for dependency injection

We can create as many use-specific composition roots as we want. For example, if we create one for testing, instead of having a separate run_prod.py, we can just compose the dependencies in the same module as the test (or in a separate module, for re-use). Let’s go with module test_flask_endpoint.py.

For this example, let’s say we want to test the TaskManager together with the Flask layer, but don’t want to make outgoing HTTP calls. We mock out ApiService.

# test_flask_endpoint.py
import pytest

def test_app():
    from services import TaskManager

    class MockApiService():
        def get_task_details(task_id):
            {"task_id": task_id, "description": "does something special"}

    mock_api_service = MockApiService
    task_manager = TaskManager(mock_api_service)
    dependencies('task_manager') = task_manager

    app = create_app(dependencies)
    test_app = app.test_client()
    return test_app

def test_task_endpoint(test_app):
    assert test_app.get('/task/3').json()('description') == 'does something special'

One disadvantage I see to doing DI this way is that the app is coupled to the injector, namely, the dependencies argument of create_app. Is there a way around this? It is not clear to me that this matters.

⚡️★QIS.HOST Pure SSD VPS CLOUD 17 Location with 1GBPS $6 . ★⚡️★ | Proxies-free

QIS HOST :desktop: is High-Speed Cloud Hosting provider which are designed for Performance amd High-Availability.
Our hosting company provides premium 24/7 support and value.
We are using high-performance systems and cutting edge technology to provide you with the best possible service. We built it on top of a 10 Gigabit network.
✔ Business Class Hosting

OUR LOCATION: :checkered_flag:

Seattle, Washington |Silicon Valley, California |Los Angeles, California |Dallas, Texas |Atlanta, Georgia |Miami, Florida |New Jersey |Chicago, |Illinois


London |Paris |Amsterdam |Frankfurt

Singapore |Seoul |Tokyo


Why Choose Us?
Cloud server located in 17 locations.
24×7 Best Staff
Fast Servers
Free Support via Support Ticket
Free Migration – QIS for free help migrate your website.
Get discount for 5 and more cloud VPS

Cloud 25GB SSD
CPU – 1 core
IPv4 – 1
IPv6 – 1
Starting at: $6 USD/month — ORDER NOW

Cloud 55GB SSD
CPU – 1 core
IPv4 – 1
IPv6 – 1
Starting at: $12 USD/month — ORDER NOW

Cloud 80GB SSD
CPU – 2 cores
IPv4 – 1
IPv6 – 1
Starting at: $23 USD/month — ORDER NOW

Cloud 160GB SSD
CPU – 4 cores
IPv4 – 1
IPv6 – 1
Starting at: $44 USD/month — ORDER NOW

Cloud 320GB SSD
CPU – 6 cores
IPv4 – 1
IPv6 – 1
Starting at: $90 USD/month — ORDER NOW

Cloud 640GB SSD
CPU – 8 cores
IPv4 – 1
IPv6 – 1
Starting at: $185 USD/month — ORDER NOW

Cloud 1280GB SSD
CPU – 16 cores
IPv4 – 1
IPv6 – 1
Starting at: $360 USD/month — ORDER NOW

Cloud 1600GB SSD
CPU – 24 cores
IPv4 – 1
IPv6 – 1
Starting at: $715 USD/month — ORDER NOW

more tariffs Cloud SSD VPS

We accept following payment methods:
– Visa / MasterCard
– WeChat
– Alipay
– NETS (Singapore)
– Paysera (OUR company fully verified)
– PayPal
– BitCoin
– Bank Transfer USD
– Bank Transfer EURO (SEPA )
– iDeal
– WebMoney (WME)
– PaySafeCard

Follow us and get discount :hoppers:


Chat with us @

Email us @
@| support @ qis.host