Shap Bytes - Shap Bytes

Mikrotik DDNS IPv6 via Cloudflare

2034-02-08T00:00:00+00:00

The majority of Mikrotik scripts I came across online utilized an external service to locate my IP address, and then used a Global API key to modify the DNS records on Cloudflare. I was searching for a more secure method to update the Cloudflare DNS record.</p>

Creating an authorization token within the Cloudflare Dashboard with limited credentials allows this script to ensure that your entire Cloudflare account is not compromised even if your key leaks.</p>

# ** CONFIGURE SECTION **
</span>
</span># IPv6 interface
</span>:local</span> wanif    </span>"ether1"
</span>
</span># Cloudflare section
</span>
</span># Using Access Token Instead of Global API Key
</span>:local</span> key      </span>"access_token"
</span>:local</span> zoneId   </span>"zone_id"
</span># To Find HostId/Record Id, Need to Call Cloudflare API; See Below
</span>:local</span> hostId   </span>"record_id"
</span>
</span># Domain hostname
</span>:local</span> hostName </span>"shapath.com.np"
</span>
</span># ** END OF CONFIGURE SECTION **
</span>
</span># Get WAN interface IPv6 address
</span>:global</span> ip6wan
</span>:local</span> ip6new </span>[</span>/ipv6 address get [/ipv6 address find interface=</span>$</span>wanif global</span>]</span> address]
</span>:set</span> ip6new </span>[</span>:pick </span>[</span>:tostr </span>$</span>ip6new</span>]</span> 0 </span>[</span>:find </span>[</span>:tostr </span>$</span>ip6new</span>] </span>"/"</span>]]
</span>
</span>:if</span> (</span>[</span>:len </span>$</span>ip6new</span>]</span> = 0) do</span>=</span>{
</span>  :log error "[Cloudflare DDNS] Could not get IPv6 for interface </span>$</span>wanif</span>"
</span>  :error "[Cloudflare DDNS] Could not get IPv6 for interface </span>$</span>wanif</span>"
</span>}
</span>
</span>:if</span> (</span>$</span>ip6new != </span>$</span>ip6wan) do</span>=</span>{
</span>    
</span>    :local url    "https://api.cloudflare.com/client/v4/zones/</span>$</span>zoneId</span>/dns_records/</span>$</span>hostId</span>"
</span>    :local header "Authorization: Bearer </span>$</span>key</span>, content-type: application/json"
</span>    :local data   "{</span>\"</span>type</span>\"</span>:</span>\"</span>AAAA</span>\"</span>,</span>\"</span>name</span>\"</span>:</span>\"</span>$</span>hostName</span>\"</span>,</span>\"</span>content</span>\"</span>:</span>\"</span>$</span>ip6new</span>\"</span>,</span>\"</span>ttl</span>\"</span>:60,</span>\"</span>proxied</span>\"</span>:false}"
</span>    
</span>    </span># :log info "[Cloudflare DDNS] URL: $url"
</span>    </span># :log info "[Cloudflare DDNS] HEADER: $header"
</span>    </span># :log info "[Cloudflare DDNS] DATA: $data"
</span>    :log info "[Cloudflare DDNS] Updating host </span>$</span>hostName</span> address to </span>$</span>ip6new</span>"
</span>
</span>    :do {
</span>        
</span>      /tool fetch mode=https http-method=put http-header-field=</span>$</span>header</span> http-data=</span>$</span>data</span> url=</span>$</span>url
</span>      :log info "[Cloudflare DDNS] Updated: </span>$</span>ip6new</span>"
</span>      
</span>    } on-error={ 
</span>        
</span>      :log error "[Cloudflare DDNS] Failed to update"
</span>    };
</span>}
</span></code></pre>
Where is my Record Id/Host Id?#</a></h4>
curl</span> --request GET </span>\
</span>           --url https://api.cloudflare.com/client/v4/zones/{zone_id}/dns_records </span>\
</span>           --header </span>'Content-Type: application/json' </span>\
</span>           --header </span>'X-Auth-Email: {cloudflare_email@email.com}' </span>\
</span>           --header </span>'X-Auth-Key: {global_api_token}'
</span></code></pre>
Since this Global API Key is only used once to find the correct record id, it is fine for me.</p>
Source#</a></h4>

https://github.com/dudanov/mikrotik-cloudflare-ddns-scripts/blob/master/cloudflare6ddns</a></li>
</ul>



Self-Hosted Tailscale DERP Server
2025-09-14T00:00:00+00:00
Setting up a custom DERP (Designated Encrypted Relay for Packets) server for Tailscale allows you to route traffic through your own infrastructure when direct peer-to-peer connections aren’t possible.</p>
Why Self-Host?#</a></h2>
Tailscale’s default DERP servers can be quite slow and their QoS (Quality of Service) severely impacts performance for long-term streaming use cases. While they work perfectly fine for one-time use cases like quick file transfers or occasional remote access, sustained traffic like video streaming or large file synchronization suffers from bandwidth limitations and throttling.</p>
Self-hosting your own DERP server eliminates these performance bottlenecks and gives you full control over the relay infrastructure. It’s not a dramatic speedboot you’re going to see, but it’s quite a bit faster for sustained workloads.</strong></p>
Running the DERP Server#</a></h2>
Deploy the DERP server using Docker with client verification enabled:</p>
sudo</span> docker run -d </span>\
</span>  --name derper </span>\
</span>  --restart unless-stopped </span>\
</span>  -e DERP_DOMAIN=derper.domain.com.np </span>\
</span>  -e DERP_VERIFY_CLIENTS=true </span>\
</span>  -v /var/run/tailscale/tailscaled.sock:/var/run/tailscale/tailscaled.sock </span>\
</span>  -p 8480:80 </span>\
</span>  -p 8443:443 </span>\
</span>  -p 3478:3478/udp </span>\
</span>  fredliang/derper
</span></code></pre>
The DERP_VERIFY_CLIENTS=true</code> flag ensures only your Tailscale clients can connect, authenticating through the mounted Unix socket.</p>
Configuring Custom DERP Region#</a></h2>
Add your custom DERP server to Tailscale’s ACL configuration in the Tailscale dashboard using a region ID between 900-999:</p>
	</span>"derpMap"</span>: {
</span>		</span>"OmitDefaultRegions"</span>: </span>false</span>,
</span>		</span>"Regions"</span>: </span>{
</span>			</span>"901"</span>: </span>{
</span>				</span>"RegionID"</span>:   </span>901</span>,
</span>				</span>"RegionCode"</span>: </span>"selfhosted-derp"</span>,
</span>				</span>"regionName"</span>: </span>"AsiaPacific"</span>,
</span>				</span>"Nodes"</span>: </span>[
</span>					{
</span>						</span>"Name"</span>:     </span>"1"</span>,
</span>						</span>"RegionID"</span>: </span>901</span>,
</span>						</span>"HostName"</span>: </span>"derper.domain.com"</span>,
</span>						</span>"STUNPort"</span>: </span>3478</span>,
</span>						</span>"DERPPort"</span>: </span>443</span>,
</span>					}</span>,
</span>				]</span>,
</span>			}</span>,
</span>		}</span>,
</span>	}
</span></code></pre>
Reverse Proxy for SSL Certificates#</a></h2>
Use Caddy to handle SSL certificate issuance and reverse proxy to the DERP server:</p>
http://derper.domain.com {
</span>    reverse_proxy localhost:8480
</span>}
</span></code></pre>
This configuration allows Let’s Encrypt to issue certificates from within the Docker container through the reverse proxy setup.</p>
Key Benefits#</a></h2>

Custom routing</strong>: Control where your Tailscale traffic is relayed</li>
Reduced latency</strong>: Place DERP servers closer to your devices</li>
Enhanced privacy</strong>: Keep relay traffic on your own infrastructure</li>
Client verification</strong>: Only authenticated Tailscale clients can use the relay</li>
</ul>


Server-Side Events (SSE) with Phoenix/Elixir
2024-08-29T00:00:00+00:00
Understanding Server-Sent Events#</a></h2>
Server-Sent Events (SSE) is a powerful technology that allows servers to push data to web clients over HTTP connections. It provides a way for servers to send real-time updates to clients without the need for long-polling or WebSockets. This makes SSE an excellent choice for scenarios where you need one-way communication from the server to the client, such as live updates, notifications, or streaming data.</p>
While Phoenix has traditionally leaned towards WebSockets for real-time, bidirectional communication, SSE offers a simpler, unidirectional approach that’s particularly well-suited for certain use cases. In this post, we’ll explore how to implement SSE using Plug</a> in Phoenix, with the help of send_chunked/2</code>, chunk/2</code>, and EventSource</code>.</p>
Setting Up the Controller#</a></h2>
First, we need to set up a controller action that will handle our SSE connection:</p>
def </span>sse</span>(conn</span>,</span> _params) </span>do
</span>  conn
</span>  </span>|></span> put_resp_header(</span>"cache-control"</span>, </span>"no-cache"</span>)
</span>  </span>|></span> put_resp_content_type(</span>"text/event-stream"</span>)
</span>  </span>|></span> send_chunked(</span>200</span>)
</span>end
</span></code></pre>
Let’s examine this code:</p>

