# Building an infinite group of finites

At this rate, I will regurgitate everything I’ve ever learned, and advance the timeline farther than I have years to claim. I guess it could be worse. Here is the construction of a number system.

First we have elements, and we select them gradually into a growing group: one in one, representing any such class of one elements, and designated with the cardinal number as its size “1.” Then we add a second element and the group grows, and this we represent with the digit-symbol “2.” And we go forever.

Three observations:

1. Each cardinal number is finite. By induction, first 1: there is no part of one element that would be its equivalent. The next (2) is finite because adding one element to a finite group – the group containing one element – does not disturb the property of the new group being finite [1]. So the group II is finite because I is, and III is finite because II is, etc.
2. All cardinals are in this list. We can take a group and mark each element within it, and the last mark will be finite. That would be the cardinal number. If our counting never ended, the group would be equivalent to a part of itself, and therefore would be infinite.
3. No numbers are equal to each other. Any two finite groups are either equivalent or one is less than the second. Our construction assures us the latter, that each group is a part of its subsequent.

# The symbols you hang meaning on

Having to prove if a < b and b < c, then a < c is me staring down a acid-free page and willing the ghost of genius to unlock something profound in the symbols themselves. That’s the first mistake.

These symbols, not even defined until after sets were defined, after cardinal numbers were described, and after equivalence was conceived in English, only represent those meanings before: of the sub-set, of belonging in groups.

Fifty years earlier, an author wrote:

If the first of three groups be a part of the second, and the second a part of the third, then the first is also a part of the third.

# Older books to explain things

Not having a solution manual feels like the demand for garbage collectors baked in to C: it’s the wrong kind of want for the context. It does make it difficult not having a “compiler” for math problems. Here is your input (the problem), but no real sense of the output. Except for proofs, but I could not begin with those.

Actually, there are two methods. One involves a time machine, to collect books from the 1900s. One such is “College Algebra” by Henry Fine. The second is to consult a discrete math textbook that suggests proof strategies. But even that ends with “proofs are an art” and “there is no one way to reach a proof.” The advice is to do more proofs; just as in programming, we have to achieve a certain level of reasoning fluency.

Suppose proofs are actually the specific steps to get from A to B. Could you have not encountered a part of this problem while noodling with the basic concepts before the exercises? The great sin is treating it as a fantasy novel of pure exposition, I guess. But it is difficult to do much when all one knows is printing things to the screen.

# Needs moar widgets

People are not actually interested in wading through code. They like having knobs and an interface. When something breaks, it should be messaged and supported by a Standard Operating Procedure (SOP) or manual. There’s no real time for checking the raw out of a repo and cutting a swath through comments. Welcome to vendor support land.

Abstracting at this level can be a godsend or a curse. You ask yourself, “What kind of tools would I need to maintain this system without having access to source?” That brings up the need for verification, unique run states, and repeatable diagnostics. You may not necessarily have the luxury of one folder in one location or a single process running things.

This is the development of a guy crawling and jumping around the Enterprise’s guts to a Titan piloted by a clone. The level of slickness transcends the plot device. In the big leagues, people invest in custom icons.

# Long string smash

MAC authentication has been pushed as a hotfix for most – if not all – ASP framework versions, so it’s another thing to parse. __VIEWSTATE has become monstrous enough to crash Command Prompt, so there has been an adjustment stage to perl scripts.

I’ve stayed long enough to see my work need maintenance, and it’s become a thorny beast. Don’t Repeat Yourself (DRY) is a faithful idiom for designing programs, not just ones with classes and objects. In this case, following the saying of “never build top-down except for the rewrite,” I may have to codify this knowledge into something engineered.

Being scrappy was fine by me; failing fast and often let me iterate quickly. That’s become a liability in places. A form of mandatory documentation has descended. It would be easier to discuss the theory and the pattern than to describe each script. Actually, that’s an entirely different kind of corporate job.

# Given your life and things

Completing a few screencasts of my primary job function, I gave my viewers a list of assignments:

There’s no real due date to any of it. As a teacher, I think about what would be nice and what would be practical. The second part was easy. The first will make them stretch a little. At one time, I thought my purpose was to train others for better jobs. It was a guerilla mission, code to trickle down into the population. It was a way to stay idealistic.

# Executing Word macros with arguments

It’s one thing to fill out a Word document, but it’s another to use it as a template. I changed all the useful fields into variable names like \$signature, \$restaurant_name, and the like. Right-click on this new version and make it read-only.

You can use cscript not only for automating Excel operations, but operations in Word too. Record a couple macros; at a minimum, Ctrl-F to find text and to overwrite it, and another for inserting pictures. You can generalize these to look for dollar-sign prefixed variables in the template and fill in with values. Be sure to match on the whole word with the Find code.

Microsoft docs mention putting macro code into ThisDocument in order to use parameterized subroutines. I still wanted to use modules. Use the “Application.Run” form of the Run call.

```normaldotm = C:\xxx\Normal.dotm

Set oWord = CreateObject("Word.Application")
Set oDoc = oWord.Documents.Open(normaldotm,,True) ' open Read-only

oWord.Application.Run "HelloWorld", "My name is Fred,3"```

Now that you’ve separated the content from the design, the template can be made pretty. The actual variables can come from a CSV file populated by your favorite GUI-learning project of the week. As plaintext, this can also be committed to a repository or scripted to other places like HTML.

# Output simulation

I had to wait on data. Usually I really do wait, because filling in the empty is hard. Software can’t be cuddled or kissed, but motivation evaporates without something to munge. Today I made it up – not really fake strings, but I used output statements.

```action: do something here
action: do something here
action: do something here```

“Each output statement is an action that will look up the data and send it,” I wrote. A message of near completeness, time spent in worthwhile productivity.

# Corporate config

It remains my naivete to believe “programming” is the sheer and sole element required for success, but that meets reality: people train to support existing products, produced by heavyweight vendors, discrete edges in the nebula of software. These contracts pay and professionals stride proudly in their expertise. My chasing after basics is almost quaint in light of it.

After delusion is a spare space, enough to illuminate shadow, where I have not the right screwdriver to fix the loose bits. That part, the most amenable to psychedelics perhaps, remains my cherished possession: a mix of stubborn, an element of the survivalist, an over-full zeal for decentralized processes (even as I yearn for mentored learning).

“You would have to go into the code and debug it,” I said. “If I’m not here, you’d have to follow the scripts and try each part.”

“No way; we are not developers!”

# Old and older

Some further perversions on the idea of learning: I dug through a bibliography and ordered a few more old books. These approach the mechanics of high school busywork, and maybe there will be some magic concepts therein that prove (ha) this wisdom. I don’t think forever is enough time to clear the stack while the heap keeps growing.

I can’t trust a notebook to order my thoughts. The answers could be lost; the index is not searchable; and I wanted to learn enough LaTeX to make things neat for future me. Recursive projects are the worst.

I don’t like that math has not a compiler. There’s no sense of whether my “syntax” is wrong or right. There are no formal checks. This continues to the present. I go along because this is the convention and harder to argue than feelings on technological preference.