iosifnicolae2

How To Make Youtube Less Boring

Tutorial: https://www.youtube.com/watch?v=hIqMrPTeGTc
Paste the below code in your browser console (F12 > Console):

(()=>{
    markAllVideosAsNotBeingInteresting({
        iterations: 1
    });
})();

rain-1

Why is IRC distributed across multiple servers?

I have been wondering for a long time why IRC networks have multiple servers. Wouldn't it be simpler just to use a single server?

One of the problems of having multiple servers is that netsplits can occur. Anybody who has been on IRC for a while will have witnessed one. Hundreds of people suddenly ripped out of the chat. This can also screw up channel and user modes, and 'some people' have been known to wait for netsplits in order to takeover channels or enter password protected channels.

So lets compare situation (A) a single IRC server everyone connects to with the current setup people use (B) multiple servers. Let's say you run an IRC network with u = 40,000 users and n = 20 server nodes that people connect to via round robin DNS (meaning that when people resolve the DNS it gives them a random server from the set of 20 to connect to). These are vaguely realistic numbers modelled after libera.chat.

So in (B) you have roughly u/n = 2000 clients connected

lf94

WHEN WILL BROWSERS BE COMPLETE?
A short exploration into the end game of web browsers.

This article may seem to be about bashing Google but it isn't. It's just about
reflecting on the current state and how much longer we should see ourselves
here.

So what is the Web? Well we can agree the Web is a conglomerate of standards
proposed by the W3C. So what do those standards define?

cormullion

using Luxor, Colors

function hilbert(pointslist::Array{Point, 1},
        start::Point, unitx::Point, unity::Point, depth)
    if depth <= 0
        push!(
            pointslist,
            Point(start.x + (unitx.x + unity.x)/2, start.y + (unitx.y + unity.y)/2))
    else
        hilbert(pointslist, start,

kayehld

class Controller {

  // bring in our Scraper and Page classes
  import Scraper
  import Page

  main(args) {
    // parse user's input arguments for target url, scraping limit, and anything else relevant
    // ...

kayehld

class Scraper {

  // bring in our "Page" class
  import Page

  var targetUrl
  var visitedLinks = array()
  var internalLinks = array()
  var externalLinks = array()

kayehld

class Page {

  var dom
  var metadata

  // constructor that parses and stores the retrieved webpage
  construct(webResponse) {
    // use your language's XML/HTML/DOM parsing capabilities or 3rd party library to parse the html into something queryable
    this.dom = MLPARSER.parse(webResponse.htmlContent)

IanColdwater

Mute these words in your settings here: https://twitter.com/settings/muted_keywords

ActivityTweet
generic_activity_highlights
generic_activity_momentsbreaking
RankedOrganicTweet
suggest_activity
suggest_activity_feed
suggest_activity_highlights
suggest_activity_tweet

jpicerno1

# R code re: CapitalSpecator.com post for replicating indexes in R
# "Replicating Indexes In R With Style Analysis: Part I"
# http://www.capitalspectator.com/replicating-indexes-in-r-with-style-analysis-part-i/
# 10 Oct 2017
# By James Picerno
# http://www.capitalspectator.com/
# (c) 2017 by Beta Publishing LLC

# load packages
library(quadprog)

VictorTaelin

async/await is just the do-notation of the Promise monad

CertSimple just wrote a blog post arguing ES2017's async/await was the best thing to happen with JavaScript. I wholeheartedly agree.

In short, one of the (few?) good things about JavaScript used to be how well it handled asynchronous requests. This was mostly thanks to its Scheme-inherited implementation of functions and closures. That, though, was also one of its worst faults, because it led to the "callback hell", an seemingly unavoidable pattern that made highly asynchronous JS code almost unreadable. Many solutions attempted to solve that, but most failed. Promises almost did it, but failed too. Finally, async/await is here and, combined with Promises, it solves the problem for good. On this post, I'll explain why that is the case and trace a link between promises, async/await, the do-notation and monads.

First, let's illustrate the 3 styles by implementing