We set the response content type to "text/event-stream"</code>, which is crucial for SSE.</li>
We use send_chunked(200)</code> to initiate a chunked response with a 200 status code.</li>
</ul>
Using send_chunked</code>#</a></h2>
The send_chunked/2</code> function is key to implementing SSE in Plug. It does two important things:</p>

It sends the HTTP headers to the client, indicating that the response will be sent in chunks.</li>
It switches the connection to chunked mode, allowing us to send data in multiple chunks over time.</li>
</ol>
Sending Events with chunk</code>#</a></h2>
Once we’ve initiated a chunked response, we can use the chunk/2</code> function to send data to the client:</p>
defp </span>send_events</span>(conn) </span>do
</span>  </span>Enum</span>.</span>reduce_while(mock_llm_response()</span>,</span> conn</span>, </span>fn</span> chunk</span>,</span> conn </span>->
</span>    </span>case</span> chunk(conn</span>,</span> chunk) </span>do
</span>      {:ok</span>,</span> conn} </span>->
</span>        </span>Process</span>.</span>sleep(</span>100</span>)
</span>        {:cont</span>,</span> conn}
</span>      {:error</span>, </span>:closed} </span>->
</span>        {:halt</span>,</span> conn}
</span>    </span>end
</span>  </span>end</span>)
</span>end
</span></code></pre>
In this example:</p>

We iterate over a list of mock responses.</li>
For each chunk, we use chunk(conn, chunk)</code> to send the data.</li>
We handle the result of chunk/2</code>:

If it’s successful ({:ok, conn}</code>), we continue the loop.</li>
If there’s an error (e.g., the connection is closed), we halt the loop.</li>
</ul>
</li>
In the last step conn is returned</li>
</ul>
Formatting the Event Data#</a></h2>
For SSE to work correctly, each event should be formatted as follows:</p>
data: Your event data here\n\n
</span></code></pre>
Note the double newline at the end - this is crucial for separating events. In our example, we format the data like this:</p>
|> </span>Enum</span>.</span>map(&</span>"data: #{</span>&</span>1}</span>\n\n</span>"</span>)
</span></code></pre>
Read more about the format here</a></p>
Client-Side: Using EventSource#</a></h2>
On the client side, you can use the EventSource API to receive these server-sent events:</p>
const </span>eventSource </span>= new </span>EventSource</span>(</span>"/sse"</span>)</span>;
</span>
</span>eventSource</span>.</span>onmessage </span>= </span>(event) </span>=> </span>{
</span>  </span>console</span>.</span>log</span>(</span>"Received data:"</span>, </span>event</span>.</span>data)</span>;
</span>}</span>;
</span></code></pre>
The EventSource API automatically handles reconnection and parsing of the event stream, making it easy to work with SSE on the client side.</p>
MIME Support#</a></h2>
When implementing SSE in Phoenix, you might encounter a Phoenix.NotAcceptableError related to MIME types. This error occurs when Phoenix doesn’t recognize the text/event-stream MIME type. This is because Phoenix only accepts certain headers that are controlled by plug :accepts, [].</p>
The fix is straightforward. Add the following to your configuration:</p>
# In config/config.exs
</span>config :mime</span>, </span>:types</span>,</span> %{
</span>  </span>"text/event-stream" </span>=> </span>[</span>"sse"</span>]
</span>}
</span>
</span># In your router.ex
</span>plug :accepts</span>, </span>[</span>"html"</span>, </span>"sse"</span>]
</span></code></pre>
Full Source Code#</a></h2>

Copy the snippet and save into file.</li>
Run with elixir file_name.exs</code> or iex file_name.exs</code></li>
Copy of code available at Github Gist</a></li>
</ul>
#!/usr/bin/env elixir
</span>Mix</span>.</span>install(
</span>  [
</span>    {:phoenix_playground</span>, </span>"~> 0.1.5"</span>}</span>,
</span>    {:jason</span>, </span>"~> 1.3"</span>}
</span>  ]</span>,
</span>  config: [
</span>    mime: [
</span>      types: %{
</span>        </span>"text/event-stream" </span>=> </span>[</span>"sse"</span>]
</span>      }
</span>    ]
</span>  ]
</span>  # force: true
</span>)
</span>
</span>defmodule </span>SSEController </span>do
</span>  </span>use </span>Phoenix</span>.</span>Controller</span>, </span>formats: [:html</span>, </span>:sse]
</span>  </span>use </span>Phoenix</span>.</span>Component
</span>  plug(:put_layout</span>, </span>false</span>)
</span>  plug(:put_view</span>, </span>__MODULE__</span>)
</span>
</span>  </span>def </span>index</span>(conn</span>,</span> _params) </span>do
</span>    render(conn</span>, </span>:index)
</span>  </span>end
</span>
</span>  </span>def </span>index</span>(assigns) </span>do
</span>    </span>~H</span>"""
</span>    <div style="padding:16px;max-width:400px;margin:auto">
</span>    <p style="font-family:sans-serif"><b>Hello Sever-Side Events (SSE)</b></p>
</span>    <br/>
</span>
</span>    <div id="response" style="font-family:sans-serif;"></div>
</span>    </div>
</span>
</span>    <script>
</span>        const eventSource = new EventSource('/sse');
</span>        const responseDiv = document.getElementById('response');
</span>
</span>        eventSource.onmessage = function(event) {
</span>          console.log(event.data);
</span>          responseDiv.innerHTML = responseDiv.innerHTML + event.data;
</span>        };
</span>
</span>        eventSource.addEventListener('done', function(event) {
</span>            console.log('Stream complete');
</span>            eventSource.close();
</span>        });
</span>
</span>        eventSource.onerror = function(error) {
</span>            console.error('EventSource failed:', error);
</span>            eventSource.close();
</span>        };
</span>    </script>
</span>    """
</span>  </span>end
</span>
</span>  </span>def </span>sse</span>(conn</span>,</span> _params) </span>do
</span>    conn
</span>    </span>|></span> put_resp_content_type(</span>"text/event-stream"</span>)
</span>    </span>|></span> put_resp_header(</span>"cache-control"</span>, </span>"no-cache"</span>)
</span>    </span>|></span> send_chunked(</span>200</span>)
</span>    </span>|></span> send_events()
</span>  </span>end
</span>
</span>  </span>defp </span>send_events</span>(conn) </span>do
</span>    </span>Enum</span>.</span>reduce_while(mock_llm_response()</span>,</span> conn</span>, </span>fn</span> chunk</span>,</span> conn </span>->
</span>      </span>case </span>Plug</span>.</span>Conn</span>.</span>chunk(conn</span>,</span> chunk) </span>do
</span>        {:ok</span>,</span> conn} </span>->
</span>          # Mimicing for ChatGPT style response
</span>          </span>Process</span>.</span>sleep(</span>100</span>)
</span>          {:cont</span>,</span> conn}
</span>
</span>        {:error</span>, </span>:closed} </span>->
</span>          {:halt</span>,</span> conn}
</span>      </span>end
</span>    </span>end</span>)
</span>  </span>end
</span>
</span>  </span>defp </span>mock_llm_response </span>do
</span>    </span>~s</span>(</span>[{"model":"llama3.1","created_at":"2024-08-29T05:10:21.143675Z","response":"Here","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:21.198081Z","response":" is","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:21.252113Z","response":" a","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:21.306116Z","response":" two","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:21.360078Z","response":"-line","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:21.415174Z","response":" summary","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:21.468991Z","response":" about","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:21.523294Z","response":" the","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:21.577272Z","response":" planets","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:21.631504Z","response":":</span>\\</span>n</span>\\</span>n","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:21.686003Z","response":" Our","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:21.74176Z","response":" solar","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:21.797425Z","response":" system","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:21.85169Z","response":" consists","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:21.907339Z","response":" of","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:21.961274Z","response":" eight","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:22.016623Z","response":" planets","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:22.0705Z","response":",","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:22.124703Z","response":" each","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:22.178571Z","response":" with","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:22.232894Z","response":" its","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:22.286941Z","response":" own","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:22.341096Z","response":" unique","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:22.395072Z","response":" size","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:22.4492Z","response":",","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:22.503167Z","response":" composition","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:22.557346Z","response":",","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:22.611345Z","response":" and","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:22.6654Z","response":" features","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:22.720629Z","response":",","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:22.774724Z","response":" ranging","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:22.831603Z","response":" from","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:22.886015Z","response":" tiny","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:22.941614Z","response":" Mercury","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:22.99643Z","response":" to","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:23.050478Z","response":" massive","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:23.104922Z","response":" gas","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:23.159261Z","response":" giant","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:23.214676Z","response":" Jupiter","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:23.270369Z","response":".","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:23.32482Z","response":" The","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:23.379032Z","response":" planets","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:23.433923Z","response":" are","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:23.488128Z","response":" categorized","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:23.543358Z","response":" into","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:23.597931Z","response":" two","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:23.653839Z","response":" main","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:23.709756Z","response":" groups","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:23.764332Z","response":":","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:23.818894Z","response":" rocky","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:23.874536Z","response":" inner","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:23.93003Z","response":" planets","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:23.98419Z","response":" like","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:24.0399Z","response":" Earth","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:24.095414Z","response":" and","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:24.14959Z","response":" Mars","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:24.205239Z","response":",","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:24.259446Z","response":" and","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:24.313489Z","response":" g","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:24.367633Z","response":"ase","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:24.42172Z","response":"ous","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:24.476205Z","response":" outer","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:24.53165Z","response":" planets","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:24.585701Z","response":" like","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:24.639802Z","response":" Saturn","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:24.695259Z","response":" and","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:24.749622Z","response":" Uran","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:24.805156Z","response":"us","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:24.859499Z","response":".","done":false},
</span>    {"model":"llama3.1","created_at":"2024-08-29T05:10:24.913578Z","response":"","done":true,"done_reason":"stop"}]</span>)
</span>    </span>|> </span>Jason</span>.</span>decode!()
</span>    # Making it working well for EventSource; \n \n line structure
</span>    </span>|> </span>Enum</span>.</span>map(&</span>Map</span>.</span>get(</span>&</span>1</span>, </span>"response"</span>))
</span>    </span>|> </span>Enum</span>.</span>map(&</span>"data: #{</span>&</span>1}</span>\n\n</span>"</span>)
</span>  </span>end
</span>end
</span>
</span>defmodule </span>SSERouter </span>do
</span>  </span>use </span>Phoenix</span>.</span>Router
</span>  # import Phoenix.LiveView.Router
</span>
</span>  pipeline :browser </span>do
</span>    plug(:accepts</span>, </span>[</span>"html"</span>, </span>"sse"</span>])
</span>    plug(:fetch_session)
</span>    plug(:put_root_layout</span>, </span>html: {</span>PhoenixPlayground</span>.</span>Layout</span>, </span>:root})
</span>    plug(:put_secure_browser_headers)
</span>  </span>end
</span>
</span>  scope </span>"/" </span>do
</span>    pipe_through(:browser)
</span>
</span>    get(</span>"/"</span>, </span>SSEController</span>, </span>:index)
</span>    get(</span>"/sse"</span>, </span>SSEController</span>, </span>:sse)
</span>    # Just to get rid of errors
</span>    get(</span>"/favicon.ico"</span>, </span>SSEController</span>, </span>:index)
</span>  </span>end
</span>end
</span>
</span>PhoenixPlayground</span>.</span>start(plug: </span>SSERouter</span>)
</span></code></pre>


