• 1 stick salted butter, room temperature
• 1/2 cup granulated sugar
• 1/2 cup dark brown sugar
• 1/2 tablespoon vanilla extract
• 1 large egg
• 1 1/2 cups graham cracker crumbs
• 3/4 cup all-purpose flour
• 1/2 teaspoon baking soda
• 1 cup semi-sweet chocolate chips

Preparation

1. Preheat oven to 350 degrees Fahrenheit.
2. Run 2 sleeves of graham crackers through the food processor until finely powdered (I’d recommend pulling out any large bits left in the powder but it’s not required if you’re in a rush).
3. Line two cookie trays with parchment paper.
4. Cream the butter and both sugars together until well combined.
5. Add the egg and continue mixing until it lightens slightly, then add in the vanilla extract.
6. Add all the graham cracker crumbs and mix until combined.
7. Add the flour and baking soda and mix until combined.
8. Stir in the chocolate chips.
9. Use a cookie scoop, tablespoon, whatever works for you, and scoop them out onto the parchment-paper-lined cookie sheets (looking at mine, I’d say they’re around 2 tablespoon scoops).
10. Bake for 10 minutes and then check them to see how they’re looking. You want them to start to darken a bit before you pull them out of the oven (for my oven, this takes 12 minutes).

Let them cool, then move them to a plate or a wire cooling rack to further firm up…or just tuck in and start eating, I’m not your supervisor.

Notes You’re probably tempted to add mini-marshmallows to these aren’t you? Don’t do it! Baking with marshmallows doesn’t go the way you’d hope it would and it tends to make a mess and ruin your cookies. If you’re unwavering in your desire for marshmallows in these you have a few options. At the 10-minute mark when you’re checking the cookies out, pull them out of the oven and sprinkle some mini marshmallows onto the cookies, then put them back in for the last bit of baking. Alternately if you want to order some freeze-dried or dehydrated marshmallows, those work great in baking and will likely give you what you’re looking for.

Let’s assume you’re working with two servers. Your primary Nextcloud server has an IP address of 10.200.10.10 and your remote server that you’re using to capture your backups is 10.200.10.20. For ease of use we’ll have both running Ubuntu but the steps to install the Borg binary is accurate in the docs, so this assumption is largely just so you’re working with complete instructions.

On your remote system, install Borg, create a user for borg backups (root is not recommended), and generate an SSH key.

1
2
3
4
5
6
sudo apt-get update && sudo apt-get install borgbackup
sudo useradd -c "Borg Backups" -m -s /bin/bash borg
sudo su borg -
ssh-keygen -o -a 100 -t ed25519
cat ~/.ssh/id_ed25519.pub >> ~/.ssh/authorized_keys
chmod 0600 ~/.ssh/authorized_keys

On your local system you likely already have an SSH key but if you don’t, you’ll need to create one. Copy the contents of the public key into the authorized_keys file you created above. Once that’s done, you’re going to install Borg Backup on your local machine and initialize the repository on the remote host. Let’s assume your backup directory for your files is in /mnt/backup/borg on your remote.

1
2
3
4
5
sudo apt-get update && sudo apt-get install borgbackup
export BORG_REPO=ssh://borg@10.200.10.20/mnt/backup/borg
export BORG_PASSPHRASE=a complex password of some kind or see below for other options
borg init -e repokey-blake2
borg key export borg@10.200.10.20/mnt/backup/borg encrypted-key-backup

Now, connect to your Nextcloud management interface at https://10.200.10.10:8080/containers and stop all the containers. Set the backup target to ssh://borg@10.200.10.20/mnt/backup/borg and start the backup job. This first job will fail, which believe it or not is OK. The UI will display a public key that you need to add to the remote so add a new line to the authorized_keys file on your remote server and paste the public key. It will also show a password to use for encryption which I ended up using as the password for my Borg Backups but I’m honestly not sure if this is required or not. Either way, while you’re on the remote server you’re also going to need to grab a copy of the Borg config file

1
cat /mnt/backup/borg

Take the contenets of the above text and copy it into a new file on your Nextcloud server located at /var/lib/docker/volumes/nextcloud_aio_mastercontainer/_data/data/borg.config. Lastly you’ll want to set the privs on that file appropriately:

