org 100h

      mov ah,3Dh       ; open file for write
      mov dx,filename
      mov al,1         ; 1 = write mode
      int 21h
      jc error
      mov [handle],ax

      mov ah,40h       ; write bytes from hello
      mov cx,13         ; write 13 bytes
      mov dx,hello
      mov bx,[handle]
      int 21h

      mov ah,3Eh       ; close file
      mov bx,[handle]
      int 21h
      jmp exithello
                        
  error:
      mov ah,09h       ; display error msg
      mov dx,errormsg
      int 21h

  exithello:
      mov   ax,4C00h   ; exit to DOS
      int   21h
  
  hello    db 'Hello File!',0Dh,0Ah,0    ; what we are writing to the file
  filename db "hello.txt",0              ; the name of the file
  handle   dw ?                          ; handle for the opened file
  errormsg db "Open error$",0            ; error message                 

org 100h
mov cx,0
mov ah,60 
mov dx,f
int 33
mov bx,ax
l1:
mov ah,64
mov cx,1
mov dx,b
inc [b]
int 33
cmp [b],255
jb l1
mov bx,ax
mov ah,62
int 33
int 32
f db "db.bin",0
b db -1
    

Okay... so from just reading the source code, my intuition tells me that you are opening a flat-binary file to write to, looping through b and incrementing it's value each time, putting the new value each time into the file, then closing it.
Congrats on understanding it! (And I am proud of myself too for actually being able to understand someone elses ASM code fully for once.

But one question pops into my mind... why do it?

org 100h
mov cx,0
mov ah,60 
mov dx,f
int 33
mov bx,ax
l1:
mov ah,64
mov cx,3
mov dx,b
inc [b]
int 33
cmp [b],16777215
jb l1
mov bx,ax
mov ah,62
int 33
int 32
f db "d3b.bin",0
b dd -1
    

org 256
mov cx,0
mov ah,60 
mov dx,f
int 33
mov bx,ax
l1:
mov ah,64
mov cx,4
mov dx,b
int 33
inc [b]
cmp [b],0
ja l1
mov bx,ax
mov ah,62
int 33
int 32
f db "dd.bin",0
b dd 0
    

2: you can save one byte in source with replacing "org 100h" with "org 256"

Using decimal for memory addresses and dos system call numbers is just needless confusion. It won't affect the binary at all, and who cares how big the source is? If you wanted the smallest possible source, use some high level language because it will almost always be smaller than in assembly.

I don't know what 'needless
confusion' you're talking about. I am so well versed in the ways of
number bases that I didn't use a calculator to convert from hex to
decimal. I have it in my head. If it confuses you then ASM isn't your
thing!

I wish I could use hexidecimal without using the 0x or h .
Hexidecimal SHOULD be the default base. If it was,I wouldn't be using
decimal!

.radix 16
code segment
assume cs:code,ds:code,es:code
org 100

Komenco:
        mov ax,10
        mov ax,16
        mov ax,44
Fino:
        int 20

code ends
end Komenco
    

Okay. Without using a calculator or anything, how long does it take for you to figure out what call this code is doing:
mov ax,19968
int 33