Retrieval-Augmented Generation (RAG) with Elixir
2024-07-30T00:00:00+00:00

This is my initial attempt at implementing RAG in Elixir. My goal is to develop a system similar to PrivateGPT by gaining a deeper understanding of the concepts and improving chunking and metadata techniques. For this project, I intentionally avoided using LangChain or OpenAI to explore the foundational aspects of RAG.</p>
</blockquote>

Checkout the code implementation here</a>. The code is at a very alpha and just shows a simple RAG. I plan to develop this code further and want to build something similar to PrivateGPT</a> in Elixir.</p>
</blockquote>
Retrieval-Augmented Generation (RAG) is a technique that enables Large Language Models (LLMs) to incorporate relevant and up-to-date information, allowing the LLM to address contexts it hasn’t been specifically trained on. RAG extends the powerful capabilities of LLMs into specific domains without the need for retraining, making it a cost-effective approach to enhancing LLM outputs, ensuring they remain relevant, accurate, and useful across various contexts.</p>

Image Source</a>
</span>
</p>
RAG is a multi step process;</p>

Document Ingestion</li>
Chunking</li>
Embedding</li>
Vector Database</li>
Retrival & Query Processing</li>
Generation & Output</li>
</ul>
Document Ingestion (Input)#</a></h2>
Document ingestion involves using a HTML document, a PDF, an image, or an audio file as input for an LLM model. For this project, I used the Reddit S1</code> filing as a knowledge base, providing prompts and questions based on it. For this initial attempt, I didn’t focus on tables and pictures within the S1 filing, as I aimed to develop a basic system capable of replying using the knowledge base.</p>
To read a PDF file, libraries such as pdftotext can be used. Here’s a simple command to read the file:</p>
# Not using stream for now
</span>{:ok</span>,</span> contents} </span>= </span>File</span>.</span>read(</span>"/priv/static/s1-file.md"</span>)
</span>
</span># OR 
</span>
</span>{:ok</span>,</span> response} </span>= </span>HTTPoison</span>.</span>get(</span>"https://gist.githubusercontent.com/theshapguy/d8633451460dac8a6cf6f0cf75a00f74/raw/a796d8af1452caa5d6857e67d40041a2ccaa3b14/RedditS1_RAG.txt"</span>)
</span>
</span>_contents </span>=</span> response</span>.</span>body
</span></code></pre>
Chunking#</a></h2>
Chunking converts a large corpus into manageable, byte-sized content, improving retrieval efficiency and relevance by enabling the system to fetch specific, pertinent sections rather than entire documents.</p>
By breaking larger texts into smaller chunks, we can selectively feed the most relevant pieces into the LLM, maximizing the use of available context and enabling the model to work with larger amounts of information than its default context window would allow. Ideally, each chunk should contain text about a specific topic, concept, or idea.</p>
  </span>def </span>chunk_document</span>(content </span>\\</span> html_input()) </span>do
</span>    </span>TextChunker</span>.</span>split(content)
</span>    </span>|> </span>Enum</span>.</span>map(& </span>&</span>1</span>.</span>text)
</span>  </span>end
</span></code></pre>
Findings#</a></h3>

Without chunking, the LLM model struggles to find the right information; larger context windows increase hallucinations.</li>
Smaller chunks capture more granular semantic information, while larger chunks retain more context.</li>
Summaries can be used instead of the whole document, speeding up retrieval and enhancing meaningful content retrieval.</li>
Chuking styles</a></li>
</ul>
Embedding & Vector Database#</a></h2>
Imagine you have a big box of different toys. Each toy is special and unique in its own way. Now, let’s say you want to organize these toys so you can easily find similar ones.
Embeddings are like giving each toy a special set of numbers that describe it. These numbers tell us things about the toy without us having to look at it directly.
For example:</p>

A toy car might get numbers like: [4, 2, 1]
(4 for “has wheels”, 2 for “made of metal”, 1 for “small size”)</li>
A stuffed animal might get: [0, 0, 3]
(0 for “no wheels”, 0 for “not metal”, 3 for “soft and cuddly”)</li>
</ul>
Now, when you want to find toys that are similar, you can just look at their numbers. Toys with similar numbers are probably alike in real life too!</p>
Embeddings turn words, sentences, or documents into a vector list of a certain dimension, allowing prompts (queries) to be compared quickly. These embeddings are stored in a vector database such as ChromaDB or PGVector for retrieval when a query is made.</p>
Findings#</a></h3>

I found that most people are using ChromaDB, however I preferred to use PGVector as it allowed me to iterate faster and I didn’t have to learn about another technology.</li>
Multiple models can be used for embedding; I used BAAI/bge-small-en-v1.5 for local testing. Local models can be as powerful as OpenAI’s embeddings.</li>
Make sure to embed the document and retrive with the same model and vector size.</li>
</ul>

</span>defmodule </span>Agents</span>.</span>Repo</span>.</span>Migrations</span>.</span>CreateSections </span>do
</span>  </span>use </span>Ecto</span>.</span>Migration
</span>
</span>  </span>def </span>change </span>do
</span>    execute </span>"CREATE EXTENSION IF NOT EXISTS vector"
</span>
</span>    create table(:sections) </span>do
</span>      add :embedding</span>, </span>:vector</span>, </span>size: </span>384
</span>      add :chunk</span>, </span>:text
</span>      add :metadata</span>, </span>:map
</span>
</span>      timestamps(type: :utc_datetime)
</span>    </span>end
</span>
</span>    create index(</span>"sections"</span>, </span>[</span>"embedding vector_cosine_ops"</span>]</span>, </span>using: :hnsw)
</span>  </span>end
</span>end
</span>
</span>schema </span>"sections" </span>do
</span>    field :chunk</span>, </span>:string
</span>    field :metadata</span>, </span>:map
</span>    field :embedding</span>, </span>Pgvector</span>.</span>Ecto</span>.</span>Vector
</span>
</span>    timestamps(type: :utc_datetime)
</span>end
</span>
</span>def </span>embed_chunks</span>(chunk) </span>do
</span>    %{embedding: embedding} </span>=
</span>      </span>Nx</span>.</span>Serving</span>.</span>batched_run(</span>SentenceTransformer</span>,</span> chunk </span>|> </span>String</span>.</span>trim())
</span>
</span>    </span>Sections</span>.</span>create_section(
</span>      %{</span>"chunk" </span>=></span> chunk </span>|> </span>String</span>.</span>trim()</span>, </span>"embedding" </span>=></span> embedding}
</span>      )
</span>end
</span>
</span>
</span></code></pre>
Retrival & Query Processing#</a></h2>
When querying, such as “What are the risk factors for Reddit?”, the first step is converting the text into a vector embedding. We use the same embedding model and vector size for both the query and document chunks for accurate similarity comparisons.</p>
Vector Search Process#</a></h3>
Once we have the query embedding, we perform a vector search to find similar chunks of data. This search is based on the principle that semantically similar texts will have similar vector representations.
We typically use cosine similarity to measure how close two vectors are. Cosine similarity values range from -1 to 1, with 1 indicating perfect similarity. For our Reddit risk factors query, we might find chunks discussing various business risks, user engagement challenges, or regulatory concerns.
Vector search is incredibly efficient compared to traditional text search, allowing us to quickly sift through millions of chunks to find the most relevant ones.</p>