1
2
chown www-data:www-data /var/lib/docker/volumes/nextcloud_aio_mastercontainer/_data/data/borg.config
chmod 0770 /var/lib/docker/volumes/nextcloud_aio_mastercontainer/_data/data/borg.config

Now that this is all done, the backups should work and you’re all good to go. You only have to do this for the first backup job and afterwards the scheduled cron jobs should take care of things for you. I hope this helps someone else as I banged my head against this for ages.

I was gifted a Vitamix by my parents which is such a huge boon if you’re making homemade dairy alternatives and I wanted to share my coffee creamer recipe.

• 500 ml cold, filtered water, divided
• 200 grams raw, unsalted cashews
• 1 teaspoon vanilla bean paste or 1 vanilla bean
• 25 grams white sugar
• 1 pinch of salt
• 1 pinch of baking soda / bicarbonate of soda

1. If you’re using a Vitamix, skip to step 2. If not then put the cashews in a container, fill it with water (with enough room for some expansion), and allow cashews to soak overnight.
2. Drain the cashews if you’re using soaked cashews. Add 250 ml of water and the raw cashews to the blender along with the sugar and pinch of salt.
3. If you’re using a vanilla bean, slice the vanilla bean pod lengthwise and scrape the seeds with the edge of your knife and then transfer them to the blender. Otherwise just add the vanilla bean paste at this stage.
4. Blend on high for 8-10 minutes in a normal blender or about 5 minutes in a Vitamix. The goal is to have a completely smooth and creamy mixture.
5. Turn the blender to low and slowly add in another 250 ml of water. Blend until combined.
6. Check the consistency of your creamer to see if it’s to your liking. If you’re looking for the consistency of storebought cashew coffee creamer, you’ll want to add an additional 250 ml of water for a grand total of 750 ml of water. My personal preference is 500 ml total of water which makes for a rich coffee creamer that’s closer to a half-and-half if you’re comparing this to dairy.

If you use a Vitamix to make this you may want to wait until your mixture has sat overnight in the refrigerator before deciding if you want more water, more sugar, etc. 5 minutes in a Vitamix is enough friction that it will start to heat a little and it’ll taste different warm than it will when it’s cooled down.

Store the creamer in airtight jars in the fridge and shake it well before using as the vanilla beans tend to settle to the bottom. You’ll want to use this up in around 10 days, give or take, as there’s no preservatives in this so it’ll eventually turn to the dark side (as in it will mold and you’ll have an awful-tasting cup of coffee on your hands and no one needs that kind of negativity in their life).

Cheese Sauce

• 8 ounces (227 grams) extra sharp white cheddar (buy a brick of cheddar and shred it yourself, trust me on this one)
• 1/2 stick (57 grams) unsalted butter
• 1/4 cup (32 grams) All-Purpose flour
• 2 cups (475 ml) milk (I use low-fat milk but anything other than skim is fine)
• Salt and pepper to taste

1. Start your pasta of choice cooking while you work on the sauce, or if you’re not a speedy cook you’ll want to get the sauce prepped first so you can get the freshly cooked pasta into the sauce as soon as it’s ready. I like the classics so I generally use good quality elbow macaroni, but really anything that holds the sauce well will do nicely. If you’re looking for suggestions - shells, penne, and rigatoni are all excellent options. You’ll need a pound (453 grams) of pasta for this recipe.
2. Melt the butter over medium heat, don’t allow it to brown
3. As soon as the butter is melted, add the flour while whisking to avoid making lumps. You’re looking for a smooth, pale roux.
4. Let the roux cook for 2-3 minutes, you’re not looking for any color, you’re just looking to not have raw flour in your sauce.
5. Pour the milk in all at once while whisking vigorously. I know, a lot of folks will have you warm it first, drizzle it, etc. It’s not needed, I promise, just whisk it while you pour and you’re good to go.
6. Let this cook for 4-5 minutes on medium heat until it starts to bubble and thicken, whisking it frequently.
7. Once it is thickened slightly, add all of the shredded cheese at once and cook the sauce until the cheese is fully melted and incorporated
8. If you have enough room in your saucepan, add the pasta to the pan with your cheese sauce and stir just until everything is well coated. If not, add the pasta to a large bowl and pour the sauce over it and do your stirring there.
9. Enjoy! Let me know what you think or what spices/cheeses/flavors you add to yours to make it your perfect mac and cheese.

