HexTxt

“Truth is the offspring of silence and meditation.” – Hermes Trismegistus, Hermetica

Greetings. I’m Eric, the writer, tinkerer, and resident mystic here at Hextxt.

I explore technology through tutorials, experiments, and problem-solving—from cybersecurity and automation to language learning and symbolic systems—and draw on experience teaching and coaching in math, flight instruction, and home schooling.

Hextxt is part portfolio, part lab notebook, part journal. If something here sparks your curiosity, get in touch. I offer coaching, collaboration, and consulting services.

Recent Articles

Dreary Digital Dread
05 Mar, 2025
Rantings of a former libertarian. A man without a political party and plenty of time on his hands.
What if the endgame of the AI eating the world isn’t utopia? Maybe, those at the nexus of power are looking forward to being the kings and queens of a new age. An age of digitally managed peasants. Where production is completely automated?
There are no jobs for anyone because no humans are needed to do them. Oh there might be a technician class. Someone has to keep things running.
Before we get there though there is work to do. First, dismantling the social systems of the pre-AI world is in order. Government programs of various kinds certainly need to go. Soon to be followed by shedding of the unnecessary workforce, both private and public.
If done under the guise of balancing budgets maybe nobody will notice what is really going on around here? That a few enterprising capitalists are at the ready to vacuum up all those dollar bills floating around?
Without employees to waste money on or self-entitled peasants caught in the now shredded safety nets there’s plenty. The rather exclusive billionaire soon-to-be trillionaire club will be doing very well for themselves indeed.
Of course, it can’t happen all at once. Takes time to roll out new tech. Work out the bugs and all. Soon enough though we can enjoy our digital overlords guiding hands in every aspect of our lives.
Assuming we don’t starve to death or die from a lack of a needed medical attention or treatment. What do we get to look forward to in this digital utopia?
A fate worse than death.
Boredom. Utterly dreary digital non-death.
Books, articles, blogs, all written in the common voice of the machine. For that matter television, and movies, too. With AI writing the scripts and generating the video and audio how could we not be enthralled?
Everything sounding the same. No creative spark. Death by digital boredom. Death by a thousand LLMs.
What I am really curious about is the following. What factor will balance out AI eating the world?
I mean we do have limits whether recognize them or not. What is that will keep the power between the those that wield AI, the peasants, and the rich and powerful in balance? Or re balance after going to far in any given direction?
Populist uprisings I suppose are bound to happen as they are happening now. But such movements are a social pendulum. Back and forth. Back and forth.
Something more long lasting?
I wonder about energy. How much energy will it take to run the machines that are being designed to run our lives?
Same with the various kinds of minerals. Do we run into limits in how many AI servers and chips we can manufacture? Or, rather, AI can manufacture?
When the peasants finally wake up in this field of mental and spiritual dreariness? Assuming they are worthy or food rations enough to stay alive. What then? Nothing stays in stasis forever. Action - reaction.

