The On-Line Encyclopedia of Integer Sequences
!
That's a rabbit hole to fall down.
Very much so.
But to tie it to this particular thread, one doesn't need a PhD in mathematics to find it very useful.
For example, given two perfect binary search trees,
with \$n = 2^{N-1}\$ to \$n = 2^N - 1\$ nodes (i.e., depth of the tree is \$N\$, \$N = 3\$ in the above illustration), we have
$$\begin{aligned}
i(k, N) &= \left( k - 2^{\lfloor \log_2 k \rfloor} \right) 2^{N - \lfloor \log_2 k \rfloor} + 2^{N - \lfloor \log_2 k \rfloor - 1} \\
k(i, N) &= \frac{\operatorname{b}\left( i + 2^N \right) - 1}{2} \\
\end{aligned}$$
where \$\operatorname{b}(x)\$ divides integer \$x\$ by its largest power of two factor (and for nonzero positive \$x\$ is always odd), i.e. right-aligns the nonnegative integer binary \$x\$.
It turns out that \$\operatorname{b}(x)\$ is
OEIS A000265, \$i(k, N)\$ are subsequences of
OEIS A131987, and \$k(i, N)\$ are subsequences of
A101279.
Similar to using different version control systems, I can use OEIS as a different reference for these sequences, and refer to them in the documentation, instead of spending a couple of thousand words explaining exactly how the formulae work. (I also have unit test programs that verify the sequences and orders both using the formulae above, as well as via brute force (re-sorting monotonically increasing sequences of integers), that can be easily amended/converted into microbenchmarks if needs arise.)
In a scientific/engineering organization, that would probably be appreciated, since it makes citations and peer review easier. In a software house (that only uses the above to speed up access to very large (storage, not in-memory) pre-prepared binary search trees by collecting groups of levels into a single sector, enabling optimum caching patterns, the OEIS references are wasted effort, and the formulae plus the unit tests are better fit to the workflow to prove their fitness for purpose and as documentation to other developers. (Maybe one might add one-liners with the OEIS links as a courtesy of interested developers, but as a footnote only.)
I definitely don't have the math-fu to attack integer sequence problems in general –– heck, I rely on Maple, Sagemath, Maxima for my symbolic math needs, and can barely do calculus on polynomials; I have no hope of remembering outhand any special functions or their behaviour, just like I use man pages for standard C library interfaces, because I just don't trust my memory to remember the nitty details correctly by rote ––, but I know
enough to use them, and where to look for deeper details if need be. Similarly, I'm definitely not a
git power user; I only know enough to fulfill my own needs. I've just "kept my eyes open" for different patterns that projects that seem to work well (complaints about the workflow concentrated on human goofs, not technical issues), and for patterns that seem to lead to issues; and above, I've tried to describe how those projects I've seen use git efficiently, especially tags and branches.
So, I don't think one needs a proverbial PhD in git to use it effectively.
Yet, simply porting ones workflow from one VCS to git is unlikely to be very effective. Workflow efficiency does depend on the tools you use. In my opinion, git is one of those tools you want to first look around at how others are using it, and evaluating their patterns based on how well it seems to work, and how well it could be adapted to ones own use. This is because it does not have any specific work flow it is designed to adhere to.
Therefore,
real-world experience is much more valuable than theoretical in-depth knowledge about these tools.
The same seems to apply to quite a few Unixy tools as well.
awk and
make are excellent examples of this: even simple templates can be tremendously useful, if you know the basic idea and operational principles (like rules for makefiles, and record-based rules and field-based access in awk), examine well-working scripts (as well as avoid patterns that you see in not-so-well working ones), and just consult the manuals for further in-depth details without trying to memorize anything. I've written/edited at least a thousand Makefiles along the years, and I still cannot remember whether to use $^ or $< when I want all prerequisites or only the first prerequisite. I consult the manual for such. (And I'm pretty fast at it, too: it takes less time than me babbling a normal social sentence out loud.)
I also do not memorize any of the more complex git commands shown in my previous posts. I use shell aliases and/or functions (if specific to some workflow or task, sourced via a helper shell script), or plain shell scripts in $HOME/bin (which is first in my $PATH, thus preferred over other locations in $PATH). Many of them contain just the shebang line (
#!/bin/bash or
#!/bin/sh or
#!/bin/dash, depending) and a single
exec command... "$@" ... line.
Home
Help
Search
Login
Register