Notes

1. If you end up with lumps in either the béchamel or the mornay, don’t panic. You can generally fix this by using an immersion blender. If you don’t have one, a regular blender will work just fine, just work in batches since the liquid will be hot.
2. Other cheese work great here, especially parmesan and gruyere. You can also combine multiple types of cheeses for your own flavor profile.
3. This will make a fairly thick cheese sauce which not everyone likes, so you’ll want to add more or less milk to the cheese sauce to get it to the consistency you like. Just don’t make it too thin or it won’t really adhere to your pasta.
4. Too much fat and too little fat from your dairy are going to lead to not great results. You can definitely do this with whole milk or evaporated milk if you want a very rich sauce. Skim milk tends to make the sauce watery and the mouth feel is off. Conversely, half and half or heavy cream would give you an unholy marriage of a pudding and a cheese sauce that will be way too fatty for anyone to really enjoy. Low-fat milk is my family’s preference but you do you my friend, it’s your sauce now.
5. You can make this vegan and it’s pretty fantastic. I recommend using rice milk for the béchamel, along with vegan margarine. If you go this route, you’ll want to increase the margarine and flour to around 6 tablespoons of each as rice milk has very little, if any, fat content. Other milks can work but their flavors might take over and rice milk is neutral which is why I use it. For the cheese substitute, you’ll want to use something that melts like Daiya shreds. Just bear in mind that this sauce is much more likely to break on you and frequently requires a blender to make it smooth so I’d recommend having one on hand if you’re going the vegan route.
6. For storing the leftovers (if there are any) I’d recommend thinning the sauce slightly with a bit of milk before putting it away. It just makes separating it later a lot easier. To reheat it, put a little milk in a sauce pan along with the leftover noodles and gently swirl it around in the milk over medium heat. It’ll start to break apart your brick of noodles and melt back into a sauce. Because you’re diluting it with milk you might need to add a little more cheese and a little more salt to get it back to the same flavor profile again but the consistency is almost perfect. Microwaves and dairy tend to not mix well unless you’re super careful so I tend to do this on the stove but again, you do you.
7. You definitely can use pre-shredded cheese but there’s the possibility it will mess with the consistency of the sauce. Bagged cheese comes coated with a starch to keep it from clumping which also acts as a thickener when it’s added to a sauce. If you do decide to use pre-shredded cheese, just add a little more milk to compensate for the additional starch.

During the 2016 - 2020 presidency, I made it about halfway through before I had to put a moratorium on checking the News daily. Reading the News became exhausting. That was when there was little progression of these terrible ideologies because of the rampant incompetence of the president and the incompetency of those with whom he chose to surround himself. Now it’s seeming like bigotry has united these forces and while they’re still incompetent, they’re managing to succeed and people I care about are losing their right to live as they choose.

So here we are on a Friday. It’s been 88 days, 10 hours, 44 minutes (at the time I am writing this) since we started round two of the American dumpster fire and I’m already exhausted by all of this. I’m terrified that November of last year represents the last time my vote was counted in the United States. I’m terrified that I might have to move. I’m terrified that by the time I decide it’s gone too far that I won’t be able to move and that my family and I will be stuck trying to survive in an increasingly hostile environment.

I say all that recognizing that I’m not even among the first targets. I’m white, cisgender, middle-aged, reasonably well off, reasonably well paid, etc. My team at work though, I’m terrified I’m going to lose them. Only one of them has a green card and the rest are here on H1B visas. I’m terrified they’ll go home to renew their work visa and will not be allowed back into the US. I’m terrified that as progressive as my company is that they’re still a business and that if there’s substantial money to be made by following the hateful ideologies of the current presidency that they’ll forget how progressive they are and cave to those demands. They’ve shown no sign of that, they say the right things, and above all they have a history of supporting progressive initiatives well before they existed as buzzwords and talking points.

I try to remain hopeful and focus on the wins. But we’re not even a hundred days in and I’m exhausted. I hate this. I will continue to fight and resist until I can’t any more. I will likely try to make myself feel better by playing mindless video games, eating food that’s horrible for me, and looking at photos of adorable baby animals until I feel like the world is going to be OK and that we’re going to come through the other side of this and things will improve.

