tomtaylor

Mix.install([:mint, :castore])

defmodule Main do
  def run() do
    total =
      Stream.resource(
        fn ->
          {:ok, conn} = Mint.HTTP.connect(:https, "ftp.bit.nl", 443, mode: :passive)
          {:ok, conn, _ref} = Mint.HTTP.request(conn, "GET", "/speedtest/10mb.bin", [], nil)
          {conn, true}

debasishg

Cache Oblivious and Cache Aware Data Structure and Algorithms

1. Cache-Oblivious Algorithms and Data Structures - Erik Demaine (One of the earliest papers in cache oblivious data structures and algorithms that introduces the cache oblivious model in detail and examines static and dynamic cache oblivious data structures built between 2000-2003)

2. Cache Oblivious B-Trees - Bender, Demaine, Farch-Colton (This paper presents two dynamic search trees attaining near-optimal performance on any hierarchical memory. One of the fundamental papers in the field where both search trees discussed match the optimal search bound of Θ(1+log (B+1)N) memory transfers)

3. Cache Oblivious Search Trees via Binary Trees of Small Height - Brodal, Fagerberg, Jacob (The data structure discussed in this paper works on the version of [2] but avoids the use o

shaeqahmed

  .event.kind = "event"
  .event.type = ["info"]
  .event.category = ["web"]

  .o365.audit = object!(del(.json.o365audit))

  if .o365.audit.CreationTime != null {
    creation_time, err = split(string!(.o365.audit.CreationTime), "Z")[0] + "Z"                                          
    .ts = to_timestamp!(creation_time) 
  }

quanhua92

#!/bin/sh
curl -s https://bunnycdn.com/api/system/edgeserverlist -H "Accept: application/json" | jq -r .[] > /tmp/bunny_ips
echo "" >> /tmp/bunny_ips
curl -s https://bunnycdn.com/api/system/edgeserverlist/ipv6 -H "Accept: application/json" | jq -r .[] >> /tmp/bunny_ips

for ip in `cat /tmp/bunny_ips`; do ufw allow proto tcp from $ip comment 'Bunny IP'; done;

pablodz

# [🟨OPTIONAL] Uninstall old docker versions
sudo apt-get remove docker docker-engine docker.io containerd runc
# Refresh latest version
sudo apt-get update
# Install pre-req
sudo apt-get install -y \
    apt-transport-https \
    ca-certificates \
    curl \
    gnupg \

dlederle

defmodule Acme.Repo do
  use Ecto.Repo,
    otp_app: :acme,
    adapter: Ecto.Adapters.Postgres

  def with_prefix(prefix) do
    module_atom = Module.concat([Acme, Repo, WithPrefix, Macro.camelize(prefix)])

    # We could not find a better way to see if this module already existed
    if !Kernel.function_exported?(module_atom, :prefix, 0) do

devonestes

# Step 1

def create_subscription(email, plan_id, payment_method_id) do
  with %User{customer_id: nil, name: name} = user <-
         Repo.get_by(User, email: email),
       {:ok, %Stripe.Customer{id: customer_id}} <-
         Stripe.Customer.create(%{
           name: name,
           email: email,
           payment_method: payment_method_id,

alco

defmodule TimeFormat do
  def format(seconds) do
    hours = div(seconds, 3600)
    remainder = rem(seconds, 3600)
    minutes = div(remainder, 60)
    seconds = rem(remainder, 60)
    format(hours, minutes, seconds)
  end

  defp format(0, minutes, seconds), do: "#{minutes}:#{pad(seconds)}"

nathanl

James Edward Gray II

Quote from Elixir Mix 63 - "063: Designing Elixir Systems With OTP with Bruce Tate and James Gray", starting at 01:03:13

"I've worked at a bunch of companies building web apps for a long time, and I keep seeing this same pattern, and it haunts me. In the web world, all we want is these long interactions with people, and we live in this stateless world. So what we do is, the first part of every request, we do thirty queries to re-establish the state of the world that we just forgot a few seconds ago after the last request. And then we go forward and make one tiny step forward, and then we forget everything again, so that when the next request comes in we can do thirty queries to put it all back and make one more tiny step. And I kept thinking, "there has to be a better way than this, right?"

And if you look at web advancements over the years, most of the things we're doing are

wosephjeber

Renaming table in Ecto migration

I recently wanted to rename a model and its postgres table in a Phoenix app. Renaming the table was simple and documented, but the table also had constraints, sequences, and indexes that needed to be updated in order for the Ecto model to be able to rely on default naming conventions. I couldn't find any examples of what this would look like but was eventually able to figure it out. For anyone else in the same situation, hopefully this example helps.

In the example below, I'm renaming the Permission model to Membership. This model belongs to a User and an Account, so it has foreign key constraints that need to be renamed.

defmodule MyApp.Repo.Migrations.RenamePermissionsToMemberships do
  use Ecto.Migration