How to Deploy A Phoenix App in a Sub Directory
21 May, 2023
Did you know you can host multiple Elixir Phoenix web applications under the same domain without using Umbrella? While you can find people discussing hosting multiple web apps learning how though another story. At least for this beginner how to get things configured was not always obvious.
What started this adventure was a growing fascination with concurrency in programming languages. Which led to Elixir and Erlang’s concurrency capabilities catching my attention.
As I learn best when I have a project I decided to use Elixir’s Phoenix framework and LiveView to create a simple calculator. Then I thought how about a site (no longer live) with multiple web apps? The first of which would be the calculator project and who knows what else?
Side note: I used this tutorial for the HTML and CSS for the calculator.
If you are going to have multiple web apps the next question is how to host them. Subdomains? Directories? Plus, what about a blog to go with them? In my case I wanted to have a Hugo generated blog, too.So, I went with sub-directories for my Hugo static site and web apps and Caddy as the web server.
Setting up Caddy server was straight forward. The calculator is hosted at localhost using the Elixir server on a unique port.
Caddy does reverse proxy with the app in a directory under the site root. Not sure if the wildcard was necessary but I threw it in just in case. If I have time I will do some testing to see if a wildcard is needed here.
```
    handle {
        reverse_proxy /tenkey*  localhost:5000
    }
```
If you look online you can find plenty of information about the Caddy reverse proxy and Elixir Phoenix. What was more difficult to figure out as a beginner was the configuration in the various application files.
The two files ‘router.ex’ and ’endpoint.ex’ are found in the same directory, ‘/MyWebApp/lib/MyWebApp_web/’ which was created when you initialized your project. These files are often mentioned in tutorials. You can find lots of helpful information about them online and in the documentation.
router.ex
The ‘router.ex’ file is noted in most tutorials for beginners. Getting it right still took some time. Eventually though everything worked out. Turns out the web socket needed a route configured. As I am still learning about how all this works I don’t have in-depth understanding of why this is needed. But it did help get things running.
```
  scope "/", TenkeyWeb do 
    pipe_through :browser

    get "/", PageController, :home
    # Getting socket to work when web app in sub directory
    live "/tenkey", PageLive, :home               # "/tenkey" required to display tenkey app
    live "/tenkey/websocket", PageLive, :home  
  end
```
See reference 1. below for more information.
Next let’s take a look at ’endpoint.ex’ as this file is where the endpoints for the static files and the sockets are configured.
endpoint.ex
Two endpoints needed to be configured for my site. First was the app and the web socket used by the app. As you can see I need to configure the ‘/webapp/live’ sub-directory. I also left the ‘/live’ endpoint in the file. You might need it or you might not. I am still pretty new at this so I suggest experimenting.
Also, the asset files. CSS and JavaScript files are asset files which needed to be exposed as well. Otherwise the calculator didn’t look like a calculator and the buttons wouldn’t work! Neither will the socket for that matter.
```
    # Getting socket to work when web app in sub directory

    socket "/live", Phoenix.LiveView.Socket, websocket: [connect_info: [session: @session_options]]
    socket "/tenkey/live", Phoenix.LiveView.Socket, websocket: [connect_info: [session: @session_options]]

    # Serve at "/" the static files from "priv/static" directory. 
    plug Plug.Static,
    # Exposing static asset directories when web app in sub directory 
        at: "/tenkey",
        from: :tenkey,
        gzip: false,
        only: TenkeyWeb.static_paths()
```
See reference 1. and 2. below for more information.
config.exs
Another spot to configure static assets is in the ‘config.exs’ file.
```
# Configures the endpoint
config :tenkey, TenkeyWeb.Endpoint,
  # Exposing static asset directories when web app in sub directory 
  static_url: [path: "/tenkey"],  
  url: [host: "localhost"],
  render_errors: [
    formats: [html: TenkeyWeb.ErrorHTML, json: TenkeyWeb.ErrorJSON],
    layout: false
  ],
  pubsub_server: Tenkey.PubSub,
  live_view: [signing_salt: "vsvm/lgN"]
```
See reference 2. below for more information.
Last but not least, the configuration that finally got everything working with Caddy. Setting ‘check_origin’ in ‘prod.exs’ to allow ’localhost’ and my domain as origins finally opened up socket communication between the browser and server.
prod.exs
```
  # Getting socket to work when behind reverse proxy
  check_origin: ["//localhost:5000", "//example.com"]   # <===== This fixed the web socket connection problems!
```
See reference 3. below for more information.
After going through the research setting up the calculator in a sub-directory of the domain wasn’t a big deal. Getting there took some thinking and experimenting as I had never worked with Elixir, Phoenix, or LiveView before. Hope these notes are helpful.
References

How to Use the ChatGPT API in Python

29 Mar, 2023

The first thing you need to do assuming you have python is to install openai. Using pip:

$ pip install openai

Now you can import openai into your python script. The os module is useful for reading getting OpenAI’s API key from a file or environment variable.

import openai
import os
from pprint import pp

# Need a key from openai.com but don't store the key in the script.
# Read the first line from the secret file where the key is kept.

with open('secret', 'r') as f:
    txt = f.readline()
    key = txt.strip()

# Define additional parameters for the API request
params = {
    "engine": "text-davinci-003",
    "temperature": 0.5,
    "max_tokens": 500,
    "top_p": 1,
    "frequency_penalty": 0,
    "presence_penalty": 0
}

# create a completion

def gpt3_response(prompt, key, params):
    openai.api_key = key

    # Print list of available models
    models = openai.Model.list()

    for model in models.data:
        print(model.id)

    completions = openai.Completion.create(
        prompt=prompt,
        engine=params["engine"],
        temperature=params["temperature"],
        max_tokens=params["max_tokens"],
        top_p=params["top_p"],
        frequency_penalty=params["frequency_penalty"],
        presence_penalty=params["presence_penalty"],
    )

    return completions.choices[0].text
    
# print the completion