But I’m still terrified.

That’s what’s on my mind.

Oooo! Are We Using Alpine Linux?!

Sorry my friend, but I generally don’t use Alpine Linux and it largely boils down to musl. Alpine implemented its own C standard library called musl which is lighter weight than glibc (which is what most of the Linux OS that have been around longer are using). I’ve run into numerous issues with code throwing segfaults on Alpine but compiles perfectly fine on Ubuntu, Debian, RHEL, etc. I’m not here to poo-poo anyone’s OS choices, and Alpine is a really great lightweight OS. All that said, it’s been the source of enough problems for me personally though that I stopped using it and went back to using Debian-derivatives.

So what’s the plan then?

I thought I might walk you through how to build your own Docker container that you can then leverage to build your static Jekyll site. If you want to skip straight to the code you can head over to my GitLab Repository to poke around.

Building the Docker image

If you strip everything else out of my code repo that isn’t documentation-related, you’re left with just a Dockerfile and a GitLab pipeline. If you want a good intro on writing a Dockerfile, the Docker Docs has a great intro. But let’s pick apart mine:

1
2
3
4
5
6
7
8
9
10
11
12
FROM debian:bookworm AS base
RUN echo 'APT::Install-Suggests "0";' >> /etc/apt/apt.conf.d/00-jekyll-builder
RUN echo 'APT::Install-Recommends "0";' >> /etc/apt/apt.conf.d/00-jekyll-builder
RUN DEBIAN_FRONTEND=noninteractive apt-get update
RUN DEBIAN_FRONTEND=noninteractive apt-get upgrade -y
RUN DEBIAN_FRONTEND=noninteractive apt-get install -y ruby-full build-essential curl rsync openssh-client git
RUN curl -fsSL https://deb.nodesource.com/setup_22.x -o nodesource_setup.sh
RUN bash nodesource_setup.sh
RUN DEBIAN_FRONTEND=noninteractive apt-get install -y nodejs
RUN gem install rubygems-update
RUN update_rubygems
RUN gem install jekyll bundler

Line by line I’m doing the following:

1. Telling Docker that I want to use the current (at the time of this article) version of Debian, which is Debian Bookworm as my base image. This pins me to that version of Debian but will continue to pull newer versions of Bookworm as that tag is updated
2. Setting APT to not install suggested packages as we’re trying to keep things as small as possible.
3. Setting APT to not install recommended packages as we’re trying to keep things as small as possible.
4. Running apt update but telling it that this is a non-interactive shell (since I’m running in a pipeline).
5. Running apt upgrade but telling it that this is a non-interactive shell (since I’m running in a pipeline).
6. Install the needed apt packages for Jekyll.
7. Download the current (at the time of this article) repo setup script for the LTS version of NodeJS.
8. Run the NodeJS repo setup script.
9. Install NodeJS.
10. Install the rubygems-update package so I can pull any critical updates to gems more easily.
11. Install Jekyll and Bundler

Running the GitLab Pipeline

The pipeline now takes the Dockerfile, builds it on a runner, and then pushes it to Docker Hub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
---
stages:
  - build

default:
  image: docker:28
  services:
    - name: docker:28-dind
      variables:
        HEALTHCHECK_TCP_PORT: "2375"
  before_script:
    - docker info

variables:
  DOCKER_HOST: tcp://docker:2375
  DOCKER_TLS_CERTDIR: ""

build:
  stage: build
  tags:
    - shared
  allow_failure: false
  rules:
    - if: $CI_COMMIT_BRANCH == 'main'
  before_script:
    - echo ${DOCKER_PAT} | docker login --username ${DOCKER_USER} --password-stdin
    - docker info
  script:
    - docker build -t "${DOCKER_USER}/${DOCKER_PROJECT}" .
    - docker push "${DOCKER_USER}/${DOCKER_PROJECT}" 