In PostgresSQL using Ecto/Elixir there is already a query function for this.</p>
</blockquote>
Reranking with Cross-Encoders#</a></h3>
After the initial vector search, we employ a reranking step using a cross-encoder. In our case, we use the cross-encoder/ms-marco-MiniLM-L-6-v2</code> model. Unlike the initial embedding model, which encodes the query and documents separately, the cross-encoder considers the query and each potential chunk together.
The cross-encoder generates a single, unified representation of the paired texts by considering the interactions between them at each layer of the transformer. This allows for a more nuanced understanding of relevance, often leading to improved ranking.
While cross-encoders provide better accuracy, they are computationally more expensive. That’s why we use them for reranking a smaller set of initially retrieved chunks rather than for the initial search.</p>
    
</span># In postgressql we can do a vector search using max_inner_product rather than cosine similarity
</span># under the hood (same thing)
</span>
</span>  </span>def </span>search_document_embedding</span>(embedding) </span>do
</span>    from(s </span>in __MODULE__</span>,
</span>      select: {s</span>.</span>id</span>,</span> s</span>.</span>chunk}</span>,
</span>      
</span>      order_by: max_inner_product(s</span>.</span>embedding</span>, </span>^</span>embedding)</span>,
</span>      limit: </span>20
</span>    )
</span>    </span>|> </span>Repo</span>.</span>all()
</span>  </span>end
</span>
</span></code></pre>
Generation & Output#</a></h2>
Once we have all the relevant context from the vector database, we can create a prompt within a  prompt window. We collect all the relevent context and create a prompt as such below.</p>
    prompt </span>= </span>"""
</span>    [INST] <<SYS>>
</span>    You are an assistant for question-answering tasks. Use the following pieces of retrieved context to answer the question.
</span>    If you do not know the answer, just say that you don't know. Use two sentences maximum and keep the answer concise.
</span>    <</SYS>>
</span>    Question: #{</span>question}
</span>    Context: #{</span>context}</span>[/INST]
</span>    """
</span>
</span>    client </span>= </span>Ollama</span>.</span>init()
</span>
</span>    </span>Ollama</span>.</span>completion(client</span>,
</span>      model: </span>"llama3.1"</span>,
</span>      prompt: prompt
</span>    )
</span></code></pre>
Conclusion#</a></h2>
In conclusion, Retrieval-Augmented Generation (RAG) with Elixir is a powerful technique that enhances the capabilities of Large Language Models (LLM) by incorporating relevant and up-to-date information. By leveraging document ingestion, chunking, embedding, vector database, retrieval, query processing, and generation, RAG enables LLMs to provide contextually accurate and useful responses without the need for retraining.</p>
Overall, I found understanding RAG systems to be very easy. However, managing the pipelines and moving this code into production will take further readings. Firstly, I’ll looking into metadata filtering because that allows us to find correct chunks further. Then, I’ll data ingestion as this is the step that allows us to represent the data better. i.e use data from tables, use data from pictures hence this is the most cruicial state in the RAG pipeline.</p>
While building this “PrivateGPT”, I’ll use using Task.async, Genservers so that all processing can take place in the background. With Elixir excelling at background and concurrect tasks it is the best fit for this job.</p>
Comments</a></p>


Cloudflare Pages Build Bash Script for Zola
2024-02-04T00:00:00+00:00
Rather than using the predefied build commands of Cloudflare Pages, it is extremley handly to create a build script and call the script with bash build.sh</code> from the build command. It gives you control over how pages are build in different branches.</p>
$CF_PAGES_BRANCH</code> & $CF_PAGES_URL</code> are enviornment variables provided by Cloudflare at build time.</p>
#!/bin/bash
</span>echo </span>"Building Site Now"
</span>if </span>[ </span>"</span>$</span>CF_PAGES_BRANCH</span>" </span>== </span>"main" </span>]</span>; then
</span>  </span># Run the "production" build
</span>  </span>zola</span> build --force
</span>else
</span>  </span># Run the build  with drafts
</span>  </span>zola</span> build --drafts --force --base-url </span>$</span>CF_PAGES_URL
</span>fi
</span></code></pre>
Sources#</a></h4>

https://developers.cloudflare.com/pages/how-to/build-commands-branches/</a></li>
</ol>


Pretty Print JSON Reponse in Bash
2024-02-04T00:00:00+00:00
Pipe output 
 </span> </span> </span></code></pre> { </span> </span>        { </span> </span> </span> </span> </span> </span> </span> </span>            }, </span> </span> </span> </span> </span> </span>                    } </span>                } </span>            } </span>        } </span> </span> </span>        { </span> </span> </span> </span> </span> </span>            } </span>        } </span> </span>} </span></code></pre> 
  Understanding 2024-02-01T00:00:00+00:00

into python -m json.tool</code></p> style="background-color:#2e3440;color:#d8dee9;" class="language-bash ">curl</span> --request GET </span>\ --url http://shapath.com.np/posts/til_format_json_response_in_bash.json </span>\ --header </span>'Content-Type: application/json' </span>\ </span>| </span>python</span> -m json.tool style="background-color:#2e3440;color:#d8dee9;" class="language-bash ">## Pretty Printed Response </span>"data"</span>:</span> [ </span>"type"</span>: </span>"resposne"</span>, </span>"id"</span>: </span>"1"</span>, </span>"attributes"</span>: </span>{ </span>"title"</span>: </span>"Pretty Printed"</span>, </span>"body"</span>: </span>"The shortest article. Ever."</span>, </span>"created"</span>: </span>"2024-02-04T14:56:29.000Z"</span>, </span>"updated"</span>: </span>"2024-02-04T14:56:28.000Z" </span>"relationships"</span>: </span>{ </span>"author"</span>: { </span>"data"</span>: { </span>"id"</span>: </span>"42"</span>, </span>"type"</span>: </span>"links" </span>], </span>"included"</span>:</span> [ </span>"type"</span>: </span>"links"</span>, </span>"id"</span>: </span>"42"</span>, </span>"attributes"</span>: </span>{ </span>"link"</span>: </span>"http://example.com"</span>, </span>"domain"</span>: </span>"example.com" </span>] Network Subnetting: IPv4

Subnetting is the process of diving networks into smaller segments. A IPv4 address is a 32 bit number divided into 8 bit numbers.</p>
            10.10.10.10               ← (deminal)
</span>                ↓
</span>    10.       10.     10.      10     ← (decimal spaced)
</span>                ↓
</span>  00001010 00001010 00001010 00001010 ← (binary)
</span></code></pre>
Examples#</a></h4>


A subnet of 255.255.255.255 or 10.10.10.0/32 can have 1 address.</p>

11111111 11111111 11111111 11111111</li>
</ul>
</li>

A subnet of 255.255.255.252 or 10.10.10.0/30 can have 2 addresses.</p>

11111111 11111111 11111111 11111110</ins></li>
</ul>
</li>

A subnet of 255.255.255.0 or 10.10.0.0/24 can have 256 addresses.</p>

11111111 11111111 11111111 00000000</ins></li>
</ul>
</li>

A subnet of 255.255.254.0 or 10.10.0.0/23 can have 512 addresses.</p>

11111111 11111111 11111110</ins> 00000000</ins></li>
</ul>
</li>
</ol>
The difference between 3</strong> & 4</strong> is that the third part of the IPv4 can be 0 or 1, i.e 10.10.0</ins>.[1-255]</em> or 10.10.1</ins>.[1-255]</em></p>
Sources#</a></h4>

https://www.ripe.net/about-us/press-centre/IPv4CIDRChart_2015.pdf</a></li>
https://www.aelius.com/njh/subnet_sheet.html</a></li>
http://jodies.de/ipcalc?host=10.10.10.1&mask1=21</a> - IP/Subnet Calculator</li>
https://www.calculator.net/ip-subnet-calculator.html</a> - IP/Subnet Calculator</li>
</ol>


