Ruby Performance Predictor

def factorial(x):
    return x * factorial(x - 1) if x > 0 else 1
print(factorial(5))

let fibonacci = (n) => {
  let arr = [0,1];
  for(let i = 2; i <= n; i++) {
     arr.push(arr[i-2] + arr[i-1]);
  }
  return arr[n]
}
console.log(fibonacci(7));

SELECT e.fname, e.lname, d.title
FROM employees AS e
LEFT JOIN positions AS p ON e.emp_no = p.emp_no
LEFT JOIN departments AS d ON p.pos_no = d.dep_no
WHERE d.title = 'SOFTWARE ENGINEER'

library(dplyr)
data_frame <- data.frame('g'=sample(letters[1:3], 100, replace=TRUE), 'x'=rnorm(100))
grp_means <- data_frame %>% group_by(g) %>% summarise(mean(x))

measure = SUMX(RELATEDTABLE('Sales'), [Amount]) - CALCULATE(SUM('Sales'[Amount]), ALL('Sales'))
RETURN
IF(ISBLANK(measure), 0, measure) AS 'Relative Sales Amount'

import threading
lock = threading.Lock()

amount = 0
def process():
    global amount
    for _ in range(100000):
        with lock:
            amount += 1

threads = [threading.Thread(target=process) for _ in range(2)]
for thread in threads: thread.start()
for thread in threads: thread.join()

print(amount)

import asyncio
async def print_after_n_seconds(n):
  await asyncio.sleep(n)
  print(f'printed after {n} seconds')

async def main():
  await asyncio.gather(print_after_n_seconds(1), print_after_n_seconds(2))

if __name__ == '__main__':
  asyncio.run(main())

let square = (value) => new Promise((resolve) => setTimeout(() => resolve(Math.pow(value, 2)), 1000))

(async function () {
  let result = await square(5)
  console.log(result)
})()

SELECT username, COUNT(*)
FROM users
GROUP BY username
HAVING COUNT(*) > 1

=INDEX(A1:D3, MATCH(J2,B1:B3,0), MATCH(J3,A1:D1,0))