In this case since I am using a runner that is installed in a Kubernetes cluster, I need to use both the docker image as well is the “Docker In Docker (DIND)” image as well. So the front matter sets the port the system can use to verify a Docker Engine is available and then the rest is the build pipeline. This says if you push to the main branch, login to the Docker Hub using a PAT, pull Docker Info to record the version information as spew, and then move on to building. The build is all of two commands - build the container, push it to the Hub. This setup will keep a “latest” version constantly moving forwards, however best practices should have you tagging your images with version information. Because this was a simple tool I was building just for my own use (and to write this article) I did not do so, but there are many articles out there on tagging taxonomy for your Docker images that I strongly advise you follow if you plan to implement anything like this in a production capacity.

Prerequisites

First, you’ll need a user that can SSH into your hosting directory:

1. Login to your Dreamhost Panel
2. Click Websites -> Manage Websites -> “Manage” (next to your site URL) -> Content -> Login Info
3. Make sure “Secure Shell Access” is enabled for your user (change the password if you’ve forgotten the login info or never logged in this way before)
4. Login as the user and create an SSH key you’re going to use for your GitLab pipeline

   1
   2
   3
   4
   5
   6
   mkdir -p ~/.ssh
   ssh-keygen -q -t ed25519 -C "GitLab Dreamhost Pipeline" -f ~/.ssh/id_ed25519 -N ''
   cat ~/.ssh/id_ed25519.pub >> ~/.ssh/authorized_keys
   chown 0600 ~/.ssh/authorized_keys
   cat ~/.ssh/id_ed25519
   cat ~/.ssh/id_ed25519.pub
   

5. Now you’ll want to set these up as files in your GitLab pipeline so head over to your GitLab project and click Settings -> CI/CD
6. Expand “Variables” and create the following variables of type “File” with the following contents
   • Key:ssh_key_private, Value: Results of cat ~/.ssh/id_ed25519
   • Key:ssh_key_public, Value: Results of cat ~/.ssh/id_ed25519.pub
   • Key:ssh_user, Value: Your Dreamhost SSH user you used to access the system and run those commands

The Pipeline

The pipeline itself is pretty simple. At this point you’re just trying to rsync data from your runner to your Dreamhost server. Let’s say you’re using this to push your static Jekyll website onto the server (since that’s what I’m using it for). There are a lot of ways you can make the below pipeline faster and more elegant but I tried to write this in a way that someone new to this might understand, so I’m sacrificing speed and efficiency for ease of both reading and understanding. Let’s just cover the actual pushing of the data itself, though for best practices you’d want to have other stages to your pipeline that perform checks and have this run when merging your data back into your ‘main’ branch. I’ve added echo commands into the pipleine so you’ll understand what each piece is doing but just shoot me an email or look me up on Mastodon if you have questions, I’m always happy to help folks.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
---
stages:
  - deploy

variables:
  SERVER_NAME: "<replace with your server name>"
  RSYNC_USER: "${ssh_user}@${SERVER_NAME}"

deploy-site:
  stage: deploy
  image: ubuntu
  allow_failure: false
  rules:
    - if: $CI_COMMIT_BRANCH == 'main'
  before_script:
    - echo "First running apt to update inside the container and then install a few essentials needed for the data..."
    - apt-get update
    - apt-get upgrade -y
    - apt-get install -y curl git-all build-essential gcc jq python3.12-venv python3.12 openssh-client rsync
    - echo "Using homebrew as an easily understandable method to install programs into user context..."
    - /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
    - echo >> /root/.bashrc
    - echo 'eval "$(/home/linuxbrew/.linuxbrew/bin/brew shellenv)"' >> /root/.bashrc
    - eval "$(/home/linuxbrew/.linuxbrew/bin/brew shellenv)"
    - echo "Installing gcc, NodeJS, and Ruby using Homebrew..."
    - brew install gcc ruby node
    - echo "Now we're mirroring what your SSH directory likely looks like on your server and we're copying files to where they would normally live..."
    - mkdir -p ~/.ssh
    - chmod 700 ~/.ssh
    - cp ${ssh_key_private} ~/.ssh/id_25519
    - cp ${ssh_key_public} ~/.ssh/id_25519.pub
    - echo "Disabling host key checking so we don't have to worry about popups related to trusting a new connection..."
    - echo -e "Host *\\n\\tStrictHostKeyChecking no\\n\\n" > ~/.ssh/config
    - echo "Fixing the permissions on the SSH files so your SSH Agent doesn't kvetch about it..."
    - chmod 0644 ~/.ssh/id_25519.pub
    - chmod 0400 ~/.ssh/id_25519
    - chmod 0600 ~/.ssh/config
    - echo "Lastly we're adding the keys to the SSH Agent and telling it to test the connection to your Dreamhost server" 
    - eval $(ssh-agent -s)
    - ssh-add ~/.ssh/id_25519
    - ssh-keyscan ${SERVER_NAME}
  script:
    - echo "We're in the home stretch now, just setting the paths for gems to install..."
    - export GEM_HOME="$HOME/gems"
    - export PATH="$HOME/.local/share/gem/ruby/3.4.0/bin:$PATH"
    - echo "Installing Jekyll and Bundler as we need those for the Jekyll build"
    - gem install --user-install jekyll bundler
    - echo "Some Jekyll themes also require you build your NodeJS files as well so this is needed on mine but might not be on yours..."
    - npm install
    - npm run build
    - echo "Almost there, just building the site with Jekyll..."
    - bundle install
    - jekyll build
    - echo "And last but not least, we push the contents of your _site folder to your Dreamhost server using rsync..."
    - rsync -ave ssh ./_site/ ${RSYNC_USER}:/home/${ssh_user}/${SERVER_NAME}
    - echo "We're done!"

