A month or two ago, I watched a bunch of videos of Uncle Bob speaking at various conferences. He’s thought a lot about what makes code testable and maintainable, and he’s an excellent speaker. I’ve even paid to watch some of his hour-ish videos at his Clean Coders site.
In Clean Code, Episode 3 – Functions, he makes the case that we should be striving to keep each function under five lines long. So, over the past month or so, I’ve been trying this out in all of my Scala and Lisp endeavors.
Once you get each function down to four lines or fewer, you start running into symbol-proliferation. You pretty much throw out (LABELS ...) and (FLET ...) unless you need the closure (and then try to say that when you can’t that it’s good enough to just keep the subfunctions under five lines and the body under five, too). You create bunches of functions that should never be called anywhere except the one place it’s called now.
Enter Package Proliferation!
Then, I remembered some Lisp coding style guidelines that I read early this year sometime. Those guidelines advocated having one package for each Lisp file and explicitly making peer files have to import or qualify symbols used from other peer files. This will help me with the symbol-proliferation! Let’s do it!
Enter File Proliferation!
After two weeks of that, I woke up yesterday morning realizing that I wasn’t getting the full benefit
from this if I was exporting more than one symbol from each package. If keeping each function tiny is Good and limiting a package to one file is Good, then it is certainly Bad to have one file’s package exporting eight different functions.
So, today, I reworked all of the UNet that I wrote in the last couple of weeks to have one package per file and as few exported symbols per package as possible.
In the interest of testability and modularity, I had broken out a subpackage of UNet called UNet-Sockets that is to be the interface the UNet library uses to interact with sockets. I had realized that I had a file called methods.lisp with four different publicly available (DEFMETHOD ...) forms in it. Now, each is in its own file and package. I did the same for various other declarations.
Now, there is a top-level package which uses Tim Bradshaw’s Conduit Packages to collect all of the symbols meant to be used externally from these packages. If there is an exported function in a package, that is the only exported symbol in that package. If there is an exported generic function declaration in a package, that is the only exported symbol from that package. If there is an exported method implementation in a package, there aren’t any exported symbols from that package. If there is an exported condition in a package, that condition and its accessors are the only exported symbols from that package. If there is an exported class in a package, that class and its accessors are the only exported symbols from that package.
Example
The top-level package of the UNET-SOCKETS system, that defines the interface that UNet will use to access its sockets, consists of just a (DEFPACKAGE ...) form. You can see the full package on github in the unet-sockets.asd and the sockets/ directory.
(:use :cl)
(:extends/including :unet-sockets-interface
#:sockets-interface)
(:extends/including :unet-sockets-base-socket
#:base-socket)
(:extends/including :unet-sockets-hostname-not-found-error
#:hostname-not-found-error
#:hostname-not-found-error-hostname)
(:extends/including :unet-sockets-get-address
#:get-address)
(:extends/including :unet-sockets-address+port-not-available-error
#:address+port-not-available-error
#:address+port-not-available-error-address
#:address+port-not-available-error-port)
(:extends/including :unet-sockets-create-datagram-socket
#:create-datagram-socket)
(:extends/including :unet-sockets-send-datagram
#:send-datagram)
(:extends/including :unet-sockets-poll-datagram
#:poll-datagram))
Conclusion?
The jury’s still out on this for me. On the one hand, the self-flagellation is an interesting exercise. On the other hand, if I’m going to have to export everything useful and import it in multiple places then I’m taking away some of the fun. I feel like I’m maintaining C++ header files to some extent.
I think I’ll keep it up for the UNet project, at least. It makes good documentation to have each exported symbol in a package and file named for that exported symbol. You can open up any file and read the three-to-four line exported function in it. You can see, right there with it, any supporting function it uses that no other files need to use. You can see from the (DEFPACKAGE ...) form at the top where any other supporting functions came from. And nothing else is cluttering up the landscape.
We’ll see if I develop religion on this topic. At the moment, I think it’s eventually going to fall into the moderation in all things bucket. Time will tell.
-th column (or row) (for 
) represents 
for some generator 
. As such, the multiplication table is simply 
in the zeroth row and column and 
for the spot 
.
on the right and 
on the left. They make as decent a stereo as any of the other pairs so far.
for various 
are convenient in computer applications because of how nicely they fit into bytes or words on the machine. The Galois field 
has 
. It has 
elements. They are (as binary integers) 
, 
, 
, 
, 
, 
, 
, and 
. The element 
. The element 
.
. That means that 
, 
, 
, and 
. In computer terms, 
is simply 
. That means, to get the integer representation of the sum of two elements, we simply have to do the bitwise-XOR of their integer representations. Every processor that I’ve ever seen has built-in instructions to do this. Most computer languages support bitwise-XOR operations. In Lisp, the bitwise-XOR of 
. But, if we did 
, we’d end up with 
. We wanted everything to be polynomials of degree less than 
(which is 
in our binary scheme). Now, we need to take our products modulo this polynomial.
by a polynomial of degree 
and divide it by the polynomial 
, we start by writing it as:
to start with 
, we need 
to start with 
. We then proceed to subtract 
and then figure out that we need a 
for the next term, and so on. We end up with 
with a remainder of 
(a degree zero polynomial).
. [Note: addition and subtraction are the same in 
might look something like this to multiply 
-th row and 
-th column is the sum (in the Galois field) of 
times a degree 7 polynomial.
and table 
, then we need an invertible function 
such that 
for all 
, 
, 
. There are only 
so that 
in 
, then we simply have that 
. For non-zero 
.
elements. The number 
). So, immediately, we know that all of the subsets we generate are going to have an odd number of items in them. For 
form a subset containing 51 elements, …, the powers of 
form a subset containing 3 elements, and the powers of 
form a subset containing 1 element. Further, if both 
and 
will have the same number of elements in their subsets for all 
that 
to verify the whole field structure is the same.
was at the top and the powers progressed around the circle and then drew a polygon connecting consecutive points, then consecutive points in the 