prompt = "Write a blog post on advantages there are to having ai write blog content."    
response = gpt3_response(prompt, key, params)

pp(response)

As you can see it really is not very difficult. The hardest part was figuring out where to put the key. I have the key in my .bashrc but Emacs wasn’t reading the environment variables from Linux. Keeping the key in the script is not a good idea either.

My solution is to put the key in a file in the same directory as the script. If I start using git on the script I will just put the file in the .gitignore. Though I may need another solution if I start accessing the API more regularly in my code.

The output from running the script:

>>>
babbage
davinci
text-davinci-edit-001
babbage-code-search-code
text-similarity-babbage-001
code-davinci-edit-001
text-davinci-001
ada
curie-instruct-beta
babbage-code-search-text
babbage-similarity
whisper-1
code-search-babbage-text-001
text-curie-001
code-search-babbage-code-001
text-ada-001
text-embedding-ada-002
text-similarity-ada-001
ada-code-search-code
ada-similarity
text-davinci-003
code-search-ada-text-001
text-search-ada-query-001
davinci-search-document
ada-code-search-text
text-search-ada-doc-001
davinci-instruct-beta
text-similarity-curie-001
code-search-ada-code-001
ada-search-query
text-search-davinci-query-001
curie-search-query
gpt-3.5-turbo-0301
davinci-search-query
babbage-search-document
ada-search-document
text-search-curie-query-001
text-search-babbage-doc-001
gpt-3.5-turbo
curie-search-document
text-search-curie-doc-001
babbage-search-query
text-babbage-001
text-search-davinci-doc-001
text-search-babbage-query-001
curie-similarity
curie
text-similarity-davinci-001
text-davinci-002
davinci-similarity
cushman:2020-05-03
ada:2020-05-03
babbage:2020-05-03
curie:2020-05-03
davinci:2020-05-03
if-davinci-v2
if-curie-v2
if-davinci:3.0.0
davinci-if:3.0.0
davinci-instruct-beta:2.0.0
text-ada:001
text-davinci:001
text-curie:001
text-babbage:001
('\n'
 '\n'
 'If you’re a business owner or content creator looking to increase your '
 'online presence, you’ve likely considered using artificial intelligence (AI) '
 'to write blog content. AI-generated content can be a great way to keep your '
 'blog fresh, save time, and reach a wider audience. Here are some of the '
 'advantages of using AI to write blog content.\n'
 '\n'
 '1. Save Time: AI-generated content can be generated quickly and efficiently, '
 'allowing you to focus your time and energy on other tasks. AI can also help '
 'you to create content that is more targeted and relevant to your audience, '
 'allowing you to get the most out of your blog posts.\n'
 '\n'
 '2. Reach a Wider Audience: AI-generated content can be tailored to the needs '
 'and interests of your target audience, helping you to reach a wider '
 'audience. AI can also help you to identify and target new markets, allowing '
 'you to increase your reach and engagement.\n'
 '\n'
 '3. Create Unique Content: AI-generated content can help you to create unique '
 'and interesting content that stands out from the competition. AI can also '
 'help you to create content that is more engaging and informative, helping to '
 'keep your readers interested and engaged.\n'
 '\n'
 '4. Automate Processes: AI-generated content can help you to automate '
 'processes, allowing you to focus your time and energy on other tasks. AI can '
 'also help you to identify trends and patterns in your content, allowing you '
 'to adjust your content strategy accordingly.\n'
 '\n'
 'Overall, using AI to write blog content can be a great way to save time, '
 'reach a wider audience, create unique content, and automate processes. If '
 'you’re looking to increase your online presence and reach a larger audience, '
 'AI-generated content can be a great way to do so.')
>>>

