Bitwise Operators
Bitwise Operators: Sayıları Manipüle Etmek İçin Güçlü Bir Araca Sahip Olun – İkili Taban, İşaretli/İşaretsiz Tamsayılar, Bit Shift ve Rotasyon İşlemleri Hakkında Her Şey
Solidity programlama dilinde sayılar, akıllı sözleşmelerin çoğunda önemli bir rol oynar. Bitwise Operators ise, sayıları manipüle etmek için güçlü bir araçtır. Bu operatörler, sayıları ikili tabanda gösterme, işaretli/İşaretsiz tamsayılar arasında dönüştürme, bit shift ve rotasyon işlemleri yapma gibi birçok işlemi gerçekleştirmeye olanak sağlar. Bu konuda yapılan her adım, programın doğru çalışması için hayati önem taşır. Bu nedenle, bu yazıda Bitwise Operators konusunu ele alacak ve Solidity programlamacılarına bu güçlü aracı nasıl kullanacaklarını öğreteceğiz.
Bitwise Operators nedir?
“Bitwise Operators” (Bit Düzeyinde Operatörler), programlama dillerinde kullanılan özel operatörlerdir. Bu operatörler, sayıları ikili tabanda gösterme, işaretli/İşaretsiz tamsayılar arasında dönüştürme, bit shift ve rotasyon işlemleri yapma gibi işlemleri gerçekleştirmek için kullanılır.
Solidity programlama dilinde de Bitwise Operators kullanılabilir. Bu operatörler, özellikle sayılarla ilgili hesaplama ve manipülasyon işlemlerinde oldukça yararlıdır. Solidity programlamacıları, Bitwise Operators’ı kullanarak sayıları daha etkili bir şekilde işleyebilirler.
Bitwise Operators neden kullanılır?
Bitwise Operators, programlama dillerinde sayıları manipüle etmek için kullanılan güçlü bir araçtır. Bu operatörler, sayıları ikili tabanda gösterme, işaretli/İşaretsiz tamsayılar arasında dönüştürme, bit shift ve rotasyon işlemleri yapma gibi birçok işlemi gerçekleştirmeye olanak sağlar.
Sayıların ikili tabanda gösterimi, Solidity programlama dilinde birçok işlemde önemlidir. Bitwise Operators, sayıların ikili tabanda gösterimini kullanarak, özellikle matematiksel hesaplamalar ve veri işleme işlemlerinde oldukça yararlıdır.
Ayrıca, Bitwise Operators’ın kullanımı sayıların verimli bir şekilde manipüle edilmesine olanak tanır. Bu operatörler, kodun daha hızlı çalışmasına, daha az bellek kullanmasına ve daha az işlemci gücü tüketmesine yardımcı olabilir.
Bitwise Operators türleri nelerdir?
Solidity programlama dilinde Bitwise Operators, aşağıdaki beş türden oluşur:
- Bitwise AND ( & ): İki sayının bitlerinin AND işlemine tabi tutulmasını sağlar. Sadece iki sayının ilgili bitleri 1 ise sonuç da 1 olur, diğer durumlarda sonuç 0’dır.
- Bitwise OR ( | ): İki sayının bitlerinin OR işlemine tabi tutulmasını sağlar. İki sayının ilgili bitlerinden en az biri 1 ise sonuç da 1 olur, diğer durumlarda sonuç 0’dır.
- Bitwise XOR ( ^ ): İki sayının bitlerinin XOR işlemine tabi tutulmasını sağlar. İki sayının ilgili bitleri farklı ise sonuç 1 olur, aynı ise sonuç 0’dır.
- Bitwise NOT ( ~ ): Tek bir sayının bitlerinin tersine çevrilmesini sağlar. Yani, 1’ler 0, 0’lar 1 olarak değiştirilir.
- Bit Shift ( <<, >> ): İki sayı arasında bit shift işlemi yapılmasını sağlar. Sol tarafta verilen sayının belirtilen sayıda biti sola veya sağa kaydırılır. Sol tarafta verilen sayı 2, sağ tarafta verilen sayı 3 ise, sol taraftaki sayının bitleri 2 kez sola kaydırılır ve sağ taraftaki sayının bitleri 3 kez sağa kaydırılır.
Ayrıca, Solidity programlama dilinde Bitwise Operators’ın kullanımı, sayıların işaretli veya işaretsiz olmasına bağlı olarak değişebilir. İşaretli sayılar, bir bitlerinden birini işaretlemek için kullanılırken, işaretsiz sayılar ise matematiksel işlemler için kullanılır.
Bitwise Operators nasıl kullanılır?
Bitwise Operators, Solidity programlama dilinde kullanımı oldukça basit olan operatörlerdir. Bu operatörler, sayıları ikili tabanda gösterme, işaretli/İşaretsiz tamsayılar arasında dönüştürme, bit shift ve rotasyon işlemleri yapma gibi birçok işlemi gerçekleştirmeye olanak sağlar.
Örneğin, aşağıdaki örneklerde AND, OR, XOR, NOT, bit shift işlemleri kullanılmıştır:
uint8 a = 0x0F; // 0000 1111
uint8 b = 0x05; // 0000 0101
// Bitwise AND
uint8 c = a & b; // 0000 0101
// Bitwise OR
uint8 d = a | b; // 0000 1111
// Bitwise XOR
uint8 e = a ^ b; // 0000 1010
// Bitwise NOT
uint8 f = ~a; // 1111 0000
// Bit shift
uint8 g = a << 2; // 0011 1100
Yukarıdaki örneklerde, a ve b adlı değişkenlere atanan sayıların ikili tabanda gösterimi yapılmıştır. Ardından Bitwise AND, OR, XOR, NOT ve Bit shift operatörleri kullanılarak farklı işlemler gerçekleştirilmiştir.
Burada, &, |, ^, ~, << ve >> operatörleri kullanılmıştır. Bu operatörler, Solidity programlama dilinde Bitwise Operators olarak adlandırılır ve sayıları manipüle etmek için kullanılır.
Bitwise Operators örnekleri nelerdir?
Aşağıda Solidity programlama dilinde Bitwise Operators kullanılarak gerçekleştirilen örnekler verilmiştir:
Örnek 1: Bitwise AND işlemi kullanarak sayının tek veya çift olduğunu kontrol etme
uint256 num = 10; // num değişkenine 10 değeri atanıyor
if (num & 1 == 0) { // Bitwise AND kullanılarak num sayısının son biti 0 ise çift sayıdır
// num çift sayıdır
} else {
// num tek sayıdır
}
Bu örnekte, Bitwise AND işlemi kullanarak, num değişkenindeki sayının son bitinin 0 olup olmadığı kontrol edilerek, sayının tek veya çift olduğu belirleniyor.
Örnek 2: Bitwise OR işlemi kullanarak izin verilen yetkileri kontrol etme
uint8 readPermission = 0x01; // 0000 0001
uint8 writePermission = 0x02; // 0000 0010
uint8 deletePermission = 0x04; // 0000 0100
uint8 userPermission = 0x03; // 0000 0011 (read ve write izni verilmiş)
if (userPermission & readPermission == readPermission) {
// Kullanıcının okuma izni var
}
if (userPermission & writePermission == writePermission) {
// Kullanıcının yazma izni var
}
if (userPermission & deletePermission == deletePermission) {
// Kullanıcının silme izni var
}
Bu örnekte, Bitwise OR işlemi kullanarak, izin verilen yetkilerin sayısal değerlerinin birleştirilmesi sağlanmıştır. Daha sonra, Bitwise AND kullanarak, kullanıcının izinleri kontrol edilerek, kullanıcının belirli bir izne sahip olup olmadığı belirleniyor.
Örnek 3: Bit shift işlemi kullanarak sayının 2’nin üssü katını bulma
uint256 num = 10; // num değişkenine 10 değeri atanıyor
uint256 result = num << 1; // num sayısının bitleri 1 kez sola kaydırılıyor
// result = 20
Bu örnekte, Bit shift işlemi kullanılarak, num değişkenindeki sayının bitleri 1 kez sola kaydırılarak, sayının 2’nin üssü katı elde ediliyor.
Bitwise Operators ile ilgili dikkat edilmesi gereken noktalar nelerdir?
Bitwise Operators kullanırken dikkat edilmesi gereken bazı önemli noktalar şunlardır:
- Bitwise Operators’ların kullanımı, özellikle büyük veri kümeleri üzerinde yürütülen işlemlerde oldukça hızlıdır.
- Bitwise Operators’ları kullanırken işlem yapacağınız değişkenlerin tipine dikkat edin. Örneğin, uint8 tipinde bir değişkene Bitwise shift işlemi uygulayarak sonucun uint8 tipinde olmasını sağlayabilirsiniz. Ancak uint256 tipinde bir değişkenle aynı işlemi yaparsanız, sonuç uint256 tipinde olacaktır.
- Bitwise Operators’lar her zaman diğer operatörlere göre önceliklidir. Ancak, kodun daha okunaklı olması için, parantezler kullanarak işlemlerin önceliğini belirleyebilirsiniz.
- Bitwise Operators kullanırken, hataların oluşmaması için operatörlerin işlevlerini tam olarak anlamak önemlidir. Özellikle Bitwise shift işleminin sağa veya sola kaydırma işlemini tam olarak anlamak ve sonuçlarına dikkat etmek gerekir.
- Kodun daha anlaşılır olması için, Bitwise Operators’ların kullanıldığı yerlerde yorum satırları eklemek iyi bir pratiktir.
Bit manipulation nedir ve ne için kullanılır?
Bit manipulation, bir bilgisayar programlama tekniği olarak, bir veri kümesindeki belirli bitleri değiştirmek veya kontrol etmek için kullanılır. Bit manipulation, programcılara, bellek kullanımını azaltmak, hızı artırmak ve daha karmaşık operasyonları gerçekleştirmek için sık sık kullanılan bir tekniktir.
Bit manipulation, özellikle veri yapıları, ağ protokolleri, sıkıştırma algoritmaları, şifreleme, grafik ve video işleme gibi performansı önemli olan alanlarda sıkça kullanılır. Bit manipulation teknikleri, örneğin, bir veri kümesindeki belirli bitleri sıfırlamak veya ayarlamak, belirli bir bit dizisindeki değişiklikleri takip etmek, belirli bir bit dizisi içindeki değerleri tersine çevirmek veya bir bit dizisindeki belli bir bitin değerini kontrol etmek için kullanılabilir.
Bit manipulation, programcıların veri işleme işlemlerini daha hızlı ve etkili bir şekilde gerçekleştirmesine yardımcı olan güçlü bir araçtır. Ancak, Bitwise Operators ve Bit manipulation teknikleri kullanırken, kodun anlaşılır ve hataların oluşmaması için dikkatli olunması önemlidir.
Sayıların ikili tabanda gösterimi nedir?
Sayıların ikili tabanda gösterimi, bilgisayarların kullanmış olduğu en temel sayı tabanıdır. İkili tabanda gösterimde, sayılar yalnızca sıfır ve bir (0 ve 1) gibi iki değer kullanarak gösterilir.
Bir sayının ikili tabanda gösteriminde, sayıların sağdan sola doğru bitlerine yer verilir. En sağdaki bit, birler basamağıdır ve 2^0 (yani 1) değerine sahiptir. Bitler sola doğru hareket ettikçe, her bir bitin değeri önceki bitin iki katıdır.
Örneğin, 5 sayısının ikili tabanda gösterimi, 101’dir. İlk bit (en sağdaki bit) 1’dir ve 2^0 değerine sahiptir. İkinci bit 0’dır ve 2^1 değerine sahiptir. Üçüncü bit (en soldaki bit) tekrar 1’dir ve 2^2 değerine sahiptir. Bu nedenle, 5 sayısı, 2^2 + 2^0 değerlerinin toplamı olarak ifade edilebilir.
İkili tabanda gösterim, bilgisayarların sayıları depolaması ve işlemesi için kullanılan temel sayı tabanıdır. Bilgisayarlar, ikili tabanda gösterimdeki sayıları daha hızlı işleyebilirler ve bellek kullanımını minimize ederler.
İşaretli ve işaretsiz tamsayılar nedir?
İşaretli ve işaretsiz tamsayılar, programlamada sıklıkla kullanılan sayı türleridir.
İşaretli tamsayılar, pozitif, negatif veya sıfır değerlerine sahip olan tam sayıları temsil eder. Bu tamsayılar, bilgisayar belleğinde belli bir bit sayısı ile saklanır ve en sol bit, sayının işaretini belirler. Eğer en sol bit 0 ise sayı pozitif veya sıfırdır, eğer 1 ise sayı negatiftir. Örneğin, 8 bitlik bir işaretli tamsayı, -128 ile 127 arasındaki değerleri ifade edebilir.
İşaretsiz tamsayılar ise, yalnızca pozitif veya sıfır değerlerine sahip olan tam sayıları temsil eder. Bu tamsayılar da belli bir bit sayısı ile saklanır, ancak en sol bit, sayının işaretini belirlemediği için, daha büyük sayıları ifade etmek için kullanılabilir. Örneğin, 8 bitlik bir işaretsiz tamsayı, 0 ile 255 arasındaki değerleri ifade edebilir.
Programlama dillerinde, işaretli ve işaretsiz tamsayılar, farklı amaçlar için kullanılır. İşaretli tamsayılar, programcılara pozitif, negatif ve sıfır değerlerini ifade etme esnekliği sağlarken, işaretsiz tamsayılar, sadece pozitif değerleri ele alır ve daha büyük sayıları işlemek için daha uygun olabilir.
Bit shift ve rotasyon işlemleri nedir ve ne için kullanılır?
Bit shift işlemi, bir sayının bitlerinin belirli bir sayıda sağa veya sola kaydırılmasıdır. Sağa kaydırma, sayıyı 2’nin sağa kaydırılan bit sayısı kadar böler, sola kaydırma ise sayıyı 2’nin sola kaydırılan bit sayısı kadar çarpar. Bit shift işlemi, işaretli veya işaretsiz tamsayılar üzerinde uygulanabilir ve performans açısından yararlıdır.
Örneğin, 1010 sayısının sağa 2 bit kaydırılması, 0010 sayısını elde ederiz. Sola 3 bit kaydırma işlemi uygulandığında, 1010 sayısı 1010000 sayısına dönüşür.
Rotasyon işlemi, bit shift işlemine benzer, ancak kaydırılan bitler, bir uçtan diğer uca taşınır. Yani, sağa rotasyon işlemi, en sağdaki biti en sola taşır ve sola rotasyon işlemi, en soldaki biti en sağa taşır. Bu işlem, bir sayının bütünlüğünü korurken, verilerin daha hızlı ve verimli bir şekilde işlenmesine yardımcı olabilir.
Bit shift ve rotasyon işlemleri, özellikle bit manipülasyonunda ve düşük seviyeli programlamada yaygın olarak kullanılır. Örneğin, bit shift işlemi, bir sayının bölme ve çarpma işlemlerinin yerine geçebilir ve bir sayının iki katına çıkarmak veya yarı yarıya azaltmak gibi işlemler için de kullanılabilir. Rotasyon işlemi ise, bir sayının döndürülmesi gereken durumlarda veya sayıların dairesel kuyruk belleğinde döndürülmesi gerektiği durumlarda kullanılabilir.
Akıllı Sözleşme Örneği İNCELEME
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
contract BitwiseOps {
// x = 1110 = 8 + 4 + 2 + 0 = 14
// y = 1011 = 8 + 0 + 2 + 1 = 11
// x & y = 1010 = 8 + 0 + 2 + 0 = 10
function and(uint x, uint y) external pure returns (uint) {
return x & y;
}
// x = 1100 = 8 + 4 + 0 + 0 = 12
// y = 1001 = 8 + 0 + 0 + 1 = 9
// x | y = 1101 = 8 + 4 + 0 + 1 = 13
function or(uint x, uint y) external pure returns (uint) {
return x | y;
}
// x = 1100 = 8 + 4 + 0 + 0 = 12
// y = 0101 = 0 + 4 + 0 + 1 = 5
// x ^ y = 1001 = 8 + 0 + 0 + 1 = 9
function xor(uint x, uint y) external pure returns (uint) {
return x ^ y;
}
// x = 00001100 = 0 + 0 + 0 + 0 + 8 + 4 + 0 + 0 = 12
// ~x = 11110011 = 128 + 64 + 32 + 16 + 0 + 0 + 2 + 1 = 243
function not(uint8 x) external pure returns (uint8) {
return ~x;
}
// 1 << 0 = 0001 --> 0001 = 1
// 1 << 1 = 0001 --> 0010 = 2
// 1 << 2 = 0001 --> 0100 = 4
// 1 << 3 = 0001 --> 1000 = 8
// 3 << 2 = 0011 --> 1100 = 12
function shiftLeft(uint x, uint bits) external pure returns (uint) {
return x << bits;
}
// 8 >> 0 = 1000 --> 1000 = 8
// 8 >> 1 = 1000 --> 0100 = 4
// 8 >> 2 = 1000 --> 0010 = 2
// 8 >> 3 = 1000 --> 0001 = 1
// 8 >> 4 = 1000 --> 0000 = 0
// 12 >> 1 = 1100 --> 0110 = 6
function shiftRight(uint x, uint bits) external pure returns (uint) {
return x >> bits;
}
// Get last n bits from x
function getLastNBits(uint x, uint n) external pure returns (uint) {
// Example, last 3 bits
// x = 1101 = 13
// mask = 0111 = 7
// x & mask = 0101 = 5
uint mask = (1 << n) - 1;
return x & mask;
}
// Get last n bits from x using mod operator
function getLastNBitsUsingMod(uint x, uint n) external pure returns (uint) {
// 1 << n = 2 ** n
return x % (1 << n);
}
// Get position of most significant bit
// x = 1100 = 10, most significant bit = 1000, so this function will return 3
function mostSignificantBit(uint x) external pure returns (uint) {
uint i = 0;
while ((x >>= 1) > 0) {
++i;
}
return i;
}
// Get first n bits from x
// len = length of bits in x = position of most significant bit of x, + 1
function getFirstNBits(uint x, uint n, uint len) external pure returns (uint) {
// Example
// x = 1110 = 14, n = 2, len = 4
// mask = 1100 = 12
// x & mask = 1100 = 12
uint mask = ((1 << n) - 1) << (len - n);
return x & mask;
}
}
Bu akıllı sözleşme, Solidity dilinde bit işlemlerini göstermek için oluşturulmuştur. Sözleşme, bitwise AND, OR ve XOR işlemlerini gerçekleştirebilir ve ayrıca NOT, shift left, shift right, get last n bits, get last n bits using mod, most significant bit ve get first n bits gibi diğer işlemleri de yapabilir.
Örneğin, and fonksiyonu, iki uint parametre alır ve bu parametrelerin bitwise AND işlemi sonucunda oluşan uint değerini döndürür. Or fonksiyonu, bitwise OR işlemi sonucunda oluşan uint değerini döndürür. XOR fonksiyonu, bitwise XOR işlemi sonucunda oluşan uint değerini döndürür.
shiftLeft ve shiftRight fonksiyonları, belirtilen miktarda biti sola veya sağa kaydırır. getLastNBits fonksiyonu, belirtilen sayıdaki son bitleri alır ve getLastNBitsUsingMod fonksiyonu, son n bitleri almak için mod kullanır. mostSignificantBit fonksiyonu, verilen sayıdaki en büyük önemli bitin konumunu döndürür. getFirstNBits fonksiyonu, belirtilen sayıdaki ilk n biti alır.
Farklı Akıllı Sözleşme Örneği İNCELEME
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
contract MostSignificantBitFunction {
// Find most significant bit using binary search
function mostSignificantBit(uint x) external pure returns (uint msb) {
// x >= 2 ** 128
if (x >= 0x100000000000000000000000000000000) {
x >>= 128;
msb += 128;
}
// x >= 2 ** 64
if (x >= 0x10000000000000000) {
x >>= 64;
msb += 64;
}
// x >= 2 ** 32
if (x >= 0x100000000) {
x >>= 32;
msb += 32;
}
// x >= 2 ** 16
if (x >= 0x10000) {
x >>= 16;
msb += 16;
}
// x >= 2 ** 8
if (x >= 0x100) {
x >>= 8;
msb += 8;
}
// x >= 2 ** 4
if (x >= 0x10) {
x >>= 4;
msb += 4;
}
// x >= 2 ** 2
if (x >= 0x4) {
x >>= 2;
msb += 2;
}
// x >= 2 ** 1
if (x >= 0x2) msb += 1;
}
}
Bu akıllı sözleşme, bir sayının en önemli (en yüksek) bitini bulmak için ikili arama kullanır. Bu, bir dizedeki en uzun önek gibi, bir sayının en büyük değerli bitinin konumunu bulur.
Sözleşme, “MostSignificantBitFunction” adında bir sözleşmedir. Bu sözleşmenin bir fonksiyonu vardır: “mostSignificantBit”. Bu fonksiyon, uint türünde bir sayı alır ve uint türünde en önemli (en yüksek) bitin konumunu döndürür.
Fonksiyon, “external” ve “pure” modifiyerları ile tanımlanır. “external” modifiyeri, fonksiyonun yalnızca dışarıdan çağrılabilir olduğunu belirtir. “pure” modifiyeri, fonksiyonun dış dünya durumunu değiştirmeden hesaplama yapabileceğini belirtir.
Fonksiyon, sırasıyla 128, 64, 32, 16, 8, 4, 2 ve 1 bitlerindeki değerleri kontrol eder. Eğer kontrol edilen bitlerde 1 değeri varsa, sayıyı bu bit sayısına göre kaydırır ve en önemli bit değerini bulmak için “msb” değişkenini artırır.
Son olarak, fonksiyon en önemli bitin konumunu döndürür. Eğer hiçbir 1 değeri yoksa, fonksiyon 0 değerini döndürür.
Alternatif Akıllı Sözleşme Örneği İNCELEME
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
contract MostSignificantBitAssembly {
function mostSignificantBit(uint x) external pure returns (uint msb) {
assembly {
let f := shl(7, gt(x, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF))
x := shr(f, x)
// or can be replaced with add
msb := or(msb, f)
}
assembly {
let f := shl(6, gt(x, 0xFFFFFFFFFFFFFFFF))
x := shr(f, x)
msb := or(msb, f)
}
assembly {
let f := shl(5, gt(x, 0xFFFFFFFF))
x := shr(f, x)
msb := or(msb, f)
}
assembly {
let f := shl(4, gt(x, 0xFFFF))
x := shr(f, x)
msb := or(msb, f)
}
assembly {
let f := shl(3, gt(x, 0xFF))
x := shr(f, x)
msb := or(msb, f)
}
assembly {
let f := shl(2, gt(x, 0xF))
x := shr(f, x)
msb := or(msb, f)
}
assembly {
let f := shl(1, gt(x, 0x3))
x := shr(f, x)
msb := or(msb, f)
}
assembly {
let f := gt(x, 0x1)
msb := or(msb, f)
}
}
}
Bu akıllı sözleşme de, önceki örnekteki gibi, bir sayının en büyük anlamlı bitini bulmayı amaçlamaktadır. Ancak bu kez, Solidity yerine, birleşik kod (assembly) kullanılarak yapılmaktadır.
Bu akıllı sözleşme de, önceki örnekteki gibi bir binary search (ikili arama) kullanır. Ancak işlem, Solidity dilinde yapılan örneğe kıyasla daha kısa bir kodla gerçekleştirilir. Her işlemde, gt (büyükse) fonksiyonu kullanılır ve sonuç, shl (sol kaydırma) ve shr (sağ kaydırma) fonksiyonlarıyla kaydırılır. Sonuçlar, or (veya) fonksiyonu kullanılarak birleştirilir.
Solidity kodu gibi, bu kod da uint olarak verilen sayının en büyük anlamlı bitini döndürür.
SONUÇ BAĞLAMI
Bu oturumda Solidity programlama dili ve Ethereum blok zinciri hakkında temel bilgileri öğrendik. Özellikle akıllı sözleşme kavramı ve Solidity programlama dilinin temel yapılarına değindik. Ayrıca gas, gas limit ve gas price gibi önemli kavramları da ele aldık.
Ayrıca, örnek Solidity kodları inceleyerek bu kodların ne işe yaradığını ve nasıl çalıştığını öğrendik. Örneğin, bir oy verme akıllı sözleşmesi ve en önemli biti bulan iki farklı Solidity akıllı sözleşmesi örneği gördük.
Bu oturumda öğrendikleriniz, Ethereum blok zinciri ve akıllı sözleşmeler hakkında daha derinlemesine bilgi edinmeniz için bir başlangıç noktasıdır. İleride daha gelişmiş konuları öğrenerek, daha karmaşık akıllı sözleşmeler ve dApps’ler oluşturabilirsiniz.
Solidity Programlama Dili Öğrenme yolculuğunuz hakkında daha iyi rehberlik almak için Solidity nedir? Ethereum Akıllı Sözleşmelerinin Dili Rehberi içeriğimize göz atın. Dilerseniz Yeni Başlayanlar için Solidity – Akıllı Sözleşme Geliştirme Hızlandırılmış Kursuna katılın.
Çalışmaya nereden başlayacağım diyenler için Blockchain Developer Olmak İçin Yol Haritası içeriğine de muhakkak bakın.
Gelin aklınızdaki soruları SUPERPEER sohbetinde cevaplayalım.
Bu makaleyi okuduğunuz için teşekkürler! Bana destek olmak isterseniz;
Beni Twitter, Linkedin ve YouTube‘da takip edin.
Kısa bir yorum bırakmayı UNUTMAYIN!
