882 karma · joined June 3, 2015
https://www.linkedin.com/in/peter-ilberg/
I haven’t used it myself, so I don’t know how easy it is to use. But I like some books that were written in it.
https://developer.apple.com/documentation/virtualization/run...
(Download the example project, build it in Xcode and run it. Point it to a linux .iso and you're good.)
I can stay in macOS for the stuff macOS is good at, and I can use linux for the stuff it's good at.
And chapter 10 of ML for the working programmer, freely available at https://www.cl.cam.ac.uk/~lp15/MLbook/pub-details.html
You can ask your employer to let you go sooner if you want to leave, and they may ask you to leave sooner if they want you to leave (and pay you as an incentive). But it has to be by mutual agreement.
Usually they’d let you go sooner rather than later because they know you’ve already left mentally and they don’t want to pay for that. But they might also not, not necessarily out of spite but because they have a deadline and they think they still need your warm body.
> BC You had used APL, and then you explored these other languages—Prolog variants and so on—but when you got to Morgan Stanley you came back to APL. What brought you back?
> AW I much preferred implementing and coding in LISP, but once I was dealing with big data sets and then having to do fairly simple calculations, APL just seemed to have the better vocabulary.
> It had to come up one level. Common LISP even then had about 2,000 primitives. I didn't like that. What I liked was the original LISP, which had car, cdr, cons, and cond, but that was too little. Common LISP was way too big, but a stripped-down version of APL was in the middle with about 50 operations. It's about the same size as C. But the thing about the languages that I implement is that there are no libraries: those 50 operations are it. Everybody builds from there, and the resulting programs are extremely short.
As others have mentioned, you don't always have a complete and accurate set of constraints. So you generate a schedule based on what you have. You hand it out to your employees. And they point out conflicts that they forgot to tell you about or that come up on short notice. So you have to rework the schedule to take them into account manually.
You could regenerate the schedule with the additional constraints. But the new schedule is likely quite different from what you originally handed out. People will have assumed the original schedule is final and they will have made plans. You cannot simply replace the schedule.
You might also already be halfway into the schedule period and the new schedule might only be fair if you had applied it from the beginning of the period.
You might be able to account for all of that in your constraints but it's going to get really hairy.
SICP goes a little further from compiling Scheme to virtual assembly, a VM and memory management with garbage collection in their last chapter. It's all implemented in Scheme itself, including the VM, but at that point it's low-level enough that you should be able to make the step to C. It doesn't talk about macros.
https://mitp-content-server.mit.edu/books/content/sectbyfn/b...
Neither one really talks about Common Lisp though and read macros etc. I'm also not sure how similar Scheme and Common Lisp compilers are.
Very interesting episode!
I’m starting with manually translating VHDL into Racket to get a feel for it and how to model it. The goal is to implement a language extension for VHDL with the help of the Beautiful Racket book.
The relevant section is 10.2. But its mechanism is the “inverse” of destination driven code generation as I understand it. In Wirth’s Item approach the callee picks a location and tells the caller where to look. Whereas in destination driven code generation the caller tells the callee where to put the result.
(Haven't tried it but they explicitly call it out in the shipping section.)
“CPU performance is faster than GPU on your network. Find out if your workload is sufficient to take advantage of the GPU. On small networks running with small batch sizes, the CPU may perform faster overall due to the overhead related to dispatching computations to the GPU. This will get amortized when the batch or model sizes grow, since the GPU can then take better advantage of the parallelism in performing the computations.”
https://people.inf.ethz.ch/wirth/CompilerConstruction/index....
https://people.inf.ethz.ch/wirth/CompilerConstruction/index....
(Cluj is a really nice and fun city to visit. Highly recommended.)