x86 Build in M1 Mac
2024-01-31T00:00:00+00:00
Building docker images with the flag --platform linux/amd64</code> allows you to create x86 images using docker</p>
Which platform am I on?</p>
> gcc -dumpmachine
</span>arm64-apple-darwin23.2.0
</span></code></pre>
Let’s run an image to enter the x86 world#</a></h4>
></span> docker </span>run</span> -it --platform</span>=</span>linux/amd64 gcc:13.2.0 /bin/bash
</span>(</span>inside</span> docker container)</span>></span> gcc -dumpmachine
</span>x86_64-linux-gnu
</span></code></pre>
When to use this?#</a></h4>
This is helpful to build cross platform images. i.e. in Elixir you can create a binary file with mix release</code> however it only targets the current platform target triple. As my server runs on linux/amd64</code> I would have to build the code again rather than just copying over the binary file. Hence, I use this script to build the binary for the x86 platform and copy over the binary file only.</p>


SSH/Telnet into Nokia G-2425G-A
2024-01-26T00:00:00+00:00
Device Infromation:
</span>
</span>Device Name G-2425G-A
</span>Vendor Nokia
</span>Boot Version U-Boot Dec-31-2016--12:00:00
</span>Router IP https://192.168.1.254
</span>Chipset MTK7528
</span></code></pre>
Default login for SSH, Telnet CLI, and Web GUI AdminGPON / ALC#FGU. However this can be changed by ISP by using TR069</a> after connecting the fiber cable.</p>
There is also another user userAdmin / userAdmin.</p>
Steps#</a></h3>

Reset the router so that it is possible to use the AdminGPON user. Another way is to extract the configuration after ISP has setup the modem router using TR-069. (contact me for further info – see secure notes on phone)</li>
Extract the cfg file using nokia-router-cfg-tool.py</a></li>
Enable TelnetSSHAccount. in the extracted XML file using the script above. Set username as ONTUSER</code> and password as OYdLWUVDdKQTPaCIeTqniA==</code> which equates to
admin</code>. If using another username, root access might not be possible.</li>
</ol>
<TelnetSshAccount. </span>n</span>=</span>"TelnetSshAccount" </span>t</span>=</span>"staticObject"</span>>
</span><Enable </span>rw</span>=</span>"RW" </span>t</span>=</span>"boolean" </span>v</span>=</span>"true"</span>></Enable>
</span><UserName </span>ml</span>=</span>"64" </span>rw</span>=</span>"RW" </span>t</span>=</span>"string" </span>v</span>=</span>"ONTUSER"</span>></UserName>
</span><Password </span>ml</span>=</span>"64" </span>rw</span>=</span>"RW" </span>t</span>=</span>"string" </span>v</span>=</span>"2NtCuV9+tykYlr4EmoJFxg==" </span>ealgo</span>=</span>"ab"</span>></Password>
</span></TelnetSshAccount.>
</span></code></pre>

Set LimitAccount_ONTUSER to false</code>. Further, ONTLOCK</code> (search the XML file) might also be needed to be set to false</code></li>
</ol>
<LimitAccount_ONTUSER </span>rw</span>=</span>"RW" </span>t</span>=</span>"boolean" </span>v</span>=</span>"false"</span>></LimitAccount_ONTUSER>
</span><X_ASB_COM_ONTLOCK </span>t</span>=</span>"boolean" </span>v</span>=</span>"false" </span>dv</span>=</span>"false" </span>rw</span>=</span>"RW"</span>></X_ASB_COM_ONTLOCK>
</span></code></pre>

Repack the xml file using nokia-router-cfg-tool.py</a></li>
Upload the new cfg file into the router. You might want to use a LAN connection for this, but it has been working fine over WLAN for me.</li>
</ol>
Notes#</a></h4>

After logging to the router portal, greyed-out (disabled) settings can be changed using the inspect element and removing the disabled prop from html.
</li>
</ul>
Sources#</a></h4>

https://0x41.cf/reversing/2019/10/08/unlocking-nokia-g240wa.html</a></li>
https://blog.fractal-reality.tech/2020/12/26/rooting-airtel-router/</a></li>
https://gist.github.com/thedroidgeek/80c379aa43b71015d71da130f85a435a</a> (See comments as well)</li>
https://broadbandforum.co/threads/nokia-g-140w-f-bridge-mode.199535/post-1533663</a></li>
https://github.com/codeanit/til/issues/61</a></li>
nokia-router-cfg-tool.py</a></li>
</ol>


Reversing A List
2024-01-24T00:00:00+00:00
To efficiently work with and transform</em> lists in Elixir, you will likely
need utilize a list reversing function from time to time. Your best bet is
to reach for the Erlang implementation which is available as part of the
lists</code> module.</p>
Here are a couple examples of how to use it:</p>
> </span>:lists</span>.</span>reverse([</span>1</span>,</span>2</span>,</span>3</span>])
</span>[</span>3</span>, </span>2</span>, </span>1</span>]
</span>> </span>:lists</span>.</span>reverse([</span>1</span>, </span>:a</span>, </span>true</span>, </span>"what"</span>, </span>5</span>])
</span>[</span>5</span>, </span>"what"</span>, </span>true</span>, </span>:a</span>, </span>1</span>]
</span></code></pre>
Note: though I said “transform</em> lists” above, what is actually going on is
that a new version of the list representing my transformation is being
created, per Elixir’s functional nature.</p>
Sources#</a></h4>

https://github.com/jbranchaud/til/blob/c7bea5aa7818767aef1915e3abe887f661df45cd/elixir/reversing-a-list.md</a></li>
</ul>


Kill Database Sessions
2024-01-21T00:00:00+00:00
The following snippet kills all connected database sessions except the current connected connection.</p>
SELECT
</span>  pg_terminate_backend(pid)
</span>FROM
</span>  pg_stat_activity
</span>WHERE
</span>  pid </span><></span> pg_backend_pid()
</span>  </span>AND</span> datname </span>= </span>'database_name'</span>;
</span></code></pre>


Get Git Details From Elixir
2024-01-20T00:00:00+00:00
The following snippet allows you to extract the SHA1 of the git commit from within elixir. It is useful to attach the SHA1 to your release or code so that if therea are any issues you can quickly checkout the commit and look into it.</p>
You can also get the branch name if required.</p>
  </span>def </span>git_commit_sha</span>() </span>do
</span>    </span>System</span>.</span>cmd(</span>"git"</span>, </span>[</span>"rev-parse"</span>, </span>"--short"</span>, </span>"HEAD"</span>])
</span>    </span>|></span> elem(</span>0</span>)
</span>    </span>|> </span>String</span>.</span>trim()
</span>  </span>end
</span>
</span>  </span>def </span>git_branch_name</span>() </span>do
</span>    </span>System</span>.</span>cmd(</span>"git"</span>, </span>[</span>"rev-parse"</span>, </span>"--abbrev-ref"</span>, </span>"HEAD"</span>])
</span>    </span>|></span> elem(</span>0</span>)
</span>    </span>|> </span>String</span>.</span>trim()
</span>  </span>end
</span></code></pre>


Find PostgreSQL Data Directory
2024-01-19T00:00:00+00:00
The following snippet finds where the PostgreSQL database directory is located.</p>
psql</span> -U postgres -c </span>'SHOW data_directory'</span>;
</span></code></pre>


Find PostgreSQL Config Location
2024-01-18T00:00:00+00:00
The following snippet finds where the PostgreSQL config file is located.</p>
psql</span> -U postgres -c </span>'SHOW config_file'</span>;
</span></code></pre>


Github+1 Workflow
2024-01-11T00:00:00+00:00

NOTE: A comprehensive</em> read</strong></p>
This post is a part of a document created for my team at Weber State Univeristy to gain an indepth understanding of Git — its abundant usefulness in a team setup.</p>
</blockquote>
Teams use several types git models. Git-Flow being one of the most polular team workflows around. However, since the rise of continious integration (CI). Github Flow has slowly started to gain its prominence. Github Flow is a lightweight branched based workflow for Git. Github Flow only contains one main branch master</code> and feature branches are created from it. However, this model uses two major branches master</code> and develop</code>. Hence, the feature branches are created from develop</code> branch. And the master is a stable state of the program. All changes and experiments should be made on feature</code> branches so that code is reviewed by other people in the team before it is merged into develop</code>.  Your feature branches should be verbosely descriptive so that other people in the team can clearly see what is being worked on.</p>
Working with Branches#</a></h2>
A new branch is created from the develop branch git checkout -b feature/{descriptive-name}</code> to make newer changes to the code.</p>
If you are working on a feature</code>, the branch should have the name feature/{descriptive-name}</code>.</p>
If you are working on a issue</code>. the branch should have the name issue/{descriptive-name}</code>.</p>
If you are working on a fix</code>. the branch should have the name fix/{descriptive-name}</code>.</p>
Commits#</a></h2>
Commits should be made after logical changes, additionally, make sure that logical units of code.</p>
git add -A</code> or git add -A hello.py</code></p>
followed by</p>
git commit -m "Added hello.py"</code> or git commit</code> and an interactive terminal will allow you to write your commit message.</p>
These commits messages are useful because it allows the modification of code to be tracked. Furthermore, each commit is a seperate unit of change. Hence, if a bug is found, an easy rollback is possible.</p>