Next Steps

This is pretty bare bones and like I said you would probably want to have other stages to this that run for your unprotected branches to test your code and make sure you’re not doing anything potentially unsafe with it. There are also tons of ways to make this faster and more efficient like using the Alpine or Jekyll images that are provided by GitLab but like I said, I wanted folks who are new to this process to understand it and Ubuntu is what a lot of folks are using when they get started in their Linux journey. I hope this helps a few folks but like I said above, if you have any questions then feel free to shoot me a message and I’m happy to answer whatever questions I can.

I feel the need…the need for speed!

It’s pretty slow right now isn’t it? Like I said, I sacrificed a lot of speed and efficiency to make the nuts and bolts of this easier to understand and I find Ubuntu seems to be where folks new to Linux tend to land. But let’s head over to Part Two and see what we can do about that.

That’s right, I’ve joined the cool kids club and rebuilt the site using Jekyll. I’d been wanting to redo this as a static site for a long time now but hadn’t taken the time to do so. But I ripped the bandaid off and tore it all apart and here we are, back and good as new. I’ll be slowly pulling in the posts from my old site over the next few weeks but the look and feel of the site will largely remain like this.

Bagel Recipe 2 teaspoons of active dry yeast
1 ½ tablespoons of granulated sugar
1 ¼ cups of warm water
4 cups bread flour
1 ½ teaspoons of salt

1. Add the sugar to the water, stir to dissolve then add the yeast. Let it sit for five minutes until the yeast has activated.
2. Add everything else. Beat in a stand mixer with a dough hook attachment for 10 minutes
3. Remove the dough from the bowl, oil it lightly, then return it to the bowl and let it rise for one hour
4. Cut the dough into 8 equal pieces. Shape them into rounds, then use your finger to make a whole in the center and stretch it until you have a roughly bagel shaped piece of dough
5. While doing this, start a pot of water boiling. Let the dough rounds stand for 20 minutes covered in a warm place
6. Preheat the oven to 425ºF. Boil each of the bagels for two minutes on each side (as many as you can fit in the pot comfortably)
7. As soon as you remove them from the water, sprinkle them with the seasoning mixture. Do it quickly as they dry out fast and you need the moisture to make it stick.
8. Bake them for 20 minutes

1. Mix 1 tsp baking soda with 1 cup sour cream and set aside
2. Blend 1 stick of butter (softened to room temperature) with 1 cup of white sugar until creamy
3. Add 2 eggs, one at a time, to the bowl while the beater is running
4. Add the seeds from 3 vanilla beans, and 1 tsp. vanilla and blend well
5. Into the wet mixture sift 1 1/2 cups cake flour and 1 1/2 tsp baking powder and fold in gently just to start it combining. I used five or six folding stirs to get this going
6. Fold in the sour cream mixture, trying to leave as much air in the mixture as possible
7. Bake in two 8-9 inch round cake tins, that have been buttered and floured, at 350 degrees for 20-25 minutes