What websites do you follow for latest updates in SEO?

What websites do you follow for latest updates in SEO?

How do I get GitHub to not show organization’s updates on my timeline

I was recently added to an organization on GitHub and consequently, and updates that anyone makes to a repository on the organization are displayed on my timeline. Is there any way to suppress these updates?

GitHub: not show organization’s updates on my timeline

I was recently added to an organization on GitHub and consequently, and updates that anyone makes to a repository on the organization are displayed on my timeline. Is there any way to suppress these updates?

Ubuntu 20.04.1 LTS updates after 5.4.0-47 low resolution

I have 2 monitors, a Samsung connected with hdmi and a Philips connected with Display port. Video card GeForce GTX 660/PCIe/SSE2.
Both the 5.4.0-48 & -51 updates boot to a single monitor in low resolution. 5.4.0-47 and previous updates work fine.

database – Drupal 9: MISSING UPDATES FOR: MEDIA

After much package dependency finagling via composer, updating PHP, updating MariaDb, etc.. (not as bad as D7 => D8 but still harder than I’d hoped) I managed to update from 8.9 => 9.0.7. I was able to run update.php, clear cache, etc. site seemed to be working ok, no errors. I enabled the core Media module as apparently blazy now depends on it. Now I’m getting:

DrupalCoreDatabaseDatabaseExceptionWrapper: SQLSTATE(42S02): Base table or view not found: 1146 Table ‘########.media' doesn't exist: SELECT "base_table"."vid" AS "vid", "base_table"."mid" AS "mid" FROM {media} "base_table" GROUP BY base_table.vid, base_table.mid LIMIT 1 OFFSET 0; Array ( ) in DrupalCoreEntityEntityStorageBase->hasData() (line 583 of /var/www/sites/#####.test/docroot/core/lib/Drupal/Core/Entity/EntityStorageBase.php).

If I try to run update php I see:
MISSING UPDATES FOR: MEDIA
The installed version of the Media module is too old to update. Update to a version prior to 9.0.0 first (missing updates: media_post_update_collection_route, media_post_update_storage_handler, media_post_update_enable_standalone_url, media_post_update_add_status_extra_filter).

MISSING UPDATES FOR: MEDIA LIBRARY
The installed version of the Media Library module is too old to update. Update to a version prior to 9.0.0 first (missing updates: media_library_post_update_display_modes, media_library_post_update_table_display, media_library_post_update_add_media_library_image_style, media_library_post_update_add_status_extra_filter, media_library_post_update_add_buttons_to_page_view, media_library_post_update_update_8001_checkbox_classes, media_library_post_update_default_administrative_list_to_table_display, media_library_post_update_add_langcode_filters).

I’d rather not take core back to an earlier version to resolve this as I’d have to also downgrade some modules, namely Solr which was not super easy to configure.

Can anyone suggest how I might go about resolving this? Is there a way to update a core module without updating core? I thought of just copying and pasting but obviously that wouldn’t resolve my missing table issue.

Any pointers in the right direction would be immensely appreciated.

updates – Whatsapp keep asking to set up backup then stucks at setup screen

Everytime I open whatsapp it goes to the setup backup screen. After selecting backup frequency and clicking done, it goes no further.
If I want to read a message I have to go from the message alert at the top of the home screen then after reading it as I exit whatsapp it goes to the backup setting first then I have to exit again.

I have installed a new version over the old but same error.
just so you know it was working fine up to a week ago

Apart from uninstalling then reinstalling any suggestions?
Reason why I dont want to uninstall at first is because its a phone that was marketed for the domestic Chinese market and I had to go tru various options to get the google play store and such installed.

any help would be greatly apreciated.

transit – Any updates on UK layovers restricted entry to US?

I read here that someone having a layover in the given areas would also be restricted entry to the US. I’m an F1 student and am planning to fly from US to India for a month in December. The CDC site was last updated on September 14, which is a month ago. I could not find an updated list of rules for nonimmigrants. As of now, I’m looking to book a flight that has a layover at LHR in London, which would put me in the list of restricted people on the way back. Is there a way I can confirm somewhere if that is the case and I should look for alternatives?

javascript – js implementation of a binary heap with logn key updates

I’m looking to get more into programming. I have quite a strong mathematical background but as a programmer I am quite the novice.

I was thinking it would be nice to implement a number of data structures and algorithms (in particular graph algorithms) as this has a nice mathematical flavour to it.

