Valley Programming blogs

Woo Woo Woo: A binaural beats app

alvin — Tue, 20 Jan 2026 19:44:12 +0000

Woo Woo Woo — also known as just Woo Woo — is a simple, totally-private, binaural beats app for meditation, relaxation, focus, and sleep.

Because we use binaural beats every day, we took the time to create an app that works simply and privately, and has the features we want.

Note 1: This is a paid app because we have a lot of other ideas we’d like to implement over time, and we couldn’t afford to implement those ideas with a free app.

Note 2: The app Privacy Policy and Technical Support information is shown later on this page.

Features

These are the current features of our app:

Beat Frequency: Adjust from 0.5 to 40 Hz to target the brainwave states you want. (See the brainwave states listed below.)
Tone Frequency: Choose your carrier tone from 40 to 600 Hz. Lower tones tend to be more relaxing, and higher tones tend to be more energizing.
Presets: Easily save your favorite settings, so you can quickly recall those favorites for focus, meditation, and relaxation.
Background Playback: Plays in the background so you can also listen to your favorite music, podcasts, audiobooks, etc., if desired.
Switch ears: The base tone can be switched between the left ear and right ear as desired. We find this helpful when you realize you’re listening to tones, but don’t hear any beats. (We suspect that there is a certain “brain fatigue” in listening to beats, and this might be a way to overcome that.)
Auto-Stop: Optionally stop playback when headphones disconnect.
No ads, no subscriptions, no account required: Everything works locally on your phone, so the app is completely private.
Works on iPhone, iPad, and Mac, too: On iOS, we’ve written the app so it not only works on your iPhone, but also your iPad and Mac, so you can use it anytime, anywhere.

What are binaural beats?

With the app we generally assume that customers already know what binaural beats are, but in short:

When you hear two slightly different frequencies in each ear, your brain perceives a third tone — the “beat” — at the difference between them. Research suggests that the Hz of that beat can help guide your brain toward different mental states.

Brainwave States

Here’s a quick look at Hz ratings and their corresponding brainwave states:

Delta (0.5-4 Hz): Deep sleep
Theta (4-8 Hz): Meditation
Alpha (8-13 Hz): Relaxation
Beta (13-30 Hz): Focus
Gamma (30+ Hz): High cognitive function

Requirements

Stereo headphones or earbuds are required. Binaural beats do not work with speakers.

About the name

The name Woo Woo Woo is based both on the sound you hear when you play binaural beats, but also the sound one of our Siberian Huskies makes every day when she wakes around the office (which is usually “woo woo”, but occasionally “arooo...”).

Privacy policy/statement

With Woo Woo Woo, everything works locally on your phone, so the app is completely private. The only data we save is (a) your “preset” settings, and (b) your last-used settings (so they can be recalled the next time you start the app), and again, that data is only stored on your phone.

Technical support

To report a bug, make a feature request, or just a general comment, please use this Google Form page.

Our “Back To Now” app: Now available for iPhone and iPad

alvin — Sat, 09 Aug 2025 15:39:13 +0000

August 9, 2025: Valley Programming is proud to announce the Version 2.0 release of our Back To Now app for iPhone and iPad devices!

How it works

Back To Now is a “mindfulness reminder” application that helps you return to the present moment. The basic concept is simple:

Create a list of your favorite mindfulness quotes
Add your favorite images
Configure your desired reminder schedule
Then, receive “mindfulness reminders” as notifications, on your schedule
Tap the notifications to see your reminder on top of your images

As a bonus, if you have an Apple Watch, the notifications will also appear on your watch. And if you have a Mac, it will also run there.

The Back To Now slideshow

This all-new release of Back To Now also offers a slideshow/screensaver mode that helps to keep you constantly in the present moment.

The Slideshow is currently in the “More” area of the app. To use it:

Go to the More tab
Configure the slideshow settings
Start the slideshow
Put your phone down where you can see it
Observe your beautiful quotes and images, to constantly keep you in the present moment

