diff --git a/Makefile b/Makefile
index 3f0f054..f225cc0 100644
--- a/Makefile
+++ b/Makefile
@@ -57,7 +57,7 @@ gprof:
 # compiles program and runs it with callgrind (part of valgrind)
 # uses gprof2dot python script to generate function call tree (pip install gprof2dot)
 # requires graphviz (https://www.graphviz.org/download/source/)
-# P.S. detailed rezults can be viewed in KCacheGrind
+# P.S. detailed results can be viewed in KCacheGrind
 callgrind:
 	@cbuild/call_task.sh callgrind 2>&1 | tee make_raw.log
 
diff --git a/cbuild b/cbuild
index 60fa8c1..c20e1e8 160000
--- a/cbuild
+++ b/cbuild
@@ -1 +1 @@
-Subproject commit 60fa8c11c2673a10f8afbe37bcea13c9be3317b8
+Subproject commit c20e1e8f1c3e92e7f980a74942352b0a3744edcd
diff --git a/default.config b/default.config
index 5fa97b3..d6baae4 100644
--- a/default.config
+++ b/default.config
@@ -150,7 +150,7 @@ case "$TASK" in
     # compiles program and runs it with callgrind (part of valgrind)
     # uses gprof2dot python script to generate function call tree (pip install gprof2dot)
     # requires graphviz (https://www.graphviz.org/download/source/)
-    # P.S. detailed rezults can be viewed in KCacheGrind
+    # P.S. detailed results can be viewed in KCacheGrind
     callgrind)
         OUTDIR="$OUTDIR/callgrind"
         # -pg adds code to executable, that generates file containing function call info (gmon.out)
diff --git a/src/Filesystem/file.c b/src/Filesystem/file.c
index 5c38523..a1bf50c 100644
--- a/src/Filesystem/file.c
+++ b/src/Filesystem/file.c
@@ -64,64 +64,64 @@ Maybe file_close(FileHandle file){
 }
 
 #define ioWriteCheck() \
-    if(rezult==EOF) \
+    if(result==EOF) \
         safethrow(ERR_IO_EOF,;); \
