cl-cookbook | The Common Lisp Cookbook | Learning library

You need to tell Lisp which package to use. In standard Common Lisp it is unspecified which packages to use. SBCL uses none. If you want symbols of the package CL to be available, you have to explicitly use that package.

Package JANE

• Method-generic-function gives you the generic function that the given method is associated with.
• Method-generic-function is not imported into the cl-user package in SBCL. You will find it in sb-mop (so, sb-mop:method-generic-function). The MOP is not entirely incorporated in the Common Lisp standard.
• For portable use of the entire MOP, use the library “Closer to MOP” (closer-mop).
• In the REPL, * refers to the first return value of the last evaluated expression. In your case, that was the list of methods returned by generic-function-methods. So you see that these two are more or less inverse functions in this one-to-many relation.

Reader macros for libraries typically need to be enabled explicitly.

According to the RELEASE-NOTES:

You can use SERIES::INSTALL for "use-package"ing Series in a way that extended special forms are shadow-import'ed and reader macros are installed.

I'm not sure why that is not exported.

I have not yet found a named-readtables definition for series, but I'd guess that someone has done that alredy.

You need to install the qtools system.

• A system is a way to organize software libraries
• A package is a namespace

The two are theoretically unrelated. But often, when you load a system X, it defines a package named X.

In some cases (like qtools) there are many packages for one system, for example because the system wants to define different levels of API.

Another way to define multiple packages when loading one system comes from the fact that ASDF version 3.1 supports an extension copied from other build systems named package-inferred-systems, where each source file is implicitly mapped to one system and one package.

Here is a snippet of what Quicklisp shows when installing qtools:

Slot names are symbols, so the package matters when using SLOT-VALUE / WITH-SLOTS. In this case the references slots appears to be named by an internal symbol in the package MITO.CLASS.COLUMN.

The inspector doesn't show the package name (because it's rarely needed), but you can see that the slot definition is of type MITO.DAO.COLUMN:DAO-TABLE-COLUMN-CLASS, so you can use CLOSER-MOP:CLASS-SLOTS to find the slot definition:

The reason you get this is because of the nature of the TCP protocol: the connection is in a state called TIME-WAIT in the TCP state machine described by RFC793. A diagram of the state machine is on page 23 of RFC793.

The interesting bit of the state machine is when one end (who I'll call 'you') wants to close the connection – this is known as an 'active close', and in this case it's what you are initiating by the socket-close calls. I'll call the other end 'them'. The normal sequence of events for an active close is:

1. you send them a FIN packet;
2. they ACK your FIN and send in turn a FIN;
3. you ACK their FIN.

Now it's important to remember that any of these packets (their ACK and FIN are the same packet usually and I think always) can get lost, and the state machine needs to recover from this.

There's one particularly interesting packet which is the last ACK: it's particularly interesting because it's the last packet ever sent, which means that you have no way of knowing whether it reached them.

So consider the situation from both ends

From their end: they've sent a FIN and are waiting for your ACK for it. Now:

• either the ACK arrives in due course, in which case they know everything is wound up and they can dismantle everything involved in the connection.
• or, after waiting for the prescribed time, the ACK doesn't arrive, so they must assume that either their FIN was lost or your ACK to their FIN was lost, and so they must resend the FIN and go back to waiting for the ACK.

From your end: you've got their FIN and have sent the last ACK. But you have no idea whether that ACK ever got to them. So you wait for a prescribed time in order to give them a chance to realise that the ACK did not get their and resend their FIN. During this wait you can't dismantle the connection, because at any point you may get another FIN.

This waiting state is known as TIME-WAIT, and during it the endpoint of the connection can't be reused. And this is the problem you are seeing.

You need to sit in TIME-WAIT for twice the maximum segment lifetime (MSL): the MSL is how long a packet can be expected to sit in the network.

There are other waiting-states which can occur prior to TIME-WAIT of course, if earlier packets get lost. But TIME-WAIT is the only one which always occurs.

TIME-WAIT is often called TIME_WAIT due to languages which can't handle hyphens in names.

• The splice-arglist helpers are not needed at all (so I'll also skip details in them). Use apply in your thread function instead:

Let's reverse engineer the problem. Understanding the efficient processing of the "dependency-chain" of image[][], image_height, image_width, a, b

given the defined code, there could be just a single loop, thus with reduced overhead costs and best with also maximising cache-aligned vectorised code.

Cache-Naive re-formulation:

With Osicat, you call stat on the file and you get a bunch of things in a structure: