Видео

holy hell, didnt even make it to the 3rd chapter and my head hurts

I think the code around 6:34 should be much more like this: def my_sum(a, b, res, c): if (c >= b): return res return my_sum(a, b, res+1, c+1) def sum(a, b): return my_sum(a, b, a, 0)

This is very informative, and much more easy to understand then reading about it online.

Wow! I've seen so many youtubers "explaining" how to do an operating system but i didn't understand anything, This is the best explanation ever

I finished my homework :D mov ah, 0x0e mov al, 97 int 0x10 loop: sub al, 31 int 0x10 add al, 33 cmp al, 123 je exit int 0x10 jmp loop exit: jmp $ times 510-($-$$) db 0 db 0x55, 0xaa

Your inauguration resembles assembly.

mb a little too late but here is my solution to homework mov ah, 0x0e mov al, 'A' mov bl, 'b' loop: int 0x10 mov cl, al mov al, bl int 0x10 mov al, cl add al, 2 add bl, 2 cmp bl, 'z' + 2 jne loop hlt times 510 - ($ - $$) db 0 db 0x55, 0xaa (I wanted to use stack btw, but since you didn't introduce it i assumed it would be an overkill)

If you know patterns will happen, can’t you just make a tagged union, literally name the enums like “pattern_a b c” etc. and then use them as keys mapped to values that are functions, and dispatch them? This works in any language. I am not buying this pattern matching until I don’t see some kind of obvious benefit over what I just said. What I said also avoids branching ( which I believe pattern matching would do since you said it works lime a switch conditional statement ). If the input is one of the enum types in the union, then they will always be correctly mapped, and there’s no branching happening under the hood.

Bro thinks I'm going to add and subtract for my homework🤣🤣🤣 Obviously I'm going to figure out the laziest way to do it. org 0x7c00 mov si, hello mov ah, 0x0e loop: lodsb cmp al, 0 je $ int 0x10 jmp loop hello: db "aBcDeFgHiJkLmNoPqRsTuVwXyZ", 0 times 510-($-$$) db 0 dw 0xaa55

Check this out: mov ah, 0x0e mov al, 0x61 PRINT: cmp al, 0x7B je $ int 0x10 cmp al, 0x5A jle TO_LOW cmp al, 0x61 jge TO_UP TO_LOW: times 33 inc al jmp PRINT TO_UP: times 31 dec al jmp PRINT jmp $ times 510-($-$$) db 0 db 0x55, 0xaa

now I can continue with my plan. Your and nanobyte`s videos help me a lot!

The video is well done, but still, after 15+ years of experience, I do not understand why? Why functional programming? I do not get the benefit of it. :(

When will we start making the GUI of this OS 😢

Memory addresses are obviously counted from zero, but the BIOS loads your code into 0000:7C00. That's where it starts out. It is not loaded into 0000:0000 because that is where a x86 CPU expects the interrupt vectors to be.

I try it, but the screen keep resetting. Is there something wrong with the build file or the setup: ASM=nasm SRC_DIR=src BUILD_DIR=build $(BUILD_DIR)/main_floppy.img: $(BUILD_DIR)/main.bin cp $(BUILD_DIR)/main.bin $(BUILD_DIR)/main_floppy.img truncate -s 1440k $(BUILD_DIR)/main_floppy.img $(BUILD_DIR)/main.bin: $(SRC_DIR)/main.asm mkdir -p $(BUILD_DIR) $(ASM) $(SRC_DIR)/main.asm -f bin -o $(BUILD_DIR)/main.bin setup: QEMU KVM 1 core CPU 512MB RAM

5:23 I feel dense… 😅. How does (foo(2))(5) return 10 if 5 was never passed in?

free() needs to know the size passed to malloc(). It can not turn off all the contiguous '1's because it could deallocate another blocks

I spend 2h trying to make it print hello world from 16bits example, converted from AI to 32bits and do not work. your videos make it a lot more easy to understand it. Thanks. *It is hard to find videos like this. A lot of the videos use syscall, that do not help me*

mov ah, 0x0e; Switch to teletype mode mov al, 'A' loop: int 0x10 cmp al, 'z' je end inc al cmp al, 96 jl capital jg small capital: add al, 32 jmp loop small: sub al, 32 jmp loop end: jmp $ times 510-($-$$) db 0 dw 0xaa55

We need your help for making an amd64 OS because I understand the best from you.

3:40 mfw almost a decade ago, I had that exact CM12 rom on that exact LG G3 phone with that exact same "bios" boot animation 😏

0:24 when ur codin in python when doing lists "pop" has the same defiition

the "hello weirdo" jmpscared me(see what i did there)

Thank gosh i resolved my mental problem with this

I started learning elixir and just reading it feels like reading Chinese. This helped a lot! Thanks

2:34 lines of WHAT ...oh...

Your cadence is impossible to predict. I am unable to anticipate when you will do this random 100-200ms pauses in your speech, you are an artist. Love the video. Cheers.

4:21 shouldn't this be (ds << 16) + offset? Or am I missing something... Why would you add the 16-bit offset (which could be as large as 65535) to a base that is only a multiple of 16? The "ds:offset" expression, in my experience, means "ds concatenated with offset". In this case, that would be the same as (ds << 16) + offset.

my brain hurts

who else opened the console to check the [] + [] and {} + []?

Excuse me, but i am getting an error from qemu, saying no bootable disk. Do you know any way to fix this?

This sounds like jibberish to me. A command is an instruction telling the computer what to do. Whatever form it takes, it is still a command. I don't get the distinction since you never trully define what a command is. I'm also disturbed by the use of the term, "command" in functional programming. Why not choose a unique word without other mean like bloud instead of trying to redefine the word, command? All you're doing is creating confusion. I've watched a number of videos on functional programming without a clear definition of a command. I'll keep trying until I find someone who truly understands this and can explain it to me in terms that I can understand.

0:09: low level* you mean

Reading through the comment section of every functional programming videos/shorts I've watched, I've come to conclude at the hypothesis that either 1. nobody can agree on the what even is the difference between Functional Programming vs Procedural Programming, everyone keeps saying that an explanation is a procedural programming paradigm even when they are wrong, and vice versa 2. Everyone thinks they are smarter than a university/course lecturer Why the hell are we even using paradigms, just start programming instead of writing a thesis

Finally, finallium

After 8 months I decided to tackle this topic again with better understanding of assembly! Anyway here's my homework: mov ah, 0x0E mov al, 'A' something: int 0x10 inc al xor al, 0x20 ; literally only this instruction got added LOL cmp al, 'Z' + 1 jne something jmp $ times 510-($-$$) db 0 db 0x55, 0xAA

the volume of the background music is so high, it's quite annoying. Please either a) talk or b) do music, but when doing a) make sure b) doesn't interfere.

as an idiot and also a java dev and java enjoyer this was very informative and entertaining, thank you & subbed <3 @Comment @Dishwasher @CommentContentsConstructor @NoCommentContentsConstructor Sent from my public void abstract interface AccountSubscriberUserBuilderFactoryHelperUtil

Errr.. FUNCTIONS ABSTRACT OVER EXPRESSIONS. End of briefest possible introduction! Simples... (:-)

5:11 I have never thought that assembly was easy

I think I'll stop at Kotlin & Lambdas . Anything more is too pure to me :)

What is property 1 and 2 at the first place You explanation is not clear at all buddy!

i couldnt do the function one i dont know how it works i mean how c i convert it to its ascii value without a database can i get some help

[org 0x7c00] start: mov ah, 0x0e mov bx, variable loopA: mov al, [bx] cmp al, 0 je config1 int 0x10 inc bx jmp loopA config1: mov ah, 0x0e mov al, 0x0a int 0x10 mov al, 0x0d int 0x10 xor bx, bx mov bx, buffer xor cx, cx loopB: xor ax, ax int 0x16 mov [bx], al cmp al, 0 je loopB mov ah, 0x0e int 0x10 inc bx inc cx cmp cx, 10 je config2 jmp loopB config2: mov byte [bx], 0 mov ah, 0x0e mov al, 0x0d int 0x10 mov al, 0x0a int 0x10 mov bx, buffer loopC: mov al, [bx] cmp al, 0 je hang int 0x10 inc bx jmp loopC hang: xor al, al xor ah, ah xor bx, bx jmp $ variable: db "write a word with 10 letters", 0 buffer: times 11 db 0 times 510-($-$$) db 0 db 0x55, 0xaa

me wasting 35 minutes staring at the code not realising i declared the variable after the boot signature

i did the alphabet without cheating... and i put dashes between them too💁‍♀ Update: i did A-B-C-D-E...Y-Z /13 min/ and A-a-B-b-C-c-D-d-E-e...Y-y-Z-z /around 30 min/ and A-b-C-d-E...Y-z /like 1 minute if not less cuz i just edited the code of the prev one/

0:23 The 🐐

I think there's a mistake in the proof. When you define what list[n] is, the definition isn't include "they can call another list function." There are 2 reason why this rule shouldn't be included. 1. This will cause "circular definition." You can't define list[n] to be "those who can return in a finite time and call another *list function*," or it will be defined by themselves. 2. Consider this function: input n; return list[n](n); This is the function that appeared in video but without "+1" in return statement. If a list function can call another list function, then the above function should also be one. Assume the index of it is x. Then we give x as an argument for it. It will return list[x](x), and it's just itself, so it will be in a recursion for infinite time. Obviously, an infinite recuring function isn't an interesting function, so it isn't a list function, either. Due to the two reasons, a list function shouldn't call another one, so the "weird function" in the video isn't in the list. Therefore, the proof in the video is invalid.

Could you help me with the os tutorial? I created an array inside the c file, and when I try to access the array, all the values are null or 0. Could you show me how to fix this?

yapper