መደበኛ ማረጋገጫ የአንድ ፕሮግራም ወይም አልጎሪዝም በሌላ እርዳታ ማረጋገጥ ነው።
ይህ በፕሮግራሙ ውስጥ ያሉትን ሁሉንም ድክመቶች ለማግኘት ወይም አለመኖራቸውን የሚያረጋግጡ በጣም ኃይለኛ ከሆኑ ዘዴዎች አንዱ ነው.
ስለ መደበኛ ማረጋገጫ የበለጠ ዝርዝር መግለጫ ችግሩን በመፍታት ምሳሌ ላይ ማየት ይቻላል ባለፈው ጽሑፌ ውስጥ.
በዚህ ጽሑፍ ውስጥ ከመደበኛ የችግር ማረጋገጫ ወደ ፕሮግራሞች እሸጋገር እና እንዴት እንደሆነ እገልጻለሁ
እንዴት እነሱን ወደ መደበኛ ህጎች ስርዓት በራስ-ሰር መቀየር እንደሚችሉ።
ይህንን ለማድረግ በምሳሌያዊ መርሆዎች ላይ የእኔን የቨርቹዋል ማሽን አናሎግ ጻፍኩ።
የፕሮግራሙን ኮድ ይተነትናል እና ወደ እኩልታዎች ስርዓት (SMT) ይተረጉመዋል, እሱም አስቀድሞ በፕሮግራም ሊፈታ ይችላል.
ስለ ምሳሌያዊ ስሌቶች መረጃ በበየነመረብ ላይ ስለሚቀርብ በተበታተነ መልኩ ፣
ምን እንደሆነ ባጭሩ እገልጻለሁ።
ተምሳሌታዊ ስሌቶች በተለያዩ መረጃዎች ላይ አንድን ፕሮግራም በአንድ ጊዜ የማስፈጸም መንገድ ሲሆን ለመደበኛ ፕሮግራም ማረጋገጫ ዋና መሳሪያ ናቸው።
ለምሳሌ የመጀመሪያው ነጋሪ እሴት ማንኛውንም አዎንታዊ እሴት የሚወስድበት፣ ሁለተኛው አሉታዊ፣ ሶስተኛው ዜሮ እና የውጤት ነጋሪ እሴት ለምሳሌ 42 የሚሆኑበትን የግቤት ሁኔታዎችን ማዘጋጀት እንችላለን።
ተምሳሌታዊ ስሌቶች በአንድ ሩጫ ውስጥ የተፈለገውን ውጤት ለማግኘት ይቻል እንደሆነ እና የእንደዚህ አይነት ግቤት መለኪያዎች ስብስብ ምሳሌ ይሰጡናል. ወይም እንደዚህ አይነት መለኪያዎች አለመኖራቸውን ያረጋግጡ.
ከዚህም በላይ የግቤት ግቤቶችን በተቻለ መጠን በአጠቃላይ ማቀናበር እንችላለን, እና ውጤቱን ብቻ መምረጥ እንችላለን, ለምሳሌ የአስተዳዳሪ ይለፍ ቃል.
በዚህ አጋጣሚ ሁሉንም የፕሮግራሙን ድክመቶች እናገኛለን, ወይም የአስተዳዳሪ የይለፍ ቃል ደህንነቱ የተጠበቀ መሆኑን ማረጋገጫ እናገኛለን.
የፕሮግራሙ ክላሲካል አፈፃፀም የተወሰነ የግብዓት መረጃ ያለው ልዩ ምሳሌያዊ ሁኔታ መሆኑን ማየት ይቻላል ።
ስለዚህ ፣ የእኔ ገጸ-ባህሪ VM በመደበኛ ምናባዊ ማሽን የማስመሰል ሁኔታ ውስጥም ሊሠራ ይችላል።
በቀደመው ጽሁፍ ላይ በተሰጡ አስተያየቶች ላይ አንድ ሰው ስለ ድክመቶቹ በመወያየት በመደበኛ ማረጋገጫ ላይ ትክክለኛ ትችት ማግኘት ይችላል.
ዋናዎቹ ችግሮች፡-
- ጥምር ፍንዳታ፣ መደበኛ ማረጋገጫ በመጨረሻ በP=NP ላይ ስለሚቆይ
- ወደ ፋይል ስርዓቱ፣ ኔትወርኮች እና ሌሎች የውጭ ማከማቻ ጥሪዎችን ማስተናገድ የበለጠ አስቸጋሪ ነው።
- በዝርዝሩ ውስጥ ያሉ ስህተቶች፣ ደንበኛው ወይም ፕሮግራመር አንድ ነገር ሲፀነሱ፣ ነገር ግን በቶር ውስጥ በትክክል አልገለጹም።
በውጤቱም, ፕሮግራሙ ይረጋገጣል እና ዝርዝር መግለጫውን ያከብራል, ነገር ግን ፈጣሪዎች ከእሱ ከጠበቁት ፈጽሞ የተለየ ነገር ያደርጋል.
በዚህ ጽሁፍ ውስጥ በዋናነት የመደበኛ ማረጋገጫን በተግባር ላይ ማዋልን ስለምመለከት ለአሁን ግንባሬን በግድግዳ ላይ አልመታም, እና የአልጎሪዝም ውስብስብነት እና የውጭ ጥሪዎች ብዛት አነስተኛ የሆኑበትን ስርዓት እመርጣለሁ.
ብልጥ ኮንትራቶች እነዚህን መስፈርቶች በተሻለ መንገድ ስለሚያሟሉ ምርጫው በ RIDE ኮንትራቶች ላይ ከ Waves መድረክ ላይ ወድቋል: እነሱ ቱሪንግ-የተሟሉ አይደሉም ፣ እና የእነሱ ከፍተኛ ውስብስብነት በሰው ሰራሽ የተገደበ ነው።
ግን ከቴክኒካል ጎን ብቻ እንቆጥራቸዋለን.
ከሁሉም ነገር በተጨማሪ, ለማንኛውም ኮንትራቶች, መደበኛ ማረጋገጫ በተለይ በፍላጎት ላይ ይሆናል: እንደ አንድ ደንብ, ከተጀመረ በኋላ የኮንትራት ስህተትን ማስተካከል አይቻልም.
በጣም ብዙ መጠን ያላቸው ገንዘቦች ብዙውን ጊዜ በስማርት ኮንትራቶች ውስጥ ስለሚከማቹ የእነዚህ ስህተቶች ዋጋ በጣም ከፍተኛ ሊሆን ይችላል።
የእኔ ገጸ ባህሪ VM በPHP እና Python የተፃፈ ነው፣ እና የተገኘውን የSMT ቀመሮችን ለመፍታት የማይክሮሶፍት ምርምር Z3Proverን ይጠቀማል።
በዋናው ላይ ኃይለኛ የብዝሃ-ግብይት ፍለጋ ነው, ይህም
ብዙ ግብይቶችን ቢጠይቅም መፍትሄዎችን ወይም ተጋላጭነቶችን እንዲያገኙ ያስችልዎታል።
እንኳ የኤቲሬም ተጋላጭነቶችን ለማግኘት በጣም ኃይለኛ ከሆኑት የቁምፊ ማዕቀፎች አንዱ ፣ ይህንን ችሎታ ከጥቂት ወራት በፊት ብቻ አክሏል።
ነገር ግን የኤተር ኮንትራቶች የበለጠ ውስብስብ እና ቱሪንግ-ሙሉነት እንዳላቸው ልብ ሊባል የሚገባው ጉዳይ ነው.
ፒኤችፒ የ RIDE ስማርት ኮንትራት ምንጭ ኮድ ወደ python ስክሪፕት ይተረጉመዋል ፣ በዚህ ውስጥ ፕሮግራሙ ከ Z3 SMT ጋር ተኳሃኝ የሆነ የኮንትራት ግዛቶች እና የመሸጋገሪያ ሁኔታቸው ነው ።
አሁን በውስጤ ያለውን ነገር በዝርዝር እገልጻለሁ።
በመጀመሪያ ግን ስለ RIDE ስማርት ውል ቋንቋ ጥቂት ቃላት።
በንድፍ ሰነፍ የሆነ ተግባራዊ እና መግለጫን መሰረት ያደረገ የፕሮግራም ቋንቋ ነው።
RIDE በብሎክቼይን ውስጥ ብቻውን ይሰራል እና ከተጠቃሚው የኪስ ቦርሳ ጋር የተያያዘውን መረጃ ማውጣት እና መፃፍ ይችላል።
የራይድ ውል ከእያንዳንዱ የኪስ ቦርሳ ጋር ማያያዝ ይቻላል፣ እና የአፈፃፀም ውጤቱ እውነት ወይም ውሸት ብቻ ይሆናል።
TRUE ማለት ብልጥ ኮንትራቱ ግብይቱን ይፈቅዳል ማለት ነው፣ እና ውሸት ይከለክላል ማለት ነው።
ቀላል ምሳሌ፡ የኪስ ቦርሳ ቀሪው ከ100 በታች ከሆነ ስክሪፕቱ ዝውውሩን ሊከለክል ይችላል።
እንደ ምሳሌ ፣ ተመሳሳይ ተኩላ ፣ ፍየል እና ጎመን እወስዳለሁ ፣ ግን ቀድሞውኑ በስማርት ኮንትራት መልክ ቀርቧል።
ተጠቃሚው ሁሉንም ሰው ወደ ሌላኛው ወገን እስኪልክ ድረስ ኮንትራቱ ከተሰራበት የኪስ ቦርሳ ገንዘብ ማውጣት አይችልም.
#Извлекаем положение всех объектов из блокчейна
let contract = tx.sender
let human= extract(getInteger(contract,"human"))
let wolf= extract(getInteger(contract,"wolf"))
let goat= extract(getInteger(contract,"goat"))
let cabbage= extract(getInteger(contract,"cabbage"))
#Это так называемая дата-транзакция, в которой пользователь присылает новые 4 переменные.
#Контракт разрешит её только в случае если все объекты останутся в сохранности.
match tx {
case t:DataTransaction =>
#Извлекаем будущее положение всех объектов из транзакции
let newHuman= extract(getInteger(t.data,"human"))
let newWolf= extract(getInteger(t.data,"wolf"))
let newGoat= extract(getInteger(t.data,"goat"))
let newCabbage= extract(getInteger(t.data,"cabbage"))
#0 обозначает, что объект на левом берегу, а 1 что на правом
let humanSide= human == 0 || human == 1
let wolfSide= wolf == 0 || wolf == 1
let goatSide= goat == 0 || goat == 1
let cabbageSide= cabbage == 0 || cabbage == 1
let side= humanSide && wolfSide && goatSide && cabbageSide
#Будут разрешены только те транзакции, где с козой никого нет в отсутствии фермера.
let safeAlone= newGoat != newWolf && newGoat != newCabbage
let safe= safeAlone || newGoat == newHuman
let humanTravel= human != newHuman
#Способы путешествия фермера туда и обратно, с кем-то либо в одиночку.
let t1= humanTravel && newWolf == wolf + 1 && newGoat == goat && newCabbage == cabbage
let t2= humanTravel && newWolf == wolf && newGoat == goat + 1 && newCabbage == cabbage
let t3= humanTravel && newWolf == wolf && newGoat == goat && newCabbage == cabbage + 1
let t4= humanTravel && newWolf == wolf - 1 && newGoat == goat && newCabbage == cabbage
let t5= humanTravel && newWolf == wolf && newGoat == goat - 1 && newCabbage == cabbage
let t6= humanTravel && newWolf == wolf && newGoat == goat && newCabbage == cabbage - 1
let t7= humanTravel && newWolf == wolf && newGoat == goat && newCabbage == cabbage
let objectTravel = t1 || t2 || t3 || t4 || t5 || t6 || t7
#Последняя строка в разделе транзакции описывает разрешающее транзакцию условие.
#Переменные транзакции должны иметь значения 1 или 0, все объекты должны
#быть в безопасности, а фермер должен переплывать реку в одиночку
#или с кем-то на каждом шагу
side && safe && humanTravel && objectTravel
case s:TransferTransaction =>
#Транзакция вывода средств разрешена только в случае если все переплыли на другой берег
human == 1 && wolf == 1 && goat == 1 && cabbage == 1
#Все прочие типы транзакций запрещены
case _ => false
}
ፒኤችፒ በመጀመሪያ ሁሉንም ተለዋዋጮች ከስማርት ኮንትራት በቁልፍ መልክ እና በተዛማጅ ቡሊያን አገላለጽ ያወጣል።
cabbage: extract ( getInteger ( contract , "cabbage" ) )
goat: extract ( getInteger ( contract , "goat" ) )
human: extract ( getInteger ( contract , "human" ) )
wolf: extract ( getInteger ( contract , "wolf" ) )
fState: human== 1 && wolf== 1 && goat== 1 && cabbage== 1
fState:
wolf:
goat:
cabbage:
cabbageSide: cabbage== 0 || cabbage== 1
human: extract ( getInteger ( contract , "human" ) )
newGoat: extract ( getInteger ( t.data , "goat" ) )
newHuman: extract ( getInteger ( t.data , "human" ) )
goatSide: goat== 0 || goat== 1
humanSide: human== 0 || human== 1
t7: humanTravel && newWolf== wolf && newGoat== goat && newCabbage== cabbage
t3: humanTravel && newWolf== wolf && newGoat== goat && newCabbage== cabbage + 1
t6: humanTravel && newWolf== wolf && newGoat== goat && newCabbage== cabbage - 1
t2: humanTravel && newWolf== wolf && newGoat== goat + 1 && newCabbage== cabbage
t5: humanTravel && newWolf== wolf && newGoat== goat - 1 && newCabbage== cabbage
t1: humanTravel && newWolf== wolf + 1 && newGoat== goat && newCabbage== cabbage
t4: humanTravel && newWolf== wolf - 1 && newGoat== goat && newCabbage== cabbage
safeAlone: newGoat != newWolf && newGoat != newCabbage
wolfSide: wolf== 0 || wolf== 1
humanTravel: human != newHuman
side: humanSide && wolfSide && goatSide && cabbageSide
safe: safeAlone || newGoat== newHuman
objectTravel: t1 || t2 || t3 || t4 || t5 || t6 || t7
ፒኤችፒ ከዚያ ወደ Z3Prover SMT ተኳሃኝ የpython ስርዓት መግለጫ ይቀይራቸዋል።
ውሂቡ በ loop ተጠቅልሏል፣ የማከማቻ ተለዋዋጮች ኢንዴክስ i፣ የግብይት ተለዋዋጮች ኢንዴክስ i + 1፣ እና መግለጫዎች ያላቸው ተለዋዋጮች ከቀዳሚው ሁኔታ ወደሚቀጥለው ለመሸጋገር ደንቦቹን ያዘጋጃሉ።
ይህ የእኛ የቨርቹዋል ማሽን ልብ ነው፣ እሱም ባለብዙ ግብይት የፍለጋ ሞተርን ያቀርባል።
fState: And( And( And( human[Steps] == 1 , wolf[Steps] == 1 ) , goat[Steps] == 1 ) , cabbage[Steps] == 1 )
final: fState[Steps]
fState:
wolf:
goat:
cabbage:
cabbageSide: Or( cabbage[i] == 0 , cabbage[i] == 1 )
goatSide: Or( goat[i] == 0 , goat[i] == 1 )
humanSide: Or( human[i] == 0 , human[i] == 1 )
t7: And( And( And( humanTravel[i] , wolf == wolf[i] ) , goat[i+1] == goat[i] ) , cabbage == cabbage[i] )
t3: And( And( And( humanTravel[i] , wolf == wolf[i] ) , goat[i+1] == goat[i] ) , cabbage == cabbage[i] + 1 )
t6: And( And( And( humanTravel[i] , wolf == wolf[i] ) , goat[i+1] == goat[i] ) , cabbage == cabbage[i] - 1 )
t2: And( And( And( humanTravel[i] , wolf == wolf[i] ) , goat[i+1] == goat[i] + 1 ) , cabbage == cabbage[i] )
t5: And( And( And( humanTravel[i] , wolf == wolf[i] ) , goat[i+1] == goat[i] - 1 ) , cabbage == cabbage[i] )
t1: And( And( And( humanTravel[i] , wolf == wolf[i] + 1 ) , goat[i+1] == goat[i] ) , cabbage == cabbage[i] )
t4: And( And( And( humanTravel[i] , wolf == wolf[i] - 1 ) , goat[i+1] == goat[i] ) , cabbage == cabbage[i] )
safeAlone: And( goat[i+1] != wolf , goat[i+1] != cabbage )
wolfSide: Or( wolf[i] == 0 , wolf[i] == 1 )
humanTravel: human[i] != human[i+1]
side: And( And( And( humanSide[i] , wolfSide[i] ) , goatSide[i] ) , cabbageSide[i] )
safe: Or( safeAlone[i] , goat[i+1] == human[i+1] )
objectTravel: Or( Or( Or( Or( Or( Or( t1[i] , t2[i] ) , t3[i] ) , t4[i] ) , t5[i] ) , t6[i] ) , t7[i] )
data: And( And( And( side[i] , safe[i] ) , humanTravel[i] ) , objectTravel[i] )
ሁኔታዎቹ በ python ውስጥ ያለውን የSMT ስርዓትን ለመግለጽ በተዘጋጀው የስክሪፕት አብነት ውስጥ ተደርድረው ገብተዋል።
ባዶ አብነት
import json
from z3 import *
s = Solver()
Steps=7
Num= Steps+1
$code$
#template, only start rest
s.add(data + start)
#template
s.add(final)
ind = 0
f = open("/var/www/html/all/bin/python/log.txt", "a")
while s.check() == sat:
ind = ind +1
print ind
m = s.model()
print m
print "traversing model..."
#for d in m.decls():
#print "%s = %s" % (d.name(), m[d])
f.write(str(m))
f.write("nn")
exit()
#s.add(Or(goat[0] != s.model()[data[0]] )) # prevent next model from using the same assignment as a previous model
print "Total solution number: "
print ind
f.close()
ለጠቅላላው ሰንሰለት የመጨረሻ ሁኔታ, በማስተላለፊያ ግብይት ክፍል ውስጥ የተቀመጡት ደንቦች ይተገበራሉ.
ይህ ማለት Z3Prover በመጨረሻ ከኮንትራቱ ገንዘብ ለማውጣት የሚያስችልዎትን በትክክል እንደዚህ ያሉ የክልል ስብስቦችን ይፈልጋል።
በውጤቱም፣ ሙሉ በሙሉ የሚሰራ የSMT ሞዴል የውላችንን በራስ ሰር እናገኛለን።
በእጅ ካጠናቀርኩት ካለፈው ጽሑፌ ከአምሳያው ጋር በጣም ተመሳሳይ መሆኑን ማየት ይችላሉ ።
የተጠናቀቀ አብነት
import json
from z3 import *
s = Solver()
Steps=7
Num= Steps+1
human = [ Int('human_%i' % (i + 1)) for i in range(Num) ]
wolf = [ Int('wolf_%i' % (i + 1)) for i in range(Num) ]
goat = [ Int('goat_%i' % (i + 1)) for i in range(Num) ]
cabbage = [ Int('cabbage_%i' % (i + 1)) for i in range(Num) ]
nothing= [ And( human[i] == human[i+1], wolf[i] == wolf[i+1], goat[i] == goat[i+1], cabbage[i] == cabbage[i+1] ) for i in range(Num-1) ]
start= [ human[0] == 1, wolf[0] == 0, goat[0] == 1, cabbage[0] == 0 ]
safeAlone= [ And( goat[i+1] != wolf[i+1] , goat[i+1] != cabbage[i+1] ) for i in range(Num-1) ]
safe= [ Or( safeAlone[i] , goat[i+1] == human[i+1] ) for i in range(Num-1) ]
humanTravel= [ human[i] != human[i+1] for i in range(Num-1) ]
cabbageSide= [ Or( cabbage[i] == 0 , cabbage[i] == 1 ) for i in range(Num-1) ]
goatSide= [ Or( goat[i] == 0 , goat[i] == 1 ) for i in range(Num-1) ]
humanSide= [ Or( human[i] == 0 , human[i] == 1 ) for i in range(Num-1) ]
t7= [ And( And( And( humanTravel[i] , wolf[i+1] == wolf[i] ) , goat[i+1] == goat[i] ) , cabbage[i+1] == cabbage[i] ) for i in range(Num-1) ]
t3= [ And( And( And( humanTravel[i] , wolf[i+1] == wolf[i] ) , goat[i+1] == goat[i] ) , cabbage[i+1] == cabbage[i] + 1 ) for i in range(Num-1) ]
t6= [ And( And( And( humanTravel[i] , wolf[i+1] == wolf[i] ) , goat[i+1] == goat[i] ) , cabbage[i+1] == cabbage[i] - 1 ) for i in range(Num-1) ]
t2= [ And( And( And( humanTravel[i] , wolf[i+1] == wolf[i] ) , goat[i+1] == goat[i] + 1 ) , cabbage[i+1] == cabbage[i] ) for i in range(Num-1) ]
t5= [ And( And( And( humanTravel[i] , wolf[i+1] == wolf[i] ) , goat[i+1] == goat[i] - 1 ) , cabbage[i+1] == cabbage[i] ) for i in range(Num-1) ]
t1= [ And( And( And( humanTravel[i] , wolf[i+1] == wolf[i] + 1 ) , goat[i+1] == goat[i] ) , cabbage[i+1] == cabbage[i] ) for i in range(Num-1) ]
t4= [ And( And( And( humanTravel[i] , wolf[i+1] == wolf[i] - 1 ) , goat[i+1] == goat[i] ) , cabbage[i+1] == cabbage[i] ) for i in range(Num-1) ]
wolfSide= [ Or( wolf[i] == 0 , wolf[i] == 1 ) for i in range(Num-1) ]
side= [ And( And( And( humanSide[i] , wolfSide[i] ) , goatSide[i] ) , cabbageSide[i] ) for i in range(Num-1) ]
objectTravel= [ Or( Or( Or( Or( Or( Or( t1[i] , t2[i] ) , t3[i] ) , t4[i] ) , t5[i] ) , t6[i] ) , t7[i] ) for i in range(Num-1) ]
data= [ Or( And( And( And( side[i] , safe[i] ) , humanTravel[i] ) , objectTravel[i] ) , nothing[i]) for i in range(Num-1) ]
fState= And( And( And( human[Steps] == 1 , wolf[Steps] == 1 ) , goat[Steps] == 1 ) , cabbage[Steps] == 1 )
final= fState
#template, only start rest
s.add(data + start)
#template
s.add(final)
ind = 0
f = open("/var/www/html/all/bin/python/log.txt", "a")
while s.check() == sat:
ind = ind +1
print ind
m = s.model()
print m
print "traversing model..."
#for d in m.decls():
#print "%s = %s" % (d.name(), m[d])
f.write(str(m))
f.write("nn")
exit()
#s.add(Or(goat[0] != s.model()[data[0]] )) # prevent next model from using the same assignment as a previous model
print "Total solution number: "
print ind
f.close()
ከተጀመረ በኋላ Z3Prover ብልጥ ኮንትራቱን ፈትቶ የግብይቶችን ሰንሰለት ያሳየናል፣ ይህም ገንዘብ ለማውጣት ያስችለናል፡
Winning transaction chain found:
Data transaction: human= 0, wolf= 0, goat= 1, cabbage= 0
Data transaction: human= 1, wolf= 0, goat= 1, cabbage= 1
Data transaction: human= 0, wolf= 0, goat= 0, cabbage= 1
Data transaction: human= 1, wolf= 1, goat= 0, cabbage= 1
Data transaction: human= 0, wolf= 1, goat= 0, cabbage= 1
Data transaction: human= 1, wolf= 1, goat= 1, cabbage= 1
Data transaction: human= 1, wolf= 1, goat= 1, cabbage= 1
Transfer transaction
ከመቋረጡ ኮንትራት በተጨማሪ በራስዎ ኮንትራቶች መሞከር ወይም ይህን ቀላል ምሳሌ መሞከር ይችላሉ, ይህም በ 2 ግብይቶች ውስጥ ይፈታል.
let contract = tx.sender
let a= extract(getInteger(contract,"a"))
let b= extract(getInteger(contract,"b"))
let c= extract(getInteger(contract,"c"))
let d= extract(getInteger(contract,"d"))
match tx {
case t:DataTransaction =>
let na= extract(getInteger(t.data,"a"))
let nb= extract(getInteger(t.data,"b"))
let nc= extract(getInteger(t.data,"c"))
let nd= extract(getInteger(t.data,"d"))
nd == 0 || a == 100 - 5
case s:TransferTransaction =>
( a + b - c ) * d == 12
case _ => true
}
ይህ በጣም የመጀመሪያው ስሪት ስለሆነ, አገባብ በጣም የተገደበ ነው እና ስህተቶች ሊኖሩ ይችላሉ.
በሚቀጥሉት ጽሁፎች ውስጥ, የቪኤም ተጨማሪ እድገትን ለመሸፈን እቅድ አለኝ, እና ከእሱ ጋር በመደበኛነት የተረጋገጡ ዘመናዊ ኮንትራቶችን እንዴት መፍጠር እንደሚችሉ ያሳያሉ, እና እነሱን መፍታት ብቻ አይደለም.
የቁምፊው ምናባዊ ማሽን በ ላይ ይገኛል።
የቪኤምን ገጸ ባህሪ ምንጭ ኮድ በቅደም ተከተል ካመጣሁ እና አስተያየቶችን ከጨመርኩ በኋላ በነጻ ተደራሽነት በ github ላይ ለማስቀመጥ እቅድ አለኝ።
ምንጭ: hab.com