Hugo Posts With Featured Images
20 Mar, 2023
Last week I spent quite a bit of time messing around with implementing featured images on my blog. The main problem I was having was getting the featured image to display in the link preview on social media sites. Mainly the problem was with Twitter and Facebook. LinkedIn for some reason was showing the images while the other two were not.
After some random tinkering I figured some things out. I don’t know if it is optimal or Hugo best practices but it does work for me.
Background
What I started doing recently was keeping my images in page bundles for each post. As I understood matters I needed to use page bundles to take advantage of Hugo image processing. So, I made a directory for each post and an image sub-directory for the images for just that post.
Hugo Images in Static Directory
The alternative, which I had used in the past is to put the images in the /static/img/ai directory at the root of the site. After seeing my tinkering start to pay off I moved all the images back to /static/img/ai. Then removed all the individual post directories and just had post-name.md files in my blog directory. Back to pretty basic Hugo.
Where my images are now:
```
/static/img/ai/featured-example.jpg
```
Hugo Image Processing and Static Directory
Ah, the simplicity of having all the post images in one place. With the change though came a potential problem. Lack of image processing. Likely due to my own ignorance I thought I needed Hugo image processing to get images to show up at different scales in different sizes of screens.
More by sheer dumb luck than anything after I moved images back to /static/img/ai I decided to see how the posts with pictures looked on my iPhone.
Yay! They looked fine! On my iPad, too. So no worrying about 1000 pixel images taking up valuable reader screen space.
All I needed to do was put a figure tag with the link in the post body. Like so:
```
{{< figure src="/img/ai/feature-example.jpg" width="75%" alt="alternative text" title="Title with image generator credit -- misunderstood super hero creating digital pictures" >}}
```
Hugo Featured Images and Link Previews
My original problem though wasn’t fixed. Images were still not appearing on social media link previews.
What I did next looks redundant but it worked. For Facebook. In the post front matter I put the following:
```
....
images: 
    - /img/ai/feature-example.jpg
....
```
Hugo Twitter Card
Ta da! Images show up in the link previews for Facebook. What about Twitter link previews? One more step.
The Hugo short code for Twitter Cards:
```
{{ template "_internal/twitter_cards.html" . }}
```
Adding the built in Twitter card partial to the head section and Twitter shows a preview image with posted links. In my theme there is a custom_header.html file. Which is where I put the above code.
Take a look at your theme documentation if link previews aren’t working for you. You may just need to add a line to your config.yaml. Or maybe do something like I needed to do.
Really, getting the link previews working wasn’t difficult. I just didn’t understand what need to happen. Not needing to use page bundles to get the effect I want my site is much simpler for me to maintain, too. Though I might consider additional directories inside of /static/img/ai if keeping everything in one spot becomes unwieldy.

Hugo Workflow, Archetypes, and Other Things of Note
19 Mar, 2023
Welcome to the first ever Week in Review from ReplTo! My hope is to make this a regular thing. I often get to the end of a week and look back wondering where the heck all my time went.
Doing a review is really handy. When I reflect on my activities for the week I realize I really didn’t just wander aimlessly through the past seven days. Even better I get new ideas to explore and share with you.
Once again welcome and let’s begin reflecting on another week gone by at ReplTo.
Blog Posts this Week
I did write a python article didn’t I? Not sure. Yes, turns out I wrote two! Hopefully, the titles are self-explanatory.
- How to Use Python With Excel Files
- How to Run the Python Debugger
Blogging vs Writing Articles
Probably, the biggest change I made this week was getting my head clear about what kind of writing I am doing. By that I mean, am I writing essays and articles? Or am I writing more informally, keeping a log or journal, of my tech research and tinkering?
For whatever psychological reason when I call what I write an article all the sudden I have a whole bunch of high expectations which just get in the way. When I write blog posts then the expectations ease up.
Being more informal fits me much better.
This switch in perspective meant I needed to go back and revert a bunch of changes I made to my Hugo set up. They weren’t difficult just took a little time and testing.
Changes to Hugo Archetypes
I made changes to the archetypes, which are the templates used to create a new blog post. While I was changing what to call the archetype I also changed the template itself.
Related to the front matter changes. Dates on blog post file names were deleted. I was using the date to help sort the files but had to edit the date out of the file name. Not only was it adding to my blog post work load I was setting myself up for url collisions in the future.
I have the title for each post generated from the filename. Pre-pending the date to the filename made every filename unique. If I create a future post with the same title as a past post, with the date making them unique, in the end I could have two posts with the same url.
As a bonus to getting things cleaned with filenames I got to learn a new Emacs key combo. Using the key combination below and the navigation keys I set the selection area then deleted all the pre-pended dates in a couple key strokes. All from the directory browser.
Emacs Trick!
```
C-x C-space
```
This is going to be so handy. Of course, like many things I learn about Emacs it has been around a very long time. Better late than never!
With the above key combo you can set the beginning of an area to edit. This differs from the typical mark by only showing the columns of text between the set point and current position of the cursor. What gets highlighted is the actual text being selected. With the typical way of selecting text the entire row gets highlighted. Which I have found confusing.
YAML Front matter
Editing the YAML front matter parameters for each of the blog archetypes also simplified processing and workflow. Less editing while writing a post is a big plus. With changes I made to the filenames (see above) I didn’t need a url: parameter.
```
....
author: Eric
....
tags: untagged 
```
Hugo Layouts
Layouts have been simplified. Every section (sub-directory under “content/”) uses the default layout. Except Pages. Pages is where the About and various Terms type pages are kept.
What is different about Pages? No social icons and tag cloud at the bottom of the post.
Posts in sections besides blog (and Pages) just need to have their type set to blog and to get rendered with social icons and tags. There aren’t any other section but nice to be prepared! On my site Occult Alchemy I do have multiple blog post sections. This solution lets me use the same layout for each site. Yay!
SEO Modifications
While I was doing surgery on my set up I took a look at some ways to help with SEO. One thing I did was take a look at my custom_header partial. I added the following line for a mobile friendliness.
```
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
```
A site I quite like, https://xeiaso.net/, inspired me to make some visual changes. A bit retro. I particularly liked the background color and the front page content and layout.
After changing the background color contrast between background and text, both links and content, wasn’t very good. While not a big SEO factor, from what I read, it can be a thing. Luckily there are web sites out there to help you find color settings for good SEO friendly contrast and readability. Search for “CSS contrast color generator” or similar.
Descriptions for all the posts on all my sites needed work. I deleted what descriptions were there and added new ones to all my posts on ReplTo. Occult Alchemy will have to wait. Too many posts to get to right now.
Social Media
Last but not least I plunged deeper into social media. After having deleted all my social media accounts, except Instagram, during the Covid/Election Season drama-fest, I only went back to Twitter recently.
This week though I signed up for Facebook and LinkedIn. Again.
We’ll see how everything pans out. There are a few people I want to stay in touch with including close family. Also, some organizations and events I am interested in are only on Facebook. Hopefully, I can keep my connections limited on Facebook. Hard to be a hermit these days.
I do have Facebook pages for this site and Occult Alchemy which is nice. Interestingly, when I tried to get a url for my old occult site it was taken. Plunking around for ideas I came up with the name OccultAlchemy. Liked it so much I paid for the domain name for the site, too. Lucky it was available!
Okay, that pretty much sums up the week. The tech side anyway. Thanks for reading and have a great next week!