By writing clear commits messages, you can make it easier for other people to follow the changes
in your code and provide better feedback.</p>
</blockquote>
The Art of the Commit Message#</a></h4>
We use a strict style for all of our commit messages. The style we use helps
ensure that our commits stay small and are easy to browse.</p>
The Layout</strong></p>
<type>: <subject>
</span>
</span><body>
</span>
</span><footer>
</span></code></pre>
The Title (the first line)</strong></p>
The title consists of the <type></code> and the <subject></code>.</p>
Allowed Values for <type></code></strong></p>

feat</strong> (new feature)</li>
fix</strong> (bug fix)</li>
docs</strong> (changes to documentation)</li>
style</strong> (formatting, missing semi colons, etc; no code change)</li>
refactor</strong> (refactoring production code)</li>
test</strong> (adding missing tests, refactoring tests; no production code change)</li>
chore</strong> (updating grunt tasks etc; no production code change)</li>
</ul>
Subject</strong></p>
An imperative tone</a> is also helpful in conveying what a commit does,
rather than what it did. For example, use change</strong>, not changed</em> or
changes</em>.</p>
The Body</strong></p>
The body of the commit message should use a style similar to the one proposed
in this article by tpope</a>. The body, just like the subject, should use
an imperative tone.</p>
The Footer</strong></p>
Here you can reference issues and pull-requests that relate to your commit, like so:</p>
closes #125 or closes #123, #245, #992
</span></code></pre>
Breaking Change</strong>
All breaking changes have to be mentioned in footer with the description of the change, justification and migration notes.</p>
BREAKING</span> CHANGE:
</span>
</span>`</span>port-runner</span>` command line option has changed to `</span>runner-port</span>`, so that it is
</span>consistent</span> with the configuration file syntax.
</span>
</span>To</span> migrate your project, change all the commands, where you use `</span>--port-runner</span>`
</span>to </span>`</span>--runner-port</span>`.
</span></code></pre>
You can see the official Github doc</a> for all the keywords to close issues and pull-requests.</p>
Never forget this standard! Set your commit message template</a> to this example, by running:</p>
git config --global commit.template "path/to/.gitmessage"
</span>
</span># Drop the `--global` flag to only use this template for one (this) repository.
</span></code></pre>

Protip: Do a rebase</code> and an interactive commit</code> (simply, git commit</code>) when you are ready to open a pull request. While working, locally, you do not need to follow this standard.</p>
</blockquote>
Read more about writing better commit messages here</a></p>
This section completely</strong> inspired by Angular</a>, Karma’s</a> and Sparkbox</a> commit style.</em></p>
Pull Requests#</a></h3>
Pull requests let you tell others about changes you’ve pushed to a repository on GitHub. Once a pull request is opened, you can discuss and review the potential changes with collaborators and add follow-up commits before the changes are merged into the repository.</p>
After you have created your feature branch, and made commits to it. It is now time to create a pull request on Github. The develop</code> branch currently and the develop branch you checkouted out your current working branch may (probably will) be different because other people in the team may have made changes or sent pull request to the project.  Hence, make sure the current branch you are working on is always upto date with the develop</code>.</p>
git checkout develop && git pull && git checkout - && git rebase develop</code></p>
or simply</p>
git pull --rebase origin develop</code></p>

Again, make sure you title the Pull Requests title verbosely so that team members
can clear understand what is being worked on.</p>
</blockquote>
Git is really flexible about merging conflicts, however, you’ll probably see some merge errors when you are working in the same area (lines) as the develop branch, which is evolving constantly. The error message will verbosely state the merge conflicts. Henceforth, you should merge these changes into your current working branch. Do this often so that, there isn’t a large numeber of merge errors at once.</p>
When there is a merge conflict, git rebase --continue</code> will allow you to integrate newer changes from the develop branch into your current working branch. After these changes are made you will need to add these changes into git with git add file.name</code>. The commit is handled by the rebasing process therefore git commit</code> is not required.</p>
Consider reading, How to Write the Perfect Pull Request</a></p>
Accepting Pull Requests#</a></h4>
Each pull request should only have one commit, if you have multiple commits, espcially if they are meaning less, i.e. missed an comma or added file. These commits do not provide any additional value to the code therefore rebase these meaningless commits into one commit using rebase. Squash these commits.</p>
Make sure you are on your current working branch.</p>
git log</code> Will help you see the commits you have made.
git rebase -i HEAD~4</code> Selects the last four commits you made. This snippet only starts the process of rebasing. You do not have to squash all your commits. These can be picked on the followup screen.</p>
The available rebase options are;</p>

</span># p, pick = use commit
</span># r, reword = use commit, but edit the commit message
</span># e, edit = use commit, but stop for amending
</span># s, squash = use commit, but meld into previous commit
</span># f, fixup = like "squash", but discard this commit's log message
</span># x, exec = run command (the rest of the line) using shell
</span># d, drop = remove commit
</span>
</span></code></pre>
The following snippet shows commit 6340aaa</code> ebfd367</code> 30e0ccb</code> is being squashed into 01d1124</code> commit.</p>
pick 01d1124 Adding functional print module
</span>squash 6340aaa Missed a simple function
</span>squash ebfd367 Jekyll has become self-aware.
</span>squash 30e0ccb Changed the line from a to b.
</span></code></pre>
After you have squashed multiple commits into one, because of change in git history.A force push, git push -f</code> is required to send these changes to upstream (remote). Since you are working on your own branch, this is allowed.</p>
The reviewer or the team lead will assign a team member to merge these changes into the develop branch. This is usually going to be the same person who sent the pull request.</p>

You can only squash newer commits to an older one. However, you can ammend the old commit message by putting a reword</code> instead of pick</code> while rebasing. Also, if you are squshing commits using id’s, choose the following commit id of the commit you want to rebase.</p>
</blockquote>
[WIP] Pull Requests#</a></h5>
You are welcome to open pull requests even though you have not completed a feature or a issue so that team members can review your code from the very begining. No other team member will “touch” your branch</code> unless you explicitly ask to do so. Make sure you label this clearly with a [WIP] tag in the beginning of the name so that team members can easily filter these pull requests unless you explitcly ask for help.</p>

Be careful while force pushing into shared branches. As this changes the history, make sure the collabrates know of this by commeting on the pull requests. A better way is to not rebase till the feature is fully ready to merge. The latter is preferred.</p>
</blockquote>
Merging Current Branch into Develop#</a></h3>
A team should usually only have ONE or very few number of people merging the pull requests.
</span></code></pre>
After the pull request has been approved, you can merge these changes directly from Github or if there are merge conflicts, locally on your computer.</p>
Naming convention for merge commit: Merge: feature/{branch} via Pull Request #{number}
Example, Merge: feature/database via Pull Request #1</p>
Make sure that the pull request number is added on to the merge commit so that other team members can easily reference the changes and the comments for this merge.</p>
On Github, make sure that you merge your changes with create a merge commit</code> so that the history of your branch will be moved over to the develop branch.</p>
On your local computer, you will follow these steps,</p>
Step 1</strong>: From your project repository, bring in the changes and test.</p>
git fetch origin
</span>
</span># do this step if you are assigned another branch that you have not made changes to
</span># otherwise this step should already be done when you pushed your branch upstream
</span>
</span>git checkout -b feature/{branch} origin/feature/{branch}
</span>git merge develop
</span></code></pre>
Step 2</strong>: Merge the changes and update on GitHub.</p>
git checkout develop
</span>git merge --no-ff feature/{branch}
</span>git push origin develop
</span></code></pre>
Note: The --no-ff</code> is important so that the history of your branch will be moved over to the develop branch.</p>

If your branch name is not meaningful, the Team Lead will ask you to rename your branch, as you do this, you will need to create a new pull request. Rename branch using git branch -m feature/{new-name}</code></p>
</blockquote>
Stashing Commits#</a></h2>
Often, when working on a project, you would want to switch branches when you want to work on something else for a bit or there is a issue you need to fix urgently. And you do no want to commit half done work because someone else is reviewing your code. The answer to this issue is git stash</code>. Stash takes the current state of your working directory (the changes you made) and saves in a stack.</p>
git stash
</span>
</span>git stash list
</span>  stash@{0}: WIP on feature/changes: 043d356 added the controller
</span></code></pre>
With this, you can switch branches and work on something different. After a while, when you come back to finish the feature with do git stash apply</code> to reapply the changes you made to the working directory.</p>