This is what several of the default images and quotes look like in full-screen portrait mode:

I think the slideshow looks even more beautiful in landscape mode:

Current features

While we hope to implement many other features in the future, other current features include:

Bulk-importing quotes
Bulk-importing images from your device
Bulk-exporting your quotes, as a way to share them to other devices
The ability to put “jitter” in your schedule, to help randomize when they are sent
The ability to “pin” quotes, so you only see those quotes during the day (to help you focus on a certain practice, for example)

Privacy: Back To Now is completely private

It’s important to note using Back To Now is completely safe. All of your data is stored on your device, and it doesn’t do anything at all over the internet, so it doesn’t track you in any way.

Downloads

You can find Back To Now here on the Apple App Store:

Back To Now

Release history

This is the app-release history:

Version 2.0.1: The app was showing in the App Store as “Designed for iPad”, when it’s really designed for iPhone.
Version 2.0.0: The new main release.

Free Scala and functional programming video training courses

alvin — Sat, 21 Dec 2024 17:56:05 +0000

If you’re interested in learning the Scala programming language or functional programming, Alvin Alexander, the author of the Scala Cookbook, has created a website dedicated to these two topics. Here’s a link to his free Scala and functional programming video training courses on LearnScala.dev.

As you may know, Mr. Alexander is also the author of Functional Programming, Simplified, which is one of the best-selling and highly-rated functional programming books of all time.

Also, please note that these free video training courses are sponsored by Ziverge.

Free: Introduction To Functional Programming video training course

alvin — Wed, 31 Jan 2024 18:14:58 +0000

As a little update, here’s a link to a free “Introduction to Functional Programming” video training course. The training course consists of over 50 videos, all of which are free.

This is a free “functional programming in Scala 3” video training course, created by Alvin Alexander, the author of the following Scala and functional programming books:

As you can see from the ratings with all those books, Mr. Alexander is a well-known and highly-rated teacher in the Scala and functional programming community.

The #1 functional programming (and computer programming) book

alvin — Wed, 12 Apr 2023 16:57:04 +0000

Dateline, April, 2023: Alvin Alexander’s newest book, “Learn Functional Programming The Fast Way!”, is a #1 Best-Seller in three computer programming book categories:

Computer Programming (general)
Functional Programming
Data Modeling and Design

This image shows the book being the best-selling book in Amazon’s Functional Programming category on April 12, 2023:

Other images that we haven’t posted here show the book being #1 in the general Computer Programming category and the Data Modeling and Design category.

If you’re interested in functional programming, this is the #1 best seller!

The User Story Mapping Workshop process

alvin — Mon, 09 May 2022 02:15:18 +0000

A technique that I’ve known for a long time — but has been improved by my recent Certified ScrumMaster (CSM) and Certified Product Owner (CSPO) training — is how to conduct a “User Story Mapping Workshop” at the beginning of a new software development project.

The basics are simple: You get together in a room with the Product Owner, Stakeholders, Subject Matter Experts (SMEs, also known as Domain Experts), Developers, Designers, ScrumMaster, and anyone else who should be there. Then you begin brainstorming the possible user stories and personas (also known as users, or actors).

A User Story Mapping Workshop board

For example, this is what a User Story Mapping Workshop board might look like if you were brainstorming and inventing Facebook back in the day:

Note that the board includes both potential user stories (at different levels of detail) as well as personas. I like to add them all as they come up.

It’s generally more effective and preferred to do this with actual sticky notes on a wall or table, but in some cases using a software tool can be acceptable. (Though the use of a software tool is generally considered a bad practice. Feel free to ask me about this when we’re working together.)

Starting to organize the User Story Mapping board

Once you’ve gotten a little way into your effort you will naturally see that the user stories line up into different categories. For instance, if you continued to work on the invention of Facebook, you would eventually start organizing your stories into logical groups like this:

In this grouping:

Posts are any stories related to adding, editing, or deleting a post
Friends are any stories related to adding, editing, or deleting a friend
Account is any stories related to managing your account