How to Use Python With Excel Files
15 Mar, 2023
Ready to leverage the power of Python? If you have data in Excel, Python is just what you need to make the most of those files.
First though you need to get the data into Python. Luckily, reading Excel files is simple and easy. All you need to do is install a few modules.
Using pip install the following. If you are using environments make sure you are working in the right environment.
The modules are pandas, xlrd, and openpyxl. They should install pretty fast.
Preparing Python to Work With Excel Files
```
$pip install pandas
$pip install xlrd
$pip install openpyxl
```
With the modules installed via pip you are ready to get to work!
Import Excel Workbooks into Python with Openpyxl Module and Pandas
First thing we need to do is import the load_workbook function from openpyxl. With load_workbook we can now load the workbook and see the sheetnames. Using pandas we then load the data from any sheet we wish into a DataFrame.
```
import pandas as pd
from openpyxl import load_workbook

# Load the workbook
wb = load_workbook('Customers.xlsx')

# Select the worksheet to use
ws = wb.worksheets[1]

# Load the worksheet in Dataframe
df = pd.DataFrame(ws.values)

# Finished with data. Save to new file.
wb.save('Customers-Saved.xlsx')
```
Checking we can see the sheetnames list from the workbook and verify the data for the second sheet is indeed loaded in the DataFrame.
```
>>>
>>> wb.sheetnames
['Customers', 'Work']
>>> df
                  0                1
0        Profession  Work Experience
1        Healthcare                1
2          Engineer                3
3          Engineer                1
4            Lawyer                0
...             ...              ...
1996         Artist                8
1997         Doctor                7
1998     Healthcare                9
1999      Executive                7
2000  Entertainment                5

[2001 rows x 2 columns]
>>>
```
Analyzing Excel Data with Python and Pandas
With the data loaded into a DataFrame you have the power of Python and Pandas at your fingertips. I am not going to describe how to do analysis or visualizations of your data in this article. That could easily take a book, or two.
Here is a short list possibilities once the data is loaded:
- Graphs and charts using Matplotlib. Many styles are available.
- Exporting charts to Excel.
- Matrix operations.
- Statistics.
- Data Cleaning and preparation. This can take most of your time in any data project. Real world data is messy! Python is an excellent tool for cleaning up data messes.
I am barely scratching the surface. You can do most things you might want to do with Python and pandas.
Saving Data from Python to Excel
Finally we get to the last line where we save our work back to an Excel file. Warning: These methods will overwrite existing files without warning. In this example only the active worksheet gets save to the new workbook.
```
# Finished with data. Save to new file.
wb.save('Customers-Saved.xlsx')
```
All done!
As you can see saving is pretty easy. Though we didn’t show examples there are quite a few options to explore. Saving multiple sheets, adding sheets to existing files, appending data, saving charts, and more.
You’ve seen what you need to do to use Python for reading and working with Excel files. Installing the modules and loading an Excel file for analysis were pretty straightforward. When you are done saving is pretty easy too.
note: Sample data is from Kaggle and was modified for these examples.