To start with I’ve just done a binary heap, but one where we maintain an internal map so we can quickly find elements so as to reasonably efficiently delete and update them.

The code in full is here

https://github.com/Thrillpool/binary-heaps and index.js contains all the logic.

I am happy for any comments, but let me note that while of course a binary heap should be a performant thing as that is it’s main application, I have only intended to achieve the right big O complexity other than this the code is supposed to be as readable as possible.

Here it is in its entirety

/** @template T */
class MutableArrayBinaryHeap {
    /**
     * @param {(a: T, b: T) => number} cmp
     */
    constructor(cmp) {
        /**
         * @private
         * @type {T()}
         */
        this.internalArr = ();
        /**
         * @private
         * @type {Map<T, (number, number)>}
         */
        this.inverseMap = new Map();
        /**
         * @private
         */
        this.cmp = cmp;
    }

    /**
     * Iterates over the heap.
     *
     * @return {Iterator<T>}
     */

    *(Symbol.iterator)() {
        while (this.internalArr.length !== 0) {
            yield this.extract();
        }
    }

    /**
     * Returns true if the heap is empty
     */
    isEmpty() {
        return this.internalArr.length === 0;
    }

    /**
     * Accounts for a change to the results of cmp which means
     * el has a smaller value in the total order than it used to
     * @param {T} el
     */
    decreaseKey(el) {
        const ind = this.inverseMap.get(el)(0);
        _heapifyDown(this, ind);
    }

    /**
     * Accounts for a change to the results of cmp which means
     * el has a larger value in the total order than it used to
     * @param {T} el
     */
    increaseKey(el) {
        const ind = this.inverseMap.get(el)(0);
        _heapifyUp(this, ind);
    }

    /**
     * Inserts the given element into the binary heap
     *
     * @template {T} S S extends T
     * @param {S} el The element to insert
     */
    insert(el) {
        const candidate = this.internalArr.length;
        this.internalArr(candidate) = el;
        _setInverseMap(this, el, candidate);
        _heapifyUp(this, candidate);
    }

    /**
     * Removes one instance of the given element from the binary heap,
     * given that it exists, otherwise it does nothing
     *
     * @param {T} el the element to delete
     */
    delete(el) {
        const (indToDelete, count) = this.inverseMap.get(el);
        if (indToDelete === -1) {
            return;
        }
        if (count !== 1) {
            _popInverseMap(this, el);
            return;
        }
        _swapVertices(this, indToDelete, this.internalArr.length - 1);
        _popInverseMap(this, el);
        const cmpResult = this.cmp(this.internalArr(indToDelete), el);
        this.internalArr.length = this.internalArr.length - 1;
        if (cmpResult >= 0) {
            _heapifyUp(this, indToDelete);
        } else {
            _heapifyDown(this, indToDelete);
        }
    }

    /**
     * Construct a priority queue using the designated comparing function
     * and initialised with the elements from an iterable
     * @template S
     * @param {Iterable<S>} it
     * @param {(a: S, b: S) => number} cmp
     */
    static from(it, cmp) {
        const b = new MutableArrayBinaryHeap(cmp);
        for (const el of it) {
            const count = _setInverseMap(b, el, b.internalArr.length);
            if (count === 1) {
                b.internalArr.push(el);
            }
        }
        const levels = Math.floor(Math.log2(b.internalArr.length));
        for (let level = levels - 1; level >= 0; level--) {
            const start = Math.pow(2, level) - 1;
            for (let i = start; i < 2 * (start + 1); i++) {
                _heapifyDown(b, i);
            }
        }
        return b;
    }

    /**
     * Given the heap is non empty
     * retrieves the largest element in the heap and removes it
     */
    extract() {
        const topEl = this.peek();
        this.delete(topEl);
        return topEl;
    }

    /**
     * Given the heap is non empty returns the largest element
     */
    peek() {
        return this.internalArr(0);
    }
}

/**
 * Performs the heapify up operation on the given index, i.e. makes the
 * heap such that the elements above the element at that index in
 * the tree order are indeed larger
 * @param {MutableArrayBinaryHeap} m
 * @param {number} candidate the position of the element to heapify up
 * @returns {void} void
 */

function _heapifyUp(m, candidate) {
    const el = m.internalArr(candidate);
    while (candidate !== 0) {
        const parentIndex = Math.floor((candidate - 1) / 2);
        const parent = m.internalArr(parentIndex);
        const cmpResult = m.cmp(el, parent);
        if (cmpResult < 0) {
            m.internalArr(candidate) = el;
            break;
        }
        _swapVertices(m, candidate, parentIndex);
        candidate = parentIndex;
    }
}