Continuing from here

At this point you would continue this process in a variety of ways, including the ongoing management and grouping of stories, adding story details, and much more. I’ll add to this at some point, but until then, if you’re interested in the User Story Mapping Workshop process, I hope this example is helpful.

Reporting live from Simpsonville, Kentucky
Alvin Alexander
Certified ScrumMaster & Certified Scrum Product Owner

Alvin Alexander, Certified Scrum Product Owner (CSPO)

alvin — Mon, 09 May 2022 01:26:31 +0000

As a brief note today (May 2, 2022), Alvin Alexander is now a Certified Scrum Product Owner (CSPO), certified by the Scrum Alliance. This is in addition to his many years of leading agile software teams in Scrum, Scrum-like, and Scrumban environments, and also being a Certified ScrumMaster (CSM).

Alvin Alexander is now a Certified ScrumMaster (CSM)

alvin — Mon, 25 Apr 2022 06:50:45 +0000

As a brief note today (April 24, 2022), Alvin Alexander is now a Certified ScrumMaster (CSM), certified by the Scrum Alliance. This is in addition to his many years of leading agile software teams in Scrum, Scrum-like, and Scrumban environments.

Our “Back To Then” app (for iOS and Android)

alvin — Fri, 08 Apr 2022 03:13:20 +0000

Back To Then is a “photo frame” slideshow app. Just copy your favorite photos into the app and then press Start Slideshow, and it slowly rotates your photos in full-screen mode on your device. When you want to stop the screensaver, just tap the screen to return to the main menu.

Back To Then doesn’t have any ads, and it doesn’t access the internet, so your photos remain completely private to you.

How It Works

To use Back To Then:

Copy your favorite photos from your photo library into Back To Then.
Tap Start Slideshow to start the slideshow.
Optionally, adjust the slideshow Settings as desired.

When the slideshow starts, your photos will be displayed in a random order, with smooth animation effects. To exit the slideshow, tap anywhere on the screen.

Managing Images

To add and remove images, tap Manage Images on the main screen.

Note: To help make scrolling faster, smaller versions of your images are shown in the Manage Images screen. But don’t worry, your full, large images are shown in the Screensaver.

Adding images

To add one or more images:

Tap the “+” button on the Manage Images screen.
Select one or more images to add to the Back To Then image library.

As a “pro tip,” if you want to add a large number of images, it can be easier to first create an album in your phone’s Photo app, and put all the images you want in that album. Then you can select all of those images from within Back To Then.

Removing images

To remove an image:

On the Manage Images screen, swipe left or right on the image, and it will be removed from the Back To Then app.

Note that this will not affect the image in your phone’s main photo library, because these are two separate locations.

Managing Settings

You can manage the following settings:

Minimum Animation Duration: The shortest time that an image will be displayed during its animation. (Default is 4 seconds.)
Maximum Animation Duration: The longest time an image will be displayed during its animation. Larger images typically take more time than smaller images. (Default is 10 seconds.)
Image Transition Duration: The time for the transition from one image to the next. (Default is 5 seconds.)
Maximum Image Zoom: The maximum amount images will be zoomed-in on during the time they are displayed. (Default is 2x.)

Note that for the time-related settings, the lower the values are, the faster the animations will move across your screen.

Created By

Back To Then is lovingly crafted by Valley Programming (valleyprogramming.com) of Louisville, Kentucky.

The name Back To Then is inspired by our mindfulness app, named Back To Now. You can find both apps in Apple’s App Store and the Google Play Store.

A Docker cheat sheet

alvin — Thu, 06 Jan 2022 21:10:33 +0000

This is the beginning of a Docker cheat sheet. I couldn’t find any out here that I liked, so I’m starting to create my own, which will hopefully be organized the way I like it. (This cheat sheet is cross-posted at alvinalexander.com/programming/docker-cheat-sheet-cheatsheet.)

Docker Basics

Recommended as a first command on a Docker system:

docker version     # should show Client and Server sections

