duf | Disk Usage/Free Utility - a better 'df ' alternative | Command Line Interface library

Further inspection of the host showed that the java application in the target container was holding a lot of tcp sockets.

After fixing the above, the connection issue did not occur any more. Presumably we hit a limit on the amount of open sockets a container can have.

Just quickly skimming the MATLAB C++ API doc, it looks like you can do this using the matlab::engine::MATLABEngine::feval interface found here:

https://www.mathworks.com/help/matlab/matlab_external/cpp-mex-api.html?searchHighlight=fevalAsync&s_tid=srchtitle#mw_723048ca-e22f-4bfb-aa12-47b8007da774

I.e., pass your function name into the C++ mex file as a string which you can get from the ArgumentList via the matlab::data::CharArray syntax:

Inserting the constants, the equation becomes

The main point to keep in mind is that you have to create 2D arrays of the velocities of the vectorfield U, V by using the meshgrid np.mgrid. Use the code below as a starting point and don't forget to play around with the options of streamplot.

I think that you feel that a lot of what you are seeing is “garbage” just because you do not yet know what it is.

• In line 9 and 8, you see the functions that the REPL is using to handle your input. At this stage, the input is a string, as you can see.
• In line 7, there are some bindings put on the stack, so that the right package is used, and * to *** are bound to the last results (a handy feature for a REPL).
• In line 6, call-with-listener is probably establishing that output should go to Sly.
• In line 5, this anonymous function is the one contained in the closure that has been an argument on line 6. In other words, an implementation detail.
• In line 4, the retry restart is established. This frame is where control would be transferred if you invoked the Retry restart in the debugger.
• In line 3, you again see a function argument being executed. Note the call-with-… naming convention.
• In line 2, you see that your input has been read, i. e. transformed into a lisp datastructure. It is now evaluated with the standard function eval.
• In line 1, you see how SBCL does that in this case — an implementation detail.
• In line 0, you see some anonymous function, again something that comes from evals implementation.

There is not much to see here, because the first thing eval does is to evaluate duf, which fails.

The computer has no idea which part of the current stack context you are trying to debug. It therefore must show you the entire backtrace, or suffer the wailing of people that got the information withheld they were interested in.

What you need to learn is to recognize where the stuff you are interested in starts. Here, all that Slynk stuff (obviously?) is below your context, so you really only need to look at the part until the first eval line. In this case, that's just the first line, which makes sense, because the line you entered simply fails at the first lookup. For a Sly developer, those lower stack frames might be interesting.

Of course, in more realistic scenarios, there are some implementations that have more legible backtraces than others. That's not something Sly can do something about. What it does do is to give you the option to jump from any line in the backtrace to the corresponding source file position, if available (in SLIME, it's v (view), don't know about Sly). There is a lot more that you can do, e. g. inspect local bindings/variables/arguments, and invoking restarts. Take a look at the manual.