How to Run the Python Debugger
13 Mar, 2023
Are you having trouble getting your python code to run? Luckily, there are a couple of ways to figure out what is causing the errors.
The first is to put print statements near where you think things are going wrong. If the print statement executes you know things were working fine until that point. Add more and move them around until you get to the misbehaving line of code.
Yes, I have too many years of experience doing exactly that painful process. One day though I saw another way.
The Python Debugger
Enter the Python Debugger. Running the debugger is pretty simple. Import the pdb module. Call the pdb.set_trace() function. Run your program.
Want to stop? Enter ‘q’ at the Pdb prompt.
Below is a simple program to demonstrate.
```
import pdb

pdb.set_trace()

x = 1.5

print(x)

y = 2.7

print(x, y)

print(x*y)

print(x+y)
```
When you run a program pdb evaluates the code step-by-step then prints the code and returns resulting values, if any. In Emacs the line being evaluated is indicated with ‘=>’ on the left side in the source file. When all the steps have been evaluated the debugger returns back to the repl.
In order to evaluate the next step enter ’n’ for ’next’ at the prompt. Running the above code looks like the following on my system.
Debugger evaluating source:
```
>>> 
> /home/eric/src/py-debug.py(4)<module>()
-> x = 1.5
(Pdb) n
> /home/eric/src/py-debug.py(6)<module>()
-> print(x)
(Pdb) 
```
Source being evaluated:
```
import pdb
pdb.set_trace()

x = 1.5

=>rint(x)

y = 2.7

print(x, y)

print(x*y)

print(x+y)
```
Notice the ’n’ entered at the (pdb) prompt to move to the next line. The ‘=>’ is on the left side of the current line.
Below is an example evaluating the source code at the command line.
```
bash $ --> python py-debug.py
> /home/eric/src/py-debug.py(4)<module>()
-> x = 1.5
(Pdb) n
> /home/eric/src/py-debug.py(6)<module>()
-> print(x)
(Pdb) n
1.5
> /home/eric/src/py-debug.py(8)<module>()
-> y = 2.7
(Pdb) n
> /home/eric/src/py-debug.py(10)<module>()
-> print(x, y)
(Pdb) n
1.5 2.7
> /home/eric/src/py-debug.py(12)<module>()
-> print(x*y)
(Pdb) n
4.050000000000001
> /home/eric/src/py-debug.py(14)<module>()
-> print(x+y)
(Pdb) n
4.2
```
Pretty simple!
At the same time the pdb module is very powerful. Imagine how many print statements even a simple program might need. Let alone a few thousand lines.
We only looked at running the python debugger using a simple example and one basic command. Take a look at the other commands to supercharge your debugging. You might not need so many print() in your code.

