fs2 | Compositional , streaming I/O library for Scala | Functional Programming library

Probably you need this part:

What's wrong with the above code?

You are not using the same Queue in the consumer and in the producer, rather each of them is creating its own new independent Queue (the same happens with Random BTW)

This is a common mistake made by newbies who don't grasp yet the main principles behind a data type like IO

When you do val queue: IO[Queue[IO, Int]] = Queue.bounded[IO, Int](10) you are saying that queue is a program that when evaluated will produce a value of type Queue[IO, Unit], that is the point of all this.
The program become a value, and as any value you can manipulate it in any ways to produce new values, for example using flatMap so when both consumer & producer crate a new program by flatMapping queue they both create new independent programs / values.

You can fix that code like this:

Your function createEmptyTexture binds the texture it creates to the (implicitly) activated texture unit 0, and leaves it bound. So if you want to read from the texture of the first framebuffer you'll need to bind that before rendering with program 2. That being said, usually you'd setup all the vertex-, index- and framebuffers with their respective textures and programs upfront during initialization, your render loop then emits bind, draw and attribute pointer calls.

I finally gotten a solution in SQL. by using LEN then get the length then using LEFT to get the first 2 char.

Then create a where clause for the condition: LEFT(Whh_SubsidiaryCode,2) >= '20'

The following code is written on top of my head and following the docs, since I can't test it right now.
(thus it may have some typos / errors; if you find one please feel free to edit the answer and thanks!)

By checking the implementation of the zipAllWith function I found out that indeed uncons1 in such cases should be avoided. The final solution would be to use the stepLeg function instead of uncons1. So the function from the above should look like this:

I see two issues.

The first thing, there is no reason to mock IO. You can pretty much do this:

how does the processor know which address to start fetching instructions from?

The actual CPU itself will have some hard-wired address that it fetches from on reset / power-on. Usually a system will be designed with ROM or flash at that phys address. (That ROM might have early-boot code for an ELF program loader which will respect the ELF entry-point metadata to set up an ELF kernel image from ROM, or you could just link a flat binary with the right code at the start of the binary.)

What is going on here? I thought I'd have a simple single line of hex, but there's a lot more going on.

Your objdump -D disassembles all ELF sections, not just .text. As you can see, there is only one instruction in the .text section, and if you used objdump -d that's what you'd see. (I normally use objdump -drwC, although -w no line-wrapping is probably irrelevant for RISC-V, unlike x86 where a single insn can be long.)

Would it be possible to pass the file I compiled above as is to my processor?

Not in the way you're probably thinking. Also note that you chose the wrong file name for the output. as produces an object file (normally .o), not an executable. You could link with ld into a flat binary, or link and objcopy the .text section out of it.

(You could in theory put a whole ELF executable or even object file into ROM such that the .text section happens to start where the CPU will fetch from, but nothing will look at the metadata bytes. So the ELF entry-point address metadata in an ELF executable would be irrelevant.)

Difference between a .o and an executable: a .o just has relocation metadata for the linker to fill in actual addresses, absolute for la pseudo-instructions, or relative for auipc in cases like multiple .o files where one references a symbol from the other. (Otherwise the relative displacement could be calculated at assemble time, not left for link time.)

So if you had code that used any labels for memory addresses, you'd need the linker to fill in those relocation entries in your code. Then you could objcopy some sections out of a linked ELF executable. Or use a linker script to set the layout for your flat binary.

For your simple case with only an add, no la or anything, there are no relocation entries so the text section in the .o is the same as in a linked executable.

Also tricky to get right with objcopy is static data, e.g. .data and .bss sections. If you copy just the .text section to a flat binary, you won't have data anywhere. (But in a ROM, you'd need a startup function that copies static initializers from ROM to RAM for .data, and zeros the .bss space. If you want to write the asm source to have a normal-looking .data section with non-zero values, you'd want your build scripts to figure out the size to copy so your startup function can use it, instead of having to manually do all that.)

I ran the below code