hyped | latest loved songs from The Hype Machine

The error message

Basic use of SKRenderer is pretty straightforward, but there are some oddities that make it somewhat quirky in practice.

First, the fundamentals. To instantiate a renderer, use the rendererWithDevice: method. This method takes a id, such as the system default device. Pardon the Objective-C; this will translate easily to Swift:

1. Make a copy of diceRoll array (diceRollCopy).
2. Use the new array(diceRollCopy) as argument of choose method.
3. Whenever you get a result using choose method remove that result from the Copy array (diceRollCopy).
4. You would need to reset the diceRollCopy to diceRoll after each set of results have been accessed.

ok, sadly I will answer my own question. After a bit of research I found out that I could not get it running on java 8 and anyway there is no .jar (and neither I can manually create it) for graaljs

details are here:

https://github.com/graalvm/graaljs/blob/master/docs/BUILDING-GRAAL.JS.md

It's a very broad question but I will try to answer you.

Docker was at first build on LXC, they switched to libcontainer later.

LXC is actually pretty hard to use compared to Docker, you don't have all the Docker related stuff like Dockerfile, Compose and all.

So I would say that container wasn't really a thing because of the difficulty of LXC.

Args of within are not assigned with <- but with the usual =.

Let's see the first example in your link:

Some info on your concern about functional and procedural programming follows. It's not particularly original, but maybe it will get you started on how to think about this new stuff.

Functional programming is not procedural programming in reverse. It's a higher level of abstraction, and most everything we interact with can be seen as an abstraction; otherwise, we would never get anything useful done because we'd be so concerned with the minutiae of every little thing we deal with. Likewise, all code, in any language, eventually becomes a series of instructions to the CPU, and these instructions are the epitome of "imperative" or "procedural." The question becomes, "How much control do I need over the extremely low details in order to solve my problem?"

One way to add some numbers together, being pretty explicit (just pseudocode, hopefully the intent is clear):

There is some academic literature on the matter, I recommend the AOSA book chapter on it, written by the principal author (Chris Lattner).

LLVM is a collection of libraries built to support compiler development and related tasks. Each library supports a particular component in a typical compiler pipeline (lexing, parsing, optimizations of a particular type, machine code generation for a particular architecture, etc.). What makes it so popular is that its modular design allows its functionality to be adapted and reused very easily. This is handy when you're developing a compiler for an existing language to target a new hardware architecture (you only have to write the hardware specific components, all the lexing, parsing, machine independent optimization, etc. are handled for you), or developing a compiler for a new language (all the back end stuff is handled for you), or when you're doing something compiler adjacent (like analyzing source code, embedding a language in a larger application, etc.).

In order to support this, LLVM employs a pretty sophisticated internal representation (called the LLVM IR, creatively enough) that is basically assembly language for a theoretical hardware architecture designed to make targeting it with a compiler very easy. Most of the LLVM libraries take the IR in, operate on it, and output the modified IR, supporting the project's aim of modularity. This is in contrast to GCC, which (historically, I haven't checked recently) has a less complete IR and thus the separate phases of compilation are very tightly coupled because they have to share a lot of information.

Clang is the flagship compiler built on the LLVM framework.