Docker Lifecycle

This section mostly comes from (https://github.com/wsargent/docker-cheat-sheet):

docker create     creates a container but does not start it
docker rename     allows the container to be renamed
docker run        creates and starts a container in one operation
docker rm         deletes a container
docker update     updates a container's resource limits

Docker Build

Build an image using a Dockerfile in the current directory:

docker build -t scala-webserver-1 .

Other build commands:

docker build [url]      # create an image from a Dockerfile at a URL
docker build -t [url]   # build an image from a Dockerfile and tag it

docker load [tafile]    # TODO (more on this)

I needed to use this command when building a Linux distro on macOS (which uses an ARM chip):

docker build --platform linux/amd64 -t scala-webserver-1 .

TODO: There is also a docker create.

Example Dockerfile:

FROM openjdk:11
WORKDIR /home
COPY target/scala-3.1.0/WebServerDocker3-assembly-0.1.0.jar WebServerDocker3-assembly-0.1.0.jar
#CMD java -jar ManualDockerfile2-assembly-0.1.0.jar
EXPOSE 5150
CMD ["java", "-jar", "WebServerDocker3-assembly-0.1.0.jar"]

Can also expose multiple ports:

EXPOSE 5150 5151

Docker Images

List images:

docker image ls
docker images
docker images -a
docker images -f dangling=true

Pull and push images from a registry:

docker pull [image]
docker pull alpine
docker pull alpine:latest

docker push [image]

Remove images:

docker rmi [image]
docker rmi alpine:latest

docker rmi $(docker images -q)
docker rmi $(docker images -a -q)
docker rmi $(docker images -aq)
docker image prune

Other image commands:

docker history [image]   # show the history of an image

Docker Run (run an image)

Start a container with an interactive shell:

docker run -it alpine /bin/sh
docker run -it rhel7/rhel bash

docker exec -it <container-name> /bin/sh
docker run -it --rm --name my-running-app my-java-app

# example:
$ docker run -it debian:stable /bin/bash
Unable to find image 'debian:stable' locally
stable: Pulling from library/debian
d39780c72a13: Pull complete 
Digest: sha256:e8795576943b7bb2ecf2126c3b7f467da64c84f3c4d63f75c24fb91502ab8487
Status: Downloaded newer image for debian:stable
root@ef74a0677a41:/#

Run an image, exposing its port 5150 as port 8080 of the container:

docker run -p 8080:5150 scala-webserver-1

> curl http://localhost:8080
Have a nice day!

More run commands:

docker run [image]        # start a container
docker run --rm [image]   # run a container, remove it when it stops
docker run -td [image]    # TODO
docker run -it [image]    # start a container, run a command in it, connect to it (TODO)

An example from https://design.jboss.org/redhatdeveloper/marketing/docker_cheatsheet/cheatsheet/images/docker_cheatsheet_r3v2.pdf:

docker run -d \
    -p 8000:8000 \
    --name=pythonweb \
    -v `pwd`/www:/var/www/html \
    -w /var/www/html \
    rhel7/rhel \
    /bin/python \
    -m SimpleHTTPServer 8000

Docker Containers

List active/running containers:

docker container ls
docker ps

List active/running and stopped containers:

docker container ls -a
docker ps -a

List all containers:

$ docker container ls -a
CONTAINER ID   IMAGE               COMMAND                  CREATED         STATUS                        PORTS     NAMES
3fd5b267c069   scala-webserver-1   "java -jar WebServer…"   3 minutes ago   Exited (130) 26 seconds ago             ecstatic_shamir
2835d9c80513   scala-hello-1       "java -jar ManualDoc…"   24 hours ago    Exited (0) 24 hours ago                 busy_sammet

# list by status
docker ps -a -f status=exited
docker ps -a -f status=exited -f status=created

# list by pattern
docker ps -a | grep "pattern"

Start, stop, and restart containers:

docker start [container]

# more 'start' options:
docker start [options] [container]
    -a, --attach        # attach stdout/stderr
    -i, --interactive   # attach stdin

docker stop [container]
docker stop -t5 [container]   # stop with a timeout

docker restart [container]

docker pause [container]      # pause processes in a running container
docker unpause [container]

docker attach [container]     # attach STDIN, STDOUT, STDERR to a running container
docker wait [container]       # block a container until (TODO)

docker kill [container]       # send SIGKILL to a container

# kill all running containers:
docker kill $(docker ps -q)

Other container commands:

docker events [container]     # list the events from a running container

docker logs [container]       # list the logs from a container
docker logs -f [container]

docker top [container]        # show running processes in a container

docker diff [container]
docker port [container]
docker stats [container]

docker export ...             # export container’s filesystem as a tar archive
docker exec ...               # run a command in a running container
docker pause ...              # pause all processes in a running container

Information commands:

diff
events
inspect
logs
port
ps
stats
top

Remove a container:

$ docker container rm 3fd5b267
3fd5b267

Remove multiple/all containers:

# remove all stopped containers:
docker rm $(docker ps -aq)

docker rm $(docker ps --filter status=exited -q)
docker ps --filter status=exited -q | xargs docker rm

Stop all running containers:

# stop
docker stop $(docker ps -a -q)
docker stop $(docker ps -aq)

# remove
docker rm $(docker ps -a -q)
docker rm $(docker ps -a -f status=exited -q)
docker rm $(docker ps -a -f status=exited -f status=created -q)

# remove by pattern
docker ps -a | grep "pattern" | awk '{print $1}' | xargs docker rm

Docker Networks

List networks:

docker network ls
docker network inspect [network]

# connect a container to a network
docker network connect [network] [container]

“Dangling” resources

This section needs more work, but here are some initial examples:

docker system df          # show space used by docker objects

# remove all "dangling" resources (images, containers, volumes, networks)
docker system prune       # not tagged or associated with a container
docker system prune -a    # stopped containers and unused images

TODO: “Dangling” may mean “not associated with a container,” but I need to research that for a more precise definition.

Docker pruning commands:

docker image prune      # remove unused, dangling images
docker image prune -a   # remove images not used in containers

docker system prune     # prune everything (the entire system)

docker container prune
docker image prune
docker network prune
docker system prune
docker volume prune

Dockerfile examples

From https://hub.docker.com/r/adoptopenjdk/openjdk11:

# Dockerfile:
    FROM adoptopenjdk/openjdk11:ubi
    RUN mkdir /opt/app
    COPY japp.jar /opt/app
    CMD ["java", "-jar", "/opt/app/japp.jar"]

# You can build and run the Docker image as shown in the following example:
    $ docker build -t japp .
    $ docker run -it --rm japp

From https://hub.docker.com/_/openjdk:

# Dockerfile:
    FROM openjdk:11
    COPY . /usr/src/myapp
    WORKDIR /usr/src/myapp
    RUN javac Main.java
    CMD ["java", "Main"]

# build and run the Docker image:
    $ docker build -t my-java-app .
    $ docker run -it --rm --name my-running-app my-java-app

This snyk.io page has a good Dockerfile example, including best practices, including this:

FROM adoptopenjdk/openjdk11:jre-11.0.9.1_1-alpine@sha256:b6ab0.....
RUN apk add dumb-init
RUN mkdir /app
RUN addgroup --system javauser && adduser -S -s /bin/false -G javauser javauser
COPY --from=build /project/target/java-code-workshop-0.0.1-SNAPSHOT.jar /app/java-application.jar
WORKDIR /app
RUN chown -R javauser:javauser /app
USER javauser
CMD "dumb-init" "java" "-jar" "java-application.jar"

Docker Volumes

TODO: I haven’t worked with these much yet, but this is what I know:

high level:
- create a volume
- create a container
- mount the volume into the container

docker volume prune    # delete all volumes

Create a new volume named vol01:

docker volume create vol01

See your volumes:

docker volume ls

Inspect them:

docker volume inspect vol01

# shows json output
# `mountpoint` tells you where on the host the volume is surfaced
# volumes with the `local` driver get their own directory under /var/lib/docker/volumes

Delete them:

# [1]
docker volume rm <volume-name>

# [2]
docker volume prune
# delete all volumens that are not mounted into a container (or service)
# neither command will delete a volume that’s in use

Example

Goal: create a new standalone container and mount a volume called als_vol

Linux:

docker container run -dit --name container_and_vol \
    --mount source=als_vol,target=/vol \
    alpine

Note: Docker can use an existing volume, and will also create one if you specify a volume that doesn’t exist. In this case, als_vol doesn’t exist, so Docker creates it and mounts it into the new container:

$ docker volume ls
DRIVER    VOLUME NAME
local     als_vol

Now use it:

docker container exec -it container_and_vol sh

echo "Hello" > /vol/file1
ls -l /vol
cat /vol/file1

Delete the container:

docker container rm container_and_vol -f

The volume still exists:

$ docker volume ls
DRIVER    VOLUME NAME
local     als_vol

On a Linux system you can see the Docker volume like this:

$ ls -l /var/lib/docker/volumes/als_vol/_data

TODO: On macOS you need to do something like this, but in January, 2022 this doesn’t work as-is:

screen ~/Library/Containers/com.docker.docker/Data/vms/0/tty
ls -l /var/lib/docker

NOTE: For this section I followed the example in the excellent book, Docker Deep Dive.

Dockerfile commands/arguments

This is a list of commands you can use in a Docker Dockerfile:

#             Comments begin with '#'

ADD           Copy new files, directories, or remote file URLs from into the filesystem of the container

CMD           Allowed only once; if given multiple times, only the last one takes effect.
              The intended command for the image.
              Doesn’t do anything during 'build' time.

COPY          Copy files or directories from a source into the filesystem of the container
              COPY readme.txt /home/al

ENTRYPOINT    TODO: A container that will run as an executable? Or, the primary command of your Docker image?

ENV           Set environment variables.
              ENV CONF_FILE=application.conf HEAP_SIZE=2G

EXPOSE        Tells the container runtime that the container listens on these network ports at runtime
              EXPOSE 5150
              EXPOSE 5150 5151

FROM          Sets the base image (ubuntu, openjdk:11, alpine, etc.)

LABEL         Adds metadata (a non-executable instruction)

MAINTAINER    Sets the author field of the generated images

RUN           Execute commands in a new layer on top of the current image and commit the results.
              Runs during 'build' time.
              Strongly consider using '&&': RUN apt-get update && update apt-get install –y php

USER          Sets the username or UID to use when running the image and commands
              USER alvin

VOLUME        Creates a mount point (path) to external volumes (on the native host or other containers)

WORKDIR       Sets the working directory for any subsequent RUN, CMD, ENTRYPOINT, COPY, and ADD commands.
              If it’s a relative path, it’s relative to the previous WORKDIR.
              WORKDIR /home/alvin
              WORKDIR foo           # results in "/home/alvin/foo"

# NOTE: I haven’t used these yet:
ARG           Defines a variable that users can pass at build-time to the builder  using --build-arg
ONBUILD       Adds an instruction to be executed later, when the image is used as the base for another build
STOPSIGNAL    Sets the system call signal that will be sent to the container to exit

Here’s an interesting Dockerfile example from Accelerating Development Velocity with Docker:

CMD         "Hello, world!"
ENTRYPOINT  echo

The initial definitions in that list came from this PDF: https://design.jboss.org/redhatdeveloper/marketing/docker_cheatsheet/cheatsheet/images/docker_cheatsheet_r3v2.pdf

I also added to them based on my own knowledge, and these books:

Docker on macOS

This section is TODO/TBD.

Where are Docker images on macOS?

used to be here: /Users/al/Library/Containers/com.docker.docker/Data/vms/0/data/Docker.raw

Reporting live from Louisville, Kentucky today,
Alvin Alexander