If you have made multiple items on your stash, do git stash list to see which one you want to reapply.
Then, reapply a particular stash using git stash apply stash@{0}</code>
Otherwise, since the stash is stored in a stack it pop outs the last inserted item.</p>
</blockquote>
Reverting Commits#</a></h2>
This usage of git reset is a simple way to undo changes that haven’t been shared with anyone else. It’s your go-to command when you’ve started working on a feature and find yourself thinking, “Oh crap, what am I doing? I should just start over.” - via Atlassian</a></p>
You can reset your commits using the --hard</code> or the --mixed flag</code>. The latter is default.</p>
git reset --hard SHA_ID or HEAD~1
</span>git reset --mixed SHA_ID or HEAD~1
</span>git reset HEAD~1 # defaults to git reset --mixed
</span></code></pre>
The --hard</code> takes the commits and modifies your directory</strong> so that your code matches the commit exactly. All changes will be removed.</p>
The --mixed</code> flag takes the commits and unstages changes after this commit. You will still have the changes in your working directory</strong>.</p>
Usually, use the latter, and you can stash your changes so that you still have access to the changes if you need them later. If you want to start over and want a clean directory use --hard</code> reset.</p>
Tagging Commits#</a></h2>
Git tags are used to indentify stable release. The use of schematic versioning for tags allows for version numbers and the way they change convey.</p>
Given a version number MAJOR.MINOR.PATCH, increment the:
</span>
</span>MAJOR version when you make incompatible API changes,
</span>MINOR version when you add functionality in a backwards-compatible manner, and
</span>PATCH version when you make backwards-compatible bug fixes.
</span>Additional labels for pre-release and build metadata are available as extensions to the MAJOR.MINOR.PATCH format.
</span>
</span></code></pre>
Schematic Versioning</a></p>
A simple git tag [version]</code> will tag the commit you are currently on.
To remove the tag, git tag -d [version]</code> will remove the tag.</p>
You can also annotate and attach a message a tag so that it is descriptive.</p>
git tag -a -m "Release Tag Message 1.0" v1.0</code></p>
Don’t forget you need to push your tags seperately with git push --tags</code></p>

The Team Lead is responsible for chronially tagging commits using Schematic Versioning. A team member seldom tags a commit.</p>
</blockquote>
Blaming Others#</a></h2>
Git blame searches the commit history and allows you to see who is the last person who modified the particular line of code.</p>
You can do this simply with git blame file.name</code>
Additionally, you can search specific line numbers with git blame file.name -L 32,45</code></p>
If you want to go back and see how and who has changed the file use the following snippet.</p>
git log -p -M --follow --stat -- file.name
</span></code></pre>
If there are problems in the code, do a git blame</code>, and create a issue on Github and mention the team member in the issue so that the person can get back to you before making changes.</p>
A few Git tips and tricks#</a></h2>


Use aliases for git, this various git commands in a few keystrokes.</p>
</li>

Also consider using a bash prompt (PS1) that allows you to see which branch you are working on.</p>
</li>

I know using Github GUI is easy however, it only harnesses a mere potential of Git. Therefore start loving using git via command-line and leave the GUI behind.</p>
</li>

Make sure to set your name in git so that when you push, we exactly know who the team member is</p>
git config --global user.name "Shap Guy"
</span>git config --global user.email "email@domain.com"
</span></code></pre>
Drop the --global</code> flag if you only want to change your email for this specific repository. Make sure you use your Weber email so that your personal email is not attached to commits.</p>
</li>

Make sure you change the default commit message template so that it follows the project standards.</p>
</li>

git push -f</code> is only allowed</strong> on branches you</em> are working on. Changing the history, in any way, of the repo will be frowned upon.</p>
</li>

It is better to use git add -A</code> rather than git add .</code> because the first one automatically tracks file deletions in the working directory.</p>
</li>
</ol>

Git’s policy is commit often, rebase later, push once.</p>
</blockquote>
Additional Resources#</a></h2>
Become a Git Guru</a></p>
Most commonly used Git Tips and Tricks</a></p>
Git Workflow Tips</a></p>
GitLab Tips and Tricks</a></p>


Get Your Public IP Address
2024-01-04T00:00:00+00:00
If you’re trying to figure out what your current public IP address is, there is
a server you can ask. It is a server running at https://ifconfig.me</code>.</p>
You can visit that URL in your browser to find your IP address and some other
User Agent/Request details. The site also mentions several cURL</code> commands you
can run to get these details in your terminal.</p>
$</span> curl -4 https://api64.ipify.org
</span></code></pre>
$</span> curl -6 https://api64.ipify.org
</span></code></pre>
To get further information go to ifconfig.me/ip</code>.</p>
See ifconfig.me</a> for more details.
See https://www.ipify.org</a> for more details.
See https://wtfismyip.com</a> to get IPv4 & IPv6 IP on the same page.</p>
Sources#</a></h4>

https://www.mfitzp.com/article/use-ifconfigme-to-return-your-ip-and-host/</li>
https://github.com/jbranchaud/til/blob/c7bea5aa7818767aef1915e3abe887f661df45cd/workflow/get-your-public-ip-address.md</li>
https://www.ipify.org</li>
</ol>


Automating Blog Hosting With Ansible
2023-12-12T00:00:00+00:00

This blog post is a hands down tutorial on provisioning</code> a server by hosting a blog using Git and nginx with Ansible.</p>
</blockquote>
Ansible is a configuration management system. Ansible by default uses the SSH protocol to manage machines. There are other configuration tools like Puppet and Chef, however these require you to install a small piece of software on the client server. Hence, my preference to Ansible.</p>
Installing Ansible#</a></h2>
We only need to install Ansible on the local computer. However make sure the server has Python 2.7</code> installed.</p>
If you have brew</a> installed on a Mac OS. You can simply do</p>
$ brew install ansible
</span></code></pre>
For Ubuntu,</p>
$ sudo apt-get install software-properties-common
</span>$ sudo apt-add-repository ppa:ansible/ansible
</span>$ sudo apt-get update
</span>$ sudo apt-get install ansible
</span></code></pre>
Please refer to Ansible Installation Docs</a> to install on more OS’s</p>
Ansible Basics#</a></h2>
There are two ways you can use Ansible depending on your use case. Firstly, use can use Ansible like bash</code> scripts. These will be lists of tasks</code> that you use to provision the server.</p>
Secondly, we can use Ansible to create roles</code>. Ansible uses roles to seperate it’s blocks of tasks. This allows you to copy blocks from one playbook to another without any hassle. A playbook</code> in essence is how your tasks and roles are executed. Addtionally, it can be uploaded into Ansible Galaxy</a> for other people to use it.</p>
An Ansible Role needs to have a specific directory structure. You can manually create this directory structure; an easier way is to use ansible-galaxy init newrole</code>.</p>
This command creates the follwing directory strcuture.</p>
.
</span>├── defaults
</span>│   └── main.yml
</span>├── files
</span>├── handlers
</span>│   └── main.yml
</span>├── meta
</span>│   └── main.yml
</span>├── tasks
</span>│   └── main.yml
</span>├── templates
</span>└── vars
</span>    └── main.yml
</span></code></pre>
Now lets explain each of these.</p>
files</strong>: This directory contains files that will be copied to the host.</p>
handlers</strong>: These are basically tasks which are can be notified to be run after tasks are completed.</p>
meta</strong>: This file cotains the meta information and dependency roles.</p>
templates</strong>: This directory contains templates that use variable subsitution and, then copy it in your host.</p>
tasks</strong>: It contains all of the tasks that the playbook needs to run.</p>
vars</strong>: These are variables that you can use in your roles.</p>
Prerequsites#</a></h2>


Make sure you have access to a remote or local Ubuntu Server. I use DigitalOcean</a> to cater for all my server needs since it is quick and easy to spin up machines.
Quick Bonus</strong>: if you sign up throught this link</a> you get $10 in  DigitalOcean</a> credit.</p>
</li>

Also make sure you have a static website or a webpage as a git repository.</p>
</li>
</ol>

All Ansible Playbooks are written in YAML.</p>
</blockquote>
Now lets get the ball rolling,</p>
Clone the static website from the git respository. But, make sure you change the repo url. Additionally, make sure you set approriate variables in the vars folder. The {{ user }}</code> variable has no default value so make sure you add one to the vars file.</p>
- name: Clone Blog From Github using HTTPS
</span>  git:
</span>    repo: https://github.com/theshapguy/bytes.git
</span>    dest: /home/{{ user }}/blog
</span>    version: master
</span>    update: yes
</span></code></pre>
We will use nginx as a webserver. You can also use Apache</a> as well, however the following configuration is for nginx.</p>
- name: Install nginx
</span>  apt:
</span>    package: nginx
</span>    state: latest
</span></code></pre>
Now, lets create a template</code> configuration for nginx virtual host.</p>
server {
</span>   listen 80;
</span>   listen [::]:80;
</span>
</span>   server_name {{ domain }}  www.{{ domain }};
</span>
</span>    root /home/{{ user }}/blog;
</span>    index index.html;
</span>
</span>   location / {
</span>       try_files $uri $uri/ =404;
</span>   }
</span>}
</span></code></pre>
All variables</code> are replaced using variables defined in the vars directory so make sure these are defined.</p>
Copy this template and configure the nginx symlink. Also make sure that you have removed the default symlink which can cause confliting issues between two nginx configuration.</p>
- name: Copy Nginx Config for Blog to Host
</span>  template:
</span>    src: blog.conf.http.j2
</span>    dest: /etc/nginx/sites-available/blog.nginx.conf
</span>
</span>- name: Add Symlink to Host
</span>  file:
</span>    src: /etc/nginx/sites-available/blog.nginx.conf
</span>    dest: /etc/nginx/sites-enabled/blog
</span>    state: link
</span>  notify: restart nginx
</span>
</span>- name: Remove default symlink
</span>  file:
</span>    path: /etc/nginx/sites-enabled/default
</span>    state: absent
</span></code></pre>
Now lets create a handler to restart nginx. If there are any changes to the file the notify</code> tag is executed and nginx is reloaded</code>.</p>
- name: reload nginx
</span>  service: name=nginx state=reloaded
</span>
</span>  # basically you are doing -> sudo service nginx [options]
</span></code></pre>
Now, your website should be running on your {{ domain }}</code> as listed on your vars directory.</p>


