Heath

@heathhenley.dev

331 Followers 1710 Following

Señor Application Engineer at a small sonar shop. Writing about things here: https://heathhenley.dev

Screenshot from math textbook, with inset quote from the opening paragraph of Alice’s Adventures in wonderland: “…what is the use of a book…without pictures or conversation”

An image made by places red / blue knights on a spiral grid. Each knight is placed in turn on the lowest spiral index available to it (not being attacked by the opposite color)

Screenshot of github - "this repository has no secrets"

Screenshot of a web browser showing an error response of: “Cannot GET /privacy” at the cnnespanol.cnn.com/privacy route

Keyboard heatmap indicating the number of times each key is used - red is more frequent, blue is less

``` python
def test_raise():
try:
raise ValueError
finally:
return 0

def test_return():
try:
return 1
finally:
return 0

print(test_raise()) # --> 0
print(test_return()) # --> 0
```

Python snippet

```python

class TailRecurseException(Exception):
def __init__(self, *args, **kwargs):
self.args = args
self.kwargs = kwargs

def tco(func):
def func_tail(*args, **kwargs):
while True:
try:
return func(*args, **kwargs)
except TailRecurseException as e:
args = e.args
kwargs = e.kwargs
return func_tail

@tco
def fib_tco(n, a=0, b=1):
if n == 0:
return a
raise TailRecurseException(n-1, a=b, b=a+b)

def fib_tail(n, a=0, b=1):
if n == 0:
return a
return fib_tail(n-1, b, a+b)

# no tco
fib_tail(1000) # --> ❌ RecursionError

# tco
fib_tco(1000) # --> ✅

# Heavily inspired by:
# - http://baruchel.github.io/python/2013/12/03/tail-recursion-in-python/
# - https://github.com/baruchel/tco

```

WPM before and after new keyboard layout

An AI generated pear wearing a hoody and sunglasses programming

$screenshot of the following in the python repl ```python import os os.path.join(r"c:\dev\test", r"\test_dir\test_file.xyz") # c:\\test_dir\test_file.xyz ```$

A screenshot of a snippit of python code in the style of ocaml

```python

# based on ocaml implementation:
# by: http://typeocaml.com/2015/05/05/permutation/
def insert_all_positions[T](x: T, lst: list[T]) -> list[list[T]]:
def inner(prev, results, orig_lst):
match orig_lst:
case []:
return [(prev + [x])] + results
case [first, *rest]:
return inner(prev + [first], [(prev + [x] + orig_lst)] + results, rest)
return inner([], [], lst)

def permutations_full_recursive[T](
lst: list[T], r: int | None = None) -> Generator[list[T]]:

r = len(lst) if r is None else r
if r == 0:
yield []
return
if not lst or r > len(lst):
return

match lst:
case [x] if r == 1:
yield [x]
case [first, *rest]:
# permutations of size r with first in them
yield from reduce(
lambda acc, p: acc + insert_all_positions(first, p),
permutations_full_recursive(rest, r - 1),
[]
)
# permutations of size without first in them
yield from permutations_full_recursive(rest, r)
```

The output of gcloud kms keys create --help - normal command line documentation of the arguments and options. Lord of the Rings characters are used as dummy key names in the usage examples.

Output of git log on a public git repo with more formatting applied so that you get similar output to the gui program gitk - one commit per line with author, msg, and time. Pipe and dash symbols show how commits are connected / how branches connect.

A bunch of strangers in the snow in Times Square in NYC

A github contribution graph - fewer contributions during the weekends in the summer and clear chunks of no contributions

Results from running the code in utop on the list 1, 2, 3 with the map function (fun l a -> (l, a + 1)) - it should return the ([1; 2; 3], 3) but it returns ([1; 2; 3], 0)

Ocaml code to map and fold a function over a list at the same time:

```ocaml
let map_and_fold ~f ~init lst =
let acc_ref = ref init in
let[@tail_mod_cons] rec go = function
| [] -> []
| hd :: tl ->
let b, new_acc = f hd !acc_ref in
acc_ref := new_acc;
b :: go tl
in
(go lst, !acc_ref)
```

$The displays the following python code snippet: ```python # https://docs.python.org/3/library/asyncio-task.html#coroutine import asyncio import time async def fetch_data(): print("start fetch_data") await asyncio.sleep(1) print("end fetch_data") async def my_task(): print("start my_task") await asyncio.sleep(2) print("end my_task") # if you have >= 3.11 - you can use a context manager async def main(): async with asyncio.TaskGroup() as tg: task1 = tg.create_task(fetch_data()) task2 = tg.create_task(my_task()) print(f"started at {time.strftime('%X')}") # The await is implicit when the context manager exits. print(f"finished at {time.strftime('%X')}") asyncio.run(main()) ```$