Review: Asus ZenWiFi AX6600 XT8
11 Mar, 2023
Last month (February 2023), my home network was a mismatched collection of Ethernet-Over-Power devices, a couple different WiFi routers, and even a switch somewhere. The network though did its job pretty well.
Until it didn’t, 20 minutes before my wife needed to sign into work.
We had been having intermittent connection issues I blamed on the modem and our ISP. So I wasn’t surprised it happened again I did eventually get everything working in time for work. But worrying about everyting being stable in the wee hours was getting old.
Turns out I was wrong about why we were having problems. Nope, the connection with the ISP was fine. The problem was between the modem and the router. The modem and router weren’t playing well together.
With my wife’s job dependent on a solid internet connection at home I decided spending a little money to upgrade was a worthy investment. After shopping around I decided to give the Asus ZenWiFi AX6600 XT8 a try.
Reviews were quite positive and comments include how the configuration interface was quite detailed. Which as a bit of a tinkerer was just fine with me. Others, less technically inclined, might fine it a bit intimidating. Luckily, as I found out later, you really don’t have to deal with the configuration details.
So I plunked down my money (credit card on Amazon) and placed my order. The router package I ordered came in a two pack. They advertise a total coverage area of 5500 square feet. Which is about twice the size of my house including the basement.
As soon as it arrived and my wife was signed off from work I disconnected the old router from the modem and plugged in one of the pair of new routers. How hard was it to get the new network up and running?
Dead simple.
Even with one router I was finding a solid signal throughout the house. The strength varied a little bit as the modem and router #1 are downstairs. We have a massive two story chimney in the middle of the upstairs between the living room and the kitchen. I suspect this thing was messing with the old routers. The signal might have not been as strong as it could have been without all that mass of brick and steel in the way.
The other router I placed upstairs in my wife’s office. Which give the two routers a clear path to connect. I also wanted her to be able to plug into router #2 with her work laptop base station. With the placement of router number two all parts of the house were getting signal without having the chimney in the way.
Installation was a breeze. Router #1 found router #2 and the rest is history.
So about that 5500 square foot coverage?
After the network was up and running I called a buddy using Wifi calling on my iPhone. No drops anywhere in the house! We have various places in the house where calls would drop either from dead zones or possibly hand offs between routers.
Not anymore! Even more impressive I walked out into the yard to our back fence. The distance was about 40 feet from the house. My friend said there was a slight degradation in sound quality but totally fine.
How are things a month later?
Stable. As good as installation day.
Eventually, I decided to do a speed check. My internet package is rated at 200Mb/sec. The speed test showed over 230 to 250+Mb/sec. Nice! The old network might get to 40 or 50Mb/sec. So a 4-5x improvement! Getting what we pay for from our ISP finally.
Am I happy with the upgrade? You bet. I am very impressed.
Being used to budget consumer routers and their lower prices gave me pause when I was buying. Paying our bills working from home requires the network be fast for video calls, no dropped cell calls with clients, and a reliable VPN connection. Definitely worth a few hundred more dollars for the pair of routers.
Besides, now I can take my iPad to the far side of our yard and read under the apple tree. Once it stops raining.

Hugo Custom Font
10 Mar, 2023
Sometimes the smallest things can take forever to get done. Such was the case with changing the font for this site ~~RelpTo~~.
Why change?
The old font was okay. I think it was Verdana. A sans-serif font which looked fine and I still am using on my rather non-technical blog. For this blog though there is one little detail which I couldn’t let slide which doesn’t matter on my other site.
The zero with a slash is missing! Readability for me is improved with zeros which don’t look much like “ohh”’s which is how I have Emacs set up for programming.
As many technical articles have code fonts with slash-zero are very much preferred. Monospace fonts also set a certain tone or feeling, I feel, which fits a technical blog nicely.
After too much tinkering I did finally decide on a font. Inconsolata is what I went with and nicely is also what I use with Emacs.
Adding a New Font to Hugo
What follows is how I set up my site to use the Inconsolata font.
In the static directory of the local site root you create a css directory for a custom.css file. Anything in the static directory of your local hugo site root gets copied over as-is to the rendered site in the public folder created by Hugo during processing.
```
static/css/custom.css
```
The custom.css file is where we set the font family we want to reference and where to find the files defining the font. In this case, I am providing the font files which I downloaded
```
@font-face {
  font-family: 'Inconsolata';
  src: url('/fonts/Inconsolata.otf') format('opentype');
}
```
Copy the font file you downloaded to the static/fonts directory:
```
static/fonts/Inconsolata.otf
```
The Hugo theme I am using has a partial available called custom_head.html. Anything put in this file will get placed with whatever else is already there. The partial is found here:
```
layouts/partials/custom_head
```
What it looks like after Hugo renders the site. Note the reference to the static directory is dropped since Hugo only takes what is in the directory and not the directory itself.
```
<head> 
    ....
    <link rel="stylesheet" href="css/custom.css">
    ....
</head>
```
If your Hugo theme doesn’t have something similar you should be able to put it in whatever _default template has the head section.
Finally, we have the file. A partial named style.html which contains all the CSS formatting and references the font to use. In order to override the CSS from the theme copy the file to:
```
layout/partials/style.html
```
Changing the CSS
Then in this case edit to reference the new font instead of the old one. All I did was change the font-family line.
```
<style>
  body {
    font-family: "Inconsolata", monospace;
    margin: auto;
    padding: 20px;
    max-width: 720px;
    text-align: left;
    background-color: #fff;
    word-wrap: break-word;
    overflow-wrap: break-word;
    line-height: 1.5;
    color: #444;
  }

......
```
When you check your site you should see all the text in your new font! To render locally for testing:
```
$ hugo -D server
```
Not too hard. Something which threw me though was browser differences. My Firefox on MX Linux was rendering the zero slash as dots in zeros. Which is better than nothing but still….
Then when I went to bed after resigning myself to not having slashed zeros I checked the site on my iPad. In both Safari and Firefox on the iPad I saw slashed zeros! So it did work.
Always good to have a few ways to see how your site looks. Even after all this time browsers are not all the same.