-    if(rezult!=0) \
+    if(result!=0) \
         safethrow(ERR_IO,;);
 
 Maybe file_writeChar(FileHandle file, char byte){
-    i32 rezult=fputc(byte, file);
+    i32 result=fputc(byte, file);
     ioWriteCheck();
     return MaybeNull;
 }
 
 Maybe file_writeBuffer(FileHandle file, char* buffer, u64 length){
-    i32 rezult=0;
-    for(u64 i=0; i<length && !rezult; i++)
-        rezult=fputc(buffer[i], file);
+    i32 result=0;
+    for(u64 i=0; i<length && !result; i++)
+        result=fputc(buffer[i], file);
     ioWriteCheck();
     return MaybeNull;
 }
 
 Maybe file_writeCptr(FileHandle file, char* cptr){
-    i32 rezult=fputs(cptr, file);
+    i32 result=fputs(cptr, file);
     ioWriteCheck();
     return MaybeNull;
 }
 
 
 Maybe file_readChar(FileHandle file){
-    i32 rezult=fgetc(file);
+    i32 result=fgetc(file);
     if(feof(file)) safethrow(ERR_IO_EOF,;);
     if(ferror(file)) safethrow(ERR_IO,;);
-    return SUCCESS(UniUInt64(rezult));
+    return SUCCESS(UniUInt64(result));
 }
 
 Maybe file_readBuffer(FileHandle file, char* buffer, u64 length){
-    i32 rezult=0;
+    i32 result=0;
     u64 i=0;
-    for(; i<length && rezult!=EOF; i++){
-        rezult=fgetc(file);
-        buffer[i]=(char)rezult;
+    for(; i<length && result!=EOF; i++){
+        result=fgetc(file);
+        buffer[i]=(char)result;
     }
     if(ferror(file)) safethrow(ERR_IO,;);
     return SUCCESS(UniUInt64(i));
 }
 
 Maybe file_readAll(FileHandle file, char** allBytes){
-    i32 rezult=0;
+    i32 result=0;
     char buffer[256];
     string bufStr={.ptr=buffer, .length=sizeof(buffer)};
     StringBuilder* sb=StringBuilder_create();
     u64 i=0;
     while(true){
-        rezult=fgetc(file);
-        if(rezult==EOF){
+        result=fgetc(file);
+        if(result==EOF){
             if(ferror(file)) 
                 safethrow(ERR_IO, StringBuilder_free(sb));
             break;
         }
-        buffer[i%sizeof(buffer)]=(char)rezult;
+        buffer[i%sizeof(buffer)]=(char)result;
         i++;
         if(!(i%sizeof(buffer)))
             StringBuilder_append_string(sb,bufStr);
diff --git a/src/Filesystem/path.c b/src/Filesystem/path.c
index cc5cb6e..66b15fd 100644
--- a/src/Filesystem/path.c
+++ b/src/Filesystem/path.c
@@ -22,7 +22,7 @@ char* __path_concat(u32 n, ...){
     const char* output=totality;
     totality[totalLength]=0;
     
-    // copying content of all strings to rezult
+    // copying content of all strings to result
     u16 k=0;
     for(; k<n-1; k++){
         memcopy(parts[k], totality, lengths[k]);
@@ -74,11 +74,11 @@ char* path_parentDir(char* dir){
 
 char* path_basename(char* path, bool with_extension){
     i32 nameIndex=cptr_lastIndexOfChar(path, path_sep)+1;
-    string rezult=string_fromCptr(path+nameIndex);
+    string result=string_fromCptr(path+nameIndex);
     if(!with_extension){
-        i32 extIndex=cptr_lastIndexOfChar(rezult.ptr, '.');
+        i32 extIndex=cptr_lastIndexOfChar(result.ptr, '.');
         if(extIndex!=0 && extIndex!=-1)
-            rezult.length=extIndex;
+            result.length=extIndex;
     }
-    return string_extract(rezult);
+    return string_extract(result);
 }
diff --git a/src/Network/sockets/knSocketChanneled.c b/src/Network/sockets/knSocketChanneled.c
index dd815d2..1f3cb24 100644
--- a/src/Network/sockets/knSocketChanneled.c
+++ b/src/Network/sockets/knSocketChanneled.c
@@ -16,14 +16,14 @@ Maybe knSocketChanneled_open(){
 }
 
 Maybe knSocketChanneled_close(knSocketChanneled* socket){
-    int rezult=
+    int result=
 #if KN_USE_WINSOCK
     closesocket
 #else
     close
 #endif
     (socket->socketfd);
-    if(rezult==-1) {
+    if(result==-1) {
         safethrow("can't close socket",;);
     }
     else return MaybeNull;
diff --git a/src/Network/sockets/knSocketTCP.c b/src/Network/sockets/knSocketTCP.c
index d24dd2d..6b41484 100644
--- a/src/Network/sockets/knSocketTCP.c
+++ b/src/Network/sockets/knSocketTCP.c
@@ -2,7 +2,6 @@
 #include "../stdSocketHeaders.h"
 ktid_define(knSocketTCP);
 
-///@return Maybe<knSocketTCP*> new socket
 Maybe knSocketTCP_open(){
     knSocketTCP* newSocket=malloc(sizeof(knSocketTCP));
     newSocket->localEndpoint=knIPV4Endpoint_create({.u32=INADDR_NONE},0);
@@ -14,23 +13,23 @@ Maybe knSocketTCP_open(){
     return SUCCESS(UniHeapPtr(knSocketTCP, newSocket));
 }
 
-///@return Maybe<void> error or nothing
 Maybe knSocketTCP_close(knSocketTCP* socket){
-    int rezult=
+    int result=
 #if KN_USE_WINSOCK
-    closesocket
+        closesocket
 #else
-    close
+        close
 #endif
-    (socket->socketfd);
-    if(rezult==-1) {
+        (socket->socketfd);
+    if(result==-1)
         safethrow("can't close socket",;);
-    }
-    else return MaybeNull;
+
+    socket->socketfd = 0;
+    socket->localEndpoint = knIPV4Endpoint_create(0, 0);
+    socket->remoteEndpoint = knIPV4Endpoint_create(0, 0);
+    return MaybeNull;
 }
 
-///sets socket local endpoint
-///@return Maybe<void> error or nothing
 Maybe knSocketTCP_listen(knSocketTCP* socket, knIPV4Endpoint localEndp){
     if(socket->localEndpoint.address.u32!=INADDR_NONE)
         safethrow("socket is bound already",;);
@@ -46,8 +45,6 @@ Maybe knSocketTCP_listen(knSocketTCP* socket, knIPV4Endpoint localEndp){
     return MaybeNull;
 }
 
-///sets socket remote endpoint
-///@return Maybe<void> error or nothing
 Maybe knSocketTCP_connect(knSocketTCP* socket, knIPV4Endpoint remoteEndp){
     if(socket->remoteEndpoint.address.u32!=0)
         safethrow("socket is connected already",;);
@@ -61,14 +58,12 @@ Maybe knSocketTCP_connect(knSocketTCP* socket, knIPV4Endpoint remoteEndp){
     return MaybeNull;
 }
 
-///@return Maybe<knSocketTCP*> new socket connected to client
-Maybe knSocketTCP_accept(knSocketTCP* socket);
+Maybe knSocketTCP_accept(knSocketTCP* socket){
+    accept(socket->socketfd, )
+}
 
-///@param dataLength 0-4294967295
-///@return Maybe<void>
-Maybe knSocketTCP_send(knSocketTCP* socket, char* data, u32 dataLength);
+Maybe knSocketTCP_send(knSocketTCP* socket, char* data, u32 dataLength){
+
+}
 
-///@param buffer buffer for recieving data
-///@param bufferLength 0-4294967295
-///@return Maybe<u64> received bytes amount
 Maybe knSocketTCP_receive(knSocketTCP* socket, char* buffer, u32 bufferLength);
diff --git a/src/Network/sockets/knSocketUDP.c b/src/Network/sockets/knSocketUDP.c
index aed2142..419e0f1 100644
--- a/src/Network/sockets/knSocketUDP.c
+++ b/src/Network/sockets/knSocketUDP.c
@@ -2,7 +2,6 @@
 #include "../stdSocketHeaders.h"
 ktid_define(knSocketUDP);
 
-///@return Maybe<knSocketUDP*> new socket
 Maybe knSocketUDP_open(){
     knSocketUDP* newSocket=malloc(sizeof(knSocketUDP));
     newSocket->localEndpoint=knIPV4Endpoint_create(knIPV4Address_fromBytes(0,0,0,0),0);
@@ -13,18 +12,26 @@ Maybe knSocketUDP_open(){
     return SUCCESS(UniHeapPtr(knSocketUDP, newSocket));
 }
 
-///start listening at local endpoint
-///@return Maybe<void> error or nothing
+Maybe knSocketUDP_close(knSocketUDP* socket){
+    int result=
+#if KN_USE_WINSOCK
+        closesocket
+#else
+        close
+#endif
+        (socket->socketfd);
+    if(result==-1)
+        safethrow("can't close socket",;);
+
+    socket->socketfd = 0;
+    socket->localEndpoint = knIPV4Endpoint_create(0,0);
+    return MaybeNull;
+}
+
 Maybe knSocketUDP_listen(knSocketUDP* socket, knIPV4Endpoint localEndp);
 
-///@return Maybe<knSocketUDP*> new socket connected to client
 Maybe knSocketUDP_accept(knSocketUDP* socket);
 
-///@param dataLength 0-4294967295
-///@return Maybe<void>
 Maybe knSocketUDP_sendto(knSocketUDP* socket, char* data, u32 dataLength, knIPV4Endpoint destination);
 
-///@param buffer buffer for recieving data
-///@param bufferLength 0-4294967295
-///@return Maybe<u64> received bytes amount
 Maybe knSocketUDP_receive(knSocketUDP* socket, char* buffer, u32 bufferLength);
diff --git a/src/base/cptr.c b/src/base/cptr.c
index 07eee43..88a4bd2 100644
--- a/src/base/cptr.c
+++ b/src/base/cptr.c
@@ -160,7 +160,7 @@ char* __cptr_concat(u32 n, ...){
     char* output=totality;
     totality[totalLength]=0;
     
-    // copying content of all strings to rezult
+    // copying content of all strings to result
     for(u16 k=0; k<n; k++){
         memcopy(strs[k], totality, lengths[k]);
         totality+=lengths[k];
@@ -212,6 +212,6 @@ char* cptr_replaceIn(const char* src, const char* str_old, const char* str_new,
     u32 src_remains_len=cptr_length(src);
     if(src_remains_len>0)
         StringBuilder_append_string(sb, (string){.ptr=(char*)src, .length=src_remains_len});
-    string rezult=StringBuilder_build(sb);
-    return rezult.ptr;
+    string result=StringBuilder_build(sb);
+    return result.ptr;
 }
diff --git a/src/base/errors.c b/src/base/errors.c
index 6f093f1..81a3e7f 100644
--- a/src/base/errors.c
+++ b/src/base/errors.c
@@ -25,23 +25,23 @@ char* errname(ErrorId err){
 
 char* __genErrMsg(const char* errmsg, const char* srcfile, i32 line, const char* funcname){
     size_t bufsize=ERRMSG_MAXLENGTH;
-    char* rezult=malloc(bufsize);
+    char* result=malloc(bufsize);
     IFMSC(
-        sprintf_s(rezult,bufsize,"[%s:%d] %s() throwed error: %s",srcfile,line,funcname,errmsg),
-        sprintf(rezult,"[%s:%d] %s() throwed error: %s",srcfile,line,funcname,errmsg)
+        sprintf_s(result,bufsize,"[%s:%d] %s() throwed error: %s",srcfile,line,funcname,errmsg),
+        sprintf(result,"[%s:%d] %s() throwed error: %s",srcfile,line,funcname,errmsg)
     );
-    return rezult;
+    return result;
 }
 
 char* __extendErrMsg(const char* errmsg, const char* srcfile, i32 line, const char* funcname){
     size_t bufsize=cptr_length(errmsg)+ERRMSG_MAXLENGTH;
-    char* rezult=malloc(bufsize);
+    char* result=malloc(bufsize);
     IFMSC(
-        sprintf_s(rezult,bufsize,"%s\n \\___[%s:%d] %s()",errmsg,srcfile,line,funcname),
-        sprintf(rezult,"%s\n \\___[%s:%d] %s()",errmsg,srcfile,line,funcname)
+        sprintf_s(result,bufsize,"%s\n \\___[%s:%d] %s()",errmsg,srcfile,line,funcname),
+        sprintf(result,"%s\n \\___[%s:%d] %s()",errmsg,srcfile,line,funcname)
     );
     free(errmsg);
-    return rezult;
+    return result;
 }
 
 void Maybe_free(Maybe e){
diff --git a/src/base/errors.h b/src/base/errors.h
index a0e228a..635143e 100644
--- a/src/base/errors.h
+++ b/src/base/errors.h
@@ -60,10 +60,10 @@ char* __unknownErr( );
     __RETURN_EXCEPTION(((char*)__genErrMsg(E, __FILE__,__LINE__,__func__))); \
 }
 
-#define try_cpp(_funcCall, _rezult, freeMem) Maybe _rezult=_funcCall; if(_rezult.errmsg){ \
+#define try_cpp(_funcCall, _result, freeMem) Maybe _result=_funcCall; if(_result.errmsg){ \
     freeMem; \
-    _rezult.errmsg=__extendErrMsg(_rezult.errmsg, __FILE__,__LINE__,__func__); \
-    return _rezult; \
+    _result.errmsg=__extendErrMsg(_result.errmsg, __FILE__,__LINE__,__func__); \
+    return _result; \
 }
 
 #else
@@ -73,16 +73,16 @@ char* __unknownErr( );
     __RETURN_EXCEPTION(((char*)__genErrMsg((__stringify_err(E)), __FILE__,__LINE__,__func__))); \
 }
 
-#define try(_funcCall, _rezult, freeMem) Maybe _rezult=_funcCall; if(_rezult.errmsg){ \
+#define try(_funcCall, _result, freeMem) Maybe _result=_funcCall; if(_result.errmsg){ \
     freeMem; \
-    _rezult.errmsg=__extendErrMsg(_rezult.errmsg, __FILE__,__LINE__,__func__); \
-    return _rezult; \
+    _result.errmsg=__extendErrMsg(_result.errmsg, __FILE__,__LINE__,__func__); \
+    return _result; \
 }
 #endif
 
-#define tryLast(_funcCall, _rezult, ON_EXIT) Maybe _rezult=_funcCall; if(_rezult.errmsg){ \
-    _rezult.errmsg=__extendErrMsg(_rezult.errmsg, __FILE__,__LINE__,__func__); \
-    __EXIT(_rezult.errmsg); \
+#define tryLast(_funcCall, _result, ON_EXIT) Maybe _result=_funcCall; if(_result.errmsg){ \
+    _result.errmsg=__extendErrMsg(_result.errmsg, __FILE__,__LINE__,__func__); \
+    __EXIT(_result.errmsg); \
 }
 
 #if __cplusplus
diff --git a/src/base/type_system/unitype.c b/src/base/type_system/unitype.c
index a85c05e..eb53fdf 100644
--- a/src/base/type_system/unitype.c
+++ b/src/base/type_system/unitype.c
@@ -85,11 +85,11 @@ char *Unitype_toString(Unitype u, u32 fmt)
         valuestr = type->toString(u.VoidPtr, fmt);
     else
         valuestr = "ERR_NO_TOSTRING_FUNC";
-    char *rezult = cptr_concat("{ type: ", type->name, ", allocated on heap: ", (u.allocatedInHeap ? "true" : "false"),
+    char *result = cptr_concat("{ type: ", type->name, ", allocated on heap: ", (u.allocatedInHeap ? "true" : "false"),
                                ", value:", valuestr, " }");
     if (type->toString)
         free(valuestr);
-    return rezult;
+    return result;
 }
 
 void printuni(Unitype v)
diff --git a/src/kprint/kprint.c b/src/kprint/kprint.c
index 4edfc8b..11aed81 100644
--- a/src/kprint/kprint.c
+++ b/src/kprint/kprint.c
@@ -53,8 +53,8 @@ Maybe __ksprint(u8 n, kp_fmt* formats, __kp_value_union* objects){
         StringBuilder_append_cptr(strb, mStr.value.VoidPtr);
         Unitype_free(mStr.value);
     }
-    char* rezult=StringBuilder_build(strb).ptr;
-    return SUCCESS(UniHeapPtr(char, rezult));
+    char* result=StringBuilder_build(strb).ptr;
+    return SUCCESS(UniHeapPtr(char, result));
 }
 
 Maybe __kfprint(FILE* file, u8 n, kp_fmt* formats, __kp_value_union* objects){
diff --git a/tests/test_network.c b/tests/test_network.c
index f9c3516..97ec06c 100644
--- a/tests/test_network.c
+++ b/tests/test_network.c
@@ -37,15 +37,22 @@ void test_network(){
         test_knIPV4Address_fromStr(34,255,45,0);
         test_knIPV4Address_fromStr(3,3,3,128);
         
-        knSocketTCP* s;
-        tryLast(knSocketTCP_open(), maybeS, ;);
-        s=maybeS.value.VoidPtr;
+        knSocketTCP* socket;
+        tryLast(knSocketTCP_open(), m_socket, ;);
+        socket=m_socket.value.VoidPtr;
         kprintf("\e[92mTCP socket created\n");
 
         knIPV4Endpoint localEnd = knIPV4Endpoint_create(knIPV4Address_fromBytes(127,0,0,1), 4444);
-        tryLast(knSocketTCP_listen(s, localEnd), _m81775, ;)
+        tryLast(knSocketTCP_listen(socket, localEnd), _m81775, ;)
 
-        tryLast(knSocketTCP_close(s), _m676, ;);
+        while(true){
+            tryLast(knSocketTCP_accept(socket), m_connection, ;);
+            knSocketTCP* connection = m_connection.value.VoidPtr;
+            knSocketTCP_receive()
+        }
+        
+
+        tryLast(knSocketTCP_close(socket), _m676, ;);
         kprintf("\e[92mTCP socket closed\n");
 
         tryLast(kt_tryDispose(), _m88ag, ;);