Getting Started with Android Animations
2023-07-03T00:00:00+00:00
Android Animations has come a long way from Froyo to Honeycomb and then to Marshmallow. This has included a lot of API changes in Android. The truth - there is no animation library that you can just include in your app and they start automagically working. Animations need to be coded. There is no way around it. Even though, animateLayoutChanges="true"</code> has some nice usages, it’s likely rare.</p>
When Material Design became the standard, Android went all out on colors and motion, moreover, delighting the user. Animations in Android have a complex vocabulary to learn, even though it has gotten easier over the years, it is still hefty. I might not even cover all the vocabulary in this post however it will give you a core idea of how to get started with animations on Android to delight your users. Android Docs are great! No doubt, however they are usually jargon to start out with.</p>
View Animations#</a></h2>
Animating a button#</a></h4>
Views are animated with the ViewPropertyAnimator. With the fluent API you can just do view.animate() to start animating your views.</p>
btnAnimate</span>.</span>animate</span>()</span>.</span>translationY</span>(</span>500</span>)</span>.</span>alpha</span>(</span>0</span>)</span>.</span>setDuration</span>(</span>1000</span>)
</span>                </span>.</span>setListener</span>(</span>new </span>AnimatorListenerAdapter</span>() {
</span>            </span>@Override
</span>            </span>public void </span>onAnimationCancel</span>(</span>Animator </span>animation) {
</span>                </span>super</span>.</span>onAnimationCancel</span>(animation)</span>;
</span>                btnAnimate</span>.</span>setVisibility</span>(</span>View</span>.</span>GONE)</span>;
</span>            }
</span>        })</span>;
</span>// They run in parallel, alpha and translationY
</span>
</span></code></pre>
Don’t override AnimatorListener, override AnimatorListenerAdapter. Try it!</p>
I have seen developers at Google recommend this method as to the following one as it makes animations fluent.</p>
ObjectAnimator#</a></h4>
The other method is to use the ObjectAnimator.</p>
ObjectAnimator fade = ObjectAnimator.ofFloat(btnAnimate, View.ALPHA, 0);
fade.start();
Interpolators</p>
Linear vs Curve#</a></h4>
Animations need to look real to your user. A decelerating/accelerating object always looks better than a object in linear motion.</p>
Interpolator is another class in the API which makes it easy to define the rate of change of animations. These allow view properties like alpha and translate to be accelerated and decelerated (it does a lot more).</p>
btnAnimate</span>.</span>animate</span>()
</span>        </span>.</span>setInterpolator</span>(</span>new </span>AccelerateDecelerateInterpolator</span>())
</span>        </span>.</span>setDuration</span>(</span>2500</span>)
</span>        </span>.</span>alpha</span>(</span>0</span>)</span>.</span>translationY</span>(</span>500</span>)</span>;
</span></code></pre>
The interpolator changes the alpha of the view by accelerating the fade in the beginning and decelerating completely disappears from the screen. The same with translationY.</p>
Sets of Animations#</a></h4>
Translate and Fade Off Screen</p>
Your might be thinking, I can just do this, however animations run asynchronously hence the following code will run in parallel.</p>

</span>// First Translate
</span>btnAnimate</span>.</span>animate</span>()</span>.</span>translationY</span>(</span>400</span>)</span>;
</span>// Then Fade Out
</span>btnAnimate</span>.</span>animate</span>()</span>.</span>alpha</span>(</span>0</span>)</span>;
</span>// They both should run sequentially
</span>
</span></code></pre>
In comes the AnimationSet. This allows animations to be played sequentially, in parallel and a lot more. Basically, AnimationSet is the choreographer of your animations.</p>
With AnimationSet you can no longer use the view.animate() but now are using the ObjectAnimator.</p>

</span>ObjectAnimator</span> fade </span>= </span>ObjectAnimator</span>.</span>ofFloat</span>(btnAnimate</span>, </span>View</span>.</span>ALPHA</span>, </span>0</span>)</span>;
</span>ObjectAnimator</span> translate </span>= </span>ObjectAnimator</span>.</span>ofFloat</span>(btnAnimate</span>, </span>View</span>.</span>TRANSLATION_Y</span>, </span>400</span>)</span>;
</span>AnimatorSet</span> set </span>= new </span>AnimatorSet</span>()</span>;
</span>set</span>.</span>playSequentially</span>(translate</span>,</span> fade)</span>;
</span>set</span>.</span>start</span>()</span>;
</span>// The button will translate and then fade out.
</span>// This example is just scratching the surface.
</span></code></pre>
In the end…</p>
With ViewPropertyAnimator, Interpolators and AnimatorSet you can choreograph many animations that delight the users with the use of motion. ViewPropertyAnimator has a lot of advantages of its predecessor ObjectAnimator, namely the fluent API. However ObjectAnimator still is the mother of all while choreographing complex animations. Also, don’t forget interpolators. Its these that make your animations delight the user.</p>
NOTE: This is a article I had on my old blog that I ported over to this version.
</span></code></pre>

Sources #</a></h4>

https://developers.cloudflare.com/pages/how-to/build-commands-branches/</a></li> </ol>

Sources#</a></h4>

https://github.com/jbranchaud/til/blob/c7bea5aa7818767aef1915e3abe887f661df45cd/elixir/reversing-a-list.md</a></li> </ul>

Additional Resources #</a></h2>
Become a Git Guru</a></p>
Most commonly used Git Tips and Tricks</a></p>
Git Workflow Tips</a></p>
GitLab Tips and Tricks</a></p>

`Sources#</a></h4> https://www.mfitzp.com/article/use-ifconfigme-to-return-your-ip-and-host/</li> https://github.com/jbranchaud/til/blob/c7bea5aa7818767aef1915e3abe887f661df45cd/workflow/get-your-public-ip-address.md</li> https://www.ipify.org</li> </ol>`

Shap Bytes - Shap Bytes

Mikrotik DDNS IPv6 via Cloudflare

Source #</a></h4>

https://github.com/dudanov/mikrotik-cloudflare-ddns-scripts/blob/master/cloudflare6ddns</a></li> </ul>

Self-Hosted Tailscale DERP Server

Server-Side Events (SSE) with Phoenix/Elixir

Retrieval-Augmented Generation (RAG) with Elixir

Cloudflare Pages Build Bash Script for Zola

Pretty Print JSON Reponse in Bash

x86 Build in M1 Mac

SSH/Telnet into Nokia G-2425G-A

Reversing A List

Kill Database Sessions

Get Git Details From Elixir

Find PostgreSQL Data Directory

Find PostgreSQL Config Location

Github+1 Workflow

Get Your Public IP Address

Automating Blog Hosting With Ansible

Getting Started with Android Animations

Shap Bytes - Shap Bytes

Mikrotik DDNS IPv6 via Cloudflare

Self-Hosted Tailscale DERP Server

Server-Side Events (SSE) with Phoenix/Elixir

Full Source Code#</a></h2> Copy the snippet and save into file.</li> Run with elixir file_name.exs</code> or iex file_name.exs</code></li>

Retrieval-Augmented Generation (RAG) with Elixir

Cloudflare Pages Build Bash Script for Zola

Pretty Print JSON Reponse in Bash

Examples#</a></h4> A subnet of 255.255.255.255 or 10.10.10.0/32 can have 1 address.</p>

x86 Build in M1 Mac

SSH/Telnet into Nokia G-2425G-A

Steps#</a></h3> Reset the router so that it is possible to use the AdminGPON user. Another way is to extract the configuration after ISP has setup the modem router using TR-069. (contact me for further info – see secure notes on phone)</li>

Reversing A List

Kill Database Sessions

Get Git Details From Elixir

Find PostgreSQL Data Directory

Find PostgreSQL Config Location

Github+1 Workflow

Get Your Public IP Address

Automating Blog Hosting With Ansible

Getting Started with Android Animations