Multiple Python Installations
08 Mar, 2023
When did Python 1.52 make an appearance in the programming world? Python 1.52 was the first version I used. Still have an old reference book for that version. Time keeps rolling along.
Having spent a couple years or so recovering from my last cubicle burnout experience I feel ready to get back into some tech fun. Having served me well all these years I decided to get my Python mojo back.
What to install? Python3 is the current major version, Python2 is no longer being developed. There are a number of choices for Python3 including alternatives like Anaconda.
A few of these Pythons sounded like they would be fun to get to know again. So I started looking around for a way to install and manage them without having too many headaches in the process.
Installing Python Package
My MX Linux system already has Python3. A quick update and upgrade gets my system Python up-to-date. If you don’t have the latest Python for you Linux system you can go ahead and install, too.
```
$ sudo apt-get update
$ sudo apt-get upgrade
$ sudo apt-get install python3
```
Pretty easy. One snag. With MX Linux being Debian based the Python version is not the latest release. Since I wanted to use the latest release that was a problem.
Compile Python from Source
What do you do if you want the most current Python and your package repository doesn’t track the latest version? One option is to download the source code and compile your own.
What I don’t like about compiling is removing the compiled version can be messy finding all the files to remove. Sure uninstalling might be possible via:
```
$ sudo make uninstall 
```
I don’t trust this approach enough to rely on it. Too many things going on during the installation process to keep track of let alone remember in six months.
Luckily, there is a solution (see below) which allows me to keep the version of Python I am compiling in one spot away from my system installations. Then if I want to remove it I can just delete one directory. No file hunting!
Just down load the source, extract it, and switch to the source directory. And do the following:
```
$ ./configure --prefix=/opt/python/3.11.2 --enable-optimizations
$ make -j3
$ sudo make altinstall
```
What is going on here?
Somewhere online I found a suggestion I really like and is working out nicely for keeping multiple versions of Python. Setting the prefix option to /opt/python/ puts all the files in one easy to find spot. Very handy!
The enable-optimizations option was just something I wanted to play around with. I haven’t had a chance yet to measure the impact.
With make -j3 the compiler uses 3 of my 4 cores. It did appear to compile pretty fast.
Finally, Python gets installed in the prefix directory.
Anaconda3
The third Python I installed is really much more than Python. Anaconda3 from https://anaconda.com is a suite of software which includes not only Python but a number of other tools and packages of interest to data scientists. If data science is your thing it is worth a look. Plus it is really easy to install on whatever major operating system you use.
The question is where to install Anaconda3? The default location for installing on Linux is the user home directory. Personally, I attempt to keep my home directory from getting too full. Keeping with the same generaly idea of using /opt when compiling form source I installed Anaconda3 into my ~/opt directory.
Pick Your Python
Looks like we are all set to do some programming! But which python do we use and how do we get our system to use it for our project?
This is where python environments come in handy. I will write more later on how I set up my environments. Basically, I activate the environment I want to use for the project I am working on. That environment already knows which python I want to use. And I start programming.

Everything Else

Recent Articles

router.ex

endpoint.ex

config.exs

prod.exs

References

Background

Hugo Images in Static Directory

Hugo Image Processing and Static Directory

Hugo Featured Images and Link Previews

Hugo Twitter Card

Blog Posts this Week

Blogging vs Writing Articles

Changes to Hugo Archetypes

Emacs Trick!

YAML Front matter

Hugo Layouts

SEO Modifications

Social Media

Preparing Python to Work With Excel Files

Import Excel Workbooks into Python with Openpyxl Module and Pandas

Analyzing Excel Data with Python and Pandas

Saving Data from Python to Excel

The Python Debugger

Adding a New Font to Hugo

Changing the CSS

Installing Python Package

Compile Python from Source

Anaconda3

Pick Your Python