/**
 * Performs the heapify down operation on the given index, i.e. makes the
 * heap such that such that the elements below the element at that index in
 * the tree order are indeed larger
 * @param {MutableArrayBinaryHeap} m
 * @param {number} ind the position of the element to heapify down
 * @returns {void} void
 */
function _heapifyDown(m, ind) {
    while (true) {
        const largestAmongstChildren = _largestAmongstChildren(m, ind);
        if (largestAmongstChildren === ind) {
            break;
        }
        _swapVertices(m, ind, largestAmongstChildren);
        ind = largestAmongstChildren;
    }
}

function _swapVertices(m, candidate, parentIndex) {
    const parent = m.internalArr(parentIndex);
    const el = m.internalArr(candidate);

    m.internalArr(candidate) = parent;
    m.internalArr(parentIndex) = el;

    const parentPair = m.inverseMap.get(parent);
    const elPair = m.inverseMap.get(el);

    parentPair(0) = candidate;
    elPair(0) = parentIndex;
}

function _setInverseMap(m, el, index) {
    if (!m.inverseMap.has(el)) {
        m.inverseMap.set(el, (index, 0));
    }
    const indexAndCount = m.inverseMap.get(el);
    indexAndCount(1) = indexAndCount(1) + 1;
    return indexAndCount(1);
}

function _popInverseMap(m, el) {
    const known = m.inverseMap.get(el);
    if (!known) {
        return (-1);
    }
    const (ind, count) = known;
    if (count === 1) {
        m.inverseMap.delete(el);
    } else {
        known(1) = known(1) - 1;
    }
    return (ind, count - 1);
}

function _children(m, index) {
    const length = m.internalArr.length;
    const (left, right) = (index * 2 + 1, index * 2 + 2);

    if (right < length) {
        return (left, right);
    }
    if (left >= length) {
        return ();
    }
    return (left);
}

function _largestAmongstChildren(m, index) {
    const children = _children(m, index);
    if (children.length === 0) {
        return index;
    }
    const el = m.internalArr(index);
    const largeChild = _largestChild(m, children);
    return m.cmp(el, m.internalArr(largeChild)) >= 1 ? index : largeChild;
}

function _largestChild(m, children) {
    if (children.length === 1) {
        return children(0);
    }
    const (left, right) = children;
    return m.cmp(m.internalArr(left), m.internalArr(right)) >= 1 ? left : right;
}

Google Updates and SERP Changes – October 2020

WebmasterWorld’s monthly look at Google’s SERPs changes.

postgresql – Postgreslq, ¿How do I create a trigger that UPDATES, null values, under conditions?

I am doing a trigger, in which:
You must first compare the “nro_persona” value of table “conductor” with table “event”.
If it exists, ask if the “nombre_completo” value is NULL.
If “nro_persona” exists and is NULL, update the data in the “conductor” table to “Event”.
Whenever an insert is made.

How can I validate that the value exists first, included in the trigger? It doesn’t give me an error, it just doesn’t work for me.

--- Insert is Null
CREATE FUNCTION TR_CONDUCTOR() RETURNS TRIGGER
AS
$$
BEGIN
IF EXISTS(SELECT nro_persona,
                 cod_operador,
                 nombre_completo,
                 genero
                 FROM evento
        WHERE nombre_completo is null) THEN
        
INSERT INTO evento(nro_personal, cod_operador, nombre_completo, genero)
    VALUES (new.nro_personal, new.cod_operador, new.nombre_completo, new.genero)
ON CONFLICT (nro_personal)
DO UPDATE SET
cod_operador=excluded.cod_operador,
nombre_completo=excluded.nombre_completo,
genero=excluded.genero;

ELSE
INSERT INTO probando(nro_personal, cod_operador, nombre_completo, genero)
    VALUES (new.nro_personal, new.cod_operador, new.nombre_completo, new.genero);
END IF;
RETURN NEW;
END $$
LANGUAGE plpgsql;
CREATE TRIGGER TR_CONDUCTOR_TMP BEFORE UPDATE ON evento
FOR EACH ROW
EXECUTE PROCEDURE TR_CONDUCTOR() ;

Link to the full code: https://dbfiddle.uk/?rdbms=postgres_10&fiddle=959c4cf72acccdbd81d2debcf4bc2ca9

enter image description here