Matar mataralhawiti

Ever wanted to delete all your likes/favorites from Twitter but only found broken/expensive tools? You are in the right place.

Go to: https://twitter.com/{username}/likes
Open the console and run the following JavaScript code:

setInterval(() => {
  for (const d of document.querySelectorAll('div[data-testid="unlike"]')) {
    d.click()
 }

$ curl -s -XGET http://localhost:8083/connector-plugins|jq '.[].class'

"io.confluent.connect.activemq.ActiveMQSourceConnector"
"io.confluent.connect.elasticsearch.ElasticsearchSinkConnector"
"io.confluent.connect.hdfs.HdfsSinkConnector"
"io.confluent.connect.hdfs.tools.SchemaSourceConnector"
"io.confluent.connect.ibm.mq.IbmMQSourceConnector"
"io.confluent.connect.jdbc.JdbcSinkConnector"
"io.confluent.connect.jdbc.JdbcSourceConnector"

"io.confluent.connect.jms.JmsSourceConnector"

	def run_pipeline(argv):
	opts: PipelineOptions = PipelineOptions(argv)
	gcloud_opts: GoogleCloudOptions = opts.view_as(GoogleCloudOptions)

	if opts.i_want_streaming_engine:
	gcloud_opts.enable_streaming_engine = True
	else:
	gcloud_opts.enable_streaming_engine = False

	...

	"""Trigger Dags #1 and #2 and do something if they succeed."""
	from airflow import DAG
	from airflow.operators.sensors import ExternalTaskSensor
	from airflow.operators.dummy_operator import DummyOperator
	from airflow.utils.dates import days_ago


	with DAG(
	'master_dag',
	schedule_interval='/1 * * *', # Every 1 minute

	from kafka import KafkaConsumer, KafkaProducer, TopicPartition
	from datetime import datetime
	import boto3
	import os
	import sys

	#settings
	client = ["node01:9092", "node02:9092", "node03:9092"]
	topic = 'test-auto-kafka'
	nbrrecords = int(50)

	Recall that cluster write throughput is directly proportional to the number of nodes N,
	and inversely proportional to the number of replicas RF. If a single node writes 15,000 rows per second,
	then you would expect a 5 node cluster writing 3 replicas will be roughly 15,000 * N / RF or 25,000 rows/s.
	[Source](https://www.datastax.com/blog/2011/05/understanding-hinted-handoff-cassandra-08)

	import json
	import random
	import logging
	import re

	from azure.cosmosdb.table.tableservice import TableService
	from azure.storage.queue import QueueService, QueueMessageFormat

	class JobManager(object):
	def __init__(self, accound_name: str, account_key: str, job_group: str, job_id: str = None):

	```
	SPARK_WORKER_INSTANCES=3 SPARK_WORKER_CORES=2 ./sbin/start-slaves.sh
	```
	This will launch three worker instances on each node. Each worker instance will use two cores.
	Also it is possible to manually start workers and connect to Spark’s master node. To do this use command:
	```
	./bin/spark-class org.apache.spark.deploy.worker.Worker spark://IP:PORT
	```

	# ---- Base python ----
	FROM python:3.6 AS base
	# Create app directory
	WORKDIR /app

	# ---- Dependencies ----
	FROM base AS dependencies
	COPY gunicorn_app/requirements.txt ./
	# install app dependencies
	RUN pip install -r requirements.txt

	# Designing Data-Intensive Applications: The Big Ideas Behind Reliable, Scalable, and Maintainable Systems

	1. Chapter 1. Reliable, Scalable and Maintainable Applications
	1. R faults != failures, faults cause failures. Systems should be fault-tolerant, resistant to some types of faults
	2. S Amazon cares about 99.9% percentile because people with higher latencies usually are people who have the most data and therefore, they’re most valuable customers
	3. S tail latency amplification - multiple requests one critical path during one page served
	2. Chapter 2. Data Models and Query Languages
	1. Hierarchical model - imperative querying, no way to change schema, children are ordered, no many-to-many
	2. CODASYL (network) vs SQL
	3. NoSQL - often no schema (precisely - schema on read vs schema on write)