نکته ضعف‌های اساسی که در بحث ایردراپ‌ها وجود داشت:
۱) قفل کردن اجباری توکن برای مدت معین
۲) تصمیمات ناگهانی و اجرا بدون نظرخواهی جامعه

این دو ویژگی در بخش ایردراپ به هیچ وجه وجود نداره. اول اینکه هیچ شرطی برای قفل کردن وجود نداره اما برای هولد کردن چرا!
و دوم اینکه هر تصمیمی گرفته بشه با رأی گیری جامعه به صورت on-chain و ثبت روی شبکهٔ بیس شکل می‌گیره و بعد تصمیم اجراء می‌شه. یعنی جامعه تصمیم می‌گیره، داوری میشه و بعد از رأی آوردن تصمیم اجرا میشه. اینطوری دیگه یک نفر تصمیم. گیرنده نخواهد بود.

این دو مورد رو من اینطور در نظر گرفتم که خطاهای دیجن رو نداشته باشیم و مقداری هم شبیه قانون هولد ریر پیش بریم که اجباری توش نباشه.

البته یک استثناء هم وجود داره، هرکسی که روی بیس NFT و یا کدی رو اجرا و مینت کنه، ممکنه بتونیم براش بدون هولد کردن مقدار مشخصی از توکن، سهمیه بدیم! این رو من باید با جامعه بیس هم یک مشورتی کنم ببینم چی میشه...

به این نگاه کن، در مورد ریر هست!
سرمایه‌گذار‌ها همیشه دنبال نقاط قوت مثل نقطهٔ ستاره صعودی هستن که یه چیزی مثل علامت + (سبز رنگ) در پایین‌ترین نقطهٔ ممکن هست! و معمولاً برعکسش یعنی در قله با رنگ قرمز علامت یک ریزش درست حسابی میده.

جاهایی که فشار فروش میاد فرصت خوبی برای نقد کردن و جاهایی که هماهنگ با نقطه‌های طلائی هست فرصت برای حمایت محسوب میشه.

پر کردن این کپ‌ها خودش داستان‌ها داره... 👀 پیدا کردن این نقاط معمولاً به همراه تأیید برای اشباع فروش و لحظهٔ خوبی برای حمایت هست.

واین موضوع هم مهمه که یاد آوری کنیم، شت‌کوین و میم‌کوین چیه؟

شت‌کوین:
معمولاً پروژه‌های بی‌ارزش یا کلاهبرداری هستن که هیچ هدف واقعی، کاربرد یا برنامه توسعه‌ای ندارن.

ویژگی‌ها:
- عرضه خیلی بالا (مثلاً چندین میلیارد و تیریلیون توکن).
- بدون قفل یا برنامه آزادسازی (همه توکن‌ها یهو توی بازار دامپ می‌شن).
- تیم ناشناس یا بدون شفافیت.
- فقط برای پامپ و دامپ کوتاه‌مدت ساخته می‌شن.

میم‌کوین:
پروژه‌هایی هستن که بیشتر بر اساس شوخی، میم‌های اینترنتی یا جامعه طرفدارا ساخته می‌شن (مثل Dogecoin یا Shiba Inu یا Degen).

ویژگی‌ها:
- معمولاً کاربرد فنی محدودی دارن و ارزششون به هیجان جامعه بستگی داره.
- عرضه بالا و بدون ساختار مشخص برای توزیع.
- تمرکز روی بازاریابی وایرال به جای توسعه واقعی.

#میم‌کوین #شت‌کوین #توکن #memecoin #shitcoin

اعلان مستعار (alias) در C++23

یکی از پیشرفت‌های C++23، گسترش عبارت‌های init برای اجازه دادن به اعلان (مستعار) alias است.
عبارت‌های init بخشی از حلقه‌ها (for، while)، switch و عبارت‌های range-based for هستند. آنها به شما اجازه می‌دهند تا متغیرها را در داخل خود حلقه یا عبارت declare و initialize کنید، یا از typedef استفاده کنید. این کار می‌تواند خوانایی و قابلیت نگهداری کد را با نگه داشتن اعلان‌های متغیر نزدیک به جایی که استفاده می‌شوند، بهبود بخشد.

از طرفی ممکن است در موقعیتی قرار بگیرید که در آن تعیین یک typedef برای بدنه حلقه for مفید باشد. در عین حال، اگر به نام مستعار نیاز داشته باشیم، خواناتر و همچنین به طور گسترده‌تری برای استفاده از آن قابل استفاده است. متأسفانه، با دستورات اولیه برای حلقه C++20 این کاری نیست که شما بتوانید انجام دهید. می‌توانید از typedef استفاده کنید.

std::vector pointsScored {27, 41, 32, 23, 28};
for (typedef int Points; Points points : pointsScored) {
    //ToDo...
}

در C++23 با اجازه دادن به اعلان مستعار با استفاده از using در عبارت‌های init، این ناسازگاری را حل می‌کند. این کار انسجام را به ارمغان می‌آورد و به شما امکان می‌دهد از مزایای aliasها در این زمینه‌ها استفاده کنید.

import std;

auto main() -> int {
    
    std::vector pointsScored {27, 41, 32, 23, 28};
    for (using Points = int; Points points : pointsScored) {
        std::println("Compez scored {}", points);
    }
    
}

#cpp20 #cpp23 #alias #چالش #سی‌روزه #رمضان #روز_چهاردهم

بخش تخصصی دوم (به‌روز رسانی Solidity) |کلمهٔ کلیدی delete

کلمهٔ کلیدی حذف (delete) یک مقدار اولیه برای نوع داده مورد نظر به متغیر می‌دهد. به عنوان مثال برای اعداد صحیح، معادل با a = 0 است، اما می‌تواند بر روی آرایه‌ها نیز استفاده شود، جایی که یک آرایه پویا با طول صفر یا یک آرایه استاتیک با همان طول و تمام عناصر به مقدار اولیه خود اختصاص می‌دهد.

برای مثال در این بخش از کد:

delete a[x]

کلمهٔ کلیدی delete، موردی که در شاخص x آرایه قرار دارد را حذف کرده و سایر عناصر و طول آرایه را بدون تغییر باقی می‌گذارد. این به ویژه به این معنا است که یک جای خالی در آرایه باقی می‌ماند. بنابراین، اگر قصد حذف عناصر را دارید، استفاده از یک نگاشت (mapping) احتمالاً انتخاب بهتری است.

برای ساختارها (structs)، یک ساختار با تمام اعضا بازنشانده می‌شود. به عبارت دیگر، مقدار a پس از delete a همانند این است که a بدون اختصاص اعلام شود.
کلمهٔ کلیدی delete تأثیری بر روی نگاشت‌ها (mapping) ندارد (زیرا کلیدهای نگاشت‌ها ممکن است خودکار و در کل ناشناخته باشند). بنابراین اگر یک ساختار را حذف کنید، تمام اعضایی که نگاشت نیستند را بازنشانده می‌کند و همچنین به اعضا داخلی عملیات بازگشتی انجام می‌دهد مگر اینکه آنها نگاشت باشند. با این حال، کلیدها و مقادیر متناظر با آنها قابل حذف هستند: اگر a یک نگاشت باشد، آنگاه delete a[x] مقدار ذخیره شده در x را حذف می‌کند.

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.0 <0.9.0;

contract DeleteExample {
    uint data;
    uint[] dataArray;

    function f() public {
        uint x = data;
        delete x; // sets x to 0, does not affect data
        delete data; // sets data to 0, does not affect x
        uint[] storage y = dataArray;
        delete dataArray; // this sets dataArray.length to zero, but as uint[] is a complex object, also
        // y is affected which is an alias to the storage object
        // On the other hand: "delete y" is not valid, as assignments to local variables
        // referencing storage objects can only be made from existing storage objects.
        assert(y.length == 0);
    }
}

#solidity #web3 #update #ether #اتریوم

در استاندارد ۲۳ ویژگی جدیدی به نام std::move_only_function معرفی شده است که به منظور بهبود کارایی و مدیریت حافظه در برنامه‌ها، به خصوص در مواردی که با انتقال اشیاء بزرگ سرو کار داریم، طراحی شده است.

در واقع std::move_only_function یک کلاس template است که به شما امکان می‌دهد توابعی را تعریف کنید که فقط می‌توانند با اشیاء موقت (rvalue) کار کنند. این نوع توابع قادر به دریافت اشیاء به عنوان lvalue (غیر موقت) نیستند، و در عوض، آنها اشیاء را به طور مستقیم «move» می‌کنند.

- این منجر به افزایش کارایی قابل توجهی در برنامه‌ها، به خصوص در مواردی که با اشیاء بزرگ سروکار داریم، می‌شود. دلیل این امر این است که نیازی به کپی اشیاء در هنگام فراخوانی تابع نیست، و به جای آن، اشیاء به طور مستقیم «move» می‌شوند.
- می‌تواند به مدیریت حافظه کارآمدتر کمک کند، زیرا از ایجاد کپی‌های غیرضروری اشیاء جلوگیری می‌کند.

مثال زیر شامل دو تابع معمولی و با عنوان printValue و تابع جدید با عنوان printValueRvalue را نمایش می‌دهد که در اینجا printValueRvalue یک std::move_only_function است که فقط می‌تواند با اشیاء rvalue کار کند:

import std;

void printValue(int value)
{
    std::println("value: {}", value);
}

std::move_only_function<void(int)> printValueRvalue = [](int value)
{
    std::println("value (rvalue): {}", value);

};

auto main() -> int {

    int x = 10;
    printValue(x);
    printValueRvalue(std::move(x));

}

نکته، منظور از «move»، انتقال مالکیت یک شیء از یک مکان حافظه به مکان دیگر است که در استاندارد سی‌پلاس‌پلاس با std::move شناخته می‌شود.

#cpp20 #cpp23 #move_only_function #چالش #سی‌روزه #رمضان #روز_پانزدهم

بخش تخصصی دوم (به‌روز رسانی Solidity) | نگاشت‌های تکرار پذیر (Iterable Mappings)

در سالیدیتی شما نمی‌توانید روی Mappings (نگاشت‌ها) عمل تکرار را انجام دهید، به عبارت دیگر نمی‌توانید کلیدهای آن‌ها را شمارش کنید. با این حال، امکان پیاده‌سازی یک ساختار داده بر روی آن‌ها و حلقه زدن بر روی آن وجود دارد. به عنوان مثال، کد زیر یک بخش کتابخانه (library) برای IterableMapping پیاده‌سازی می‌کند که پس از آن قرارداد User داده‌ها را به آن اضافه می‌کند، و sum به عنوان تابع، iterates را برای جمع کلیهٔ مقادیر استفاده می‌کند.

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.8;

struct IndexValue { uint keyIndex; uint value; }
struct KeyFlag { uint key; bool deleted; }

struct itmap {
    mapping(uint => IndexValue) data;
    KeyFlag[] keys;
    uint size;
}

type Iterator is uint;

library IterableMapping {
    function insert(itmap storage self, uint key, uint value) internal returns (bool replaced) {
        uint keyIndex = self.data[key].keyIndex;
        self.data[key].value = value;
        if (keyIndex > 0)
            return true;
        else {
            keyIndex = self.keys.length;
            self.keys.push();
            self.data[key].keyIndex = keyIndex + 1;
            self.keys[keyIndex].key = key;
            self.size++;
            return false;
        }
    }

    function remove(itmap storage self, uint key) internal returns (bool success) {
        uint keyIndex = self.data[key].keyIndex;
        if (keyIndex == 0)
            return false;
        delete self.data[key];
        self.keys[keyIndex - 1].deleted = true;
        self.size --;
    }

    function contains(itmap storage self, uint key) internal view returns (bool) {
        return self.data[key].keyIndex > 0;
    }

    function iterateStart(itmap storage self) internal view returns (Iterator) {
        return iteratorSkipDeleted(self, 0);
    }

    function iterateValid(itmap storage self, Iterator iterator) internal view returns (bool) {
        return Iterator.unwrap(iterator) < self.keys.length;
    }

    function iterateNext(itmap storage self, Iterator iterator) internal view returns (Iterator) {
        return iteratorSkipDeleted(self, Iterator.unwrap(iterator) + 1);
    }

    function iterateGet(itmap storage self, Iterator iterator) internal view returns (uint key, uint value) {
        uint keyIndex = Iterator.unwrap(iterator);
        key = self.keys[keyIndex].key;
        value = self.data[key].value;
    }

    function iteratorSkipDeleted(itmap storage self, uint keyIndex) private view returns (Iterator) {
        while (keyIndex < self.keys.length && self.keys[keyIndex].deleted)
            keyIndex++;
        return Iterator.wrap(keyIndex);
    }
}

// How to use it
contract User {
    // Just a struct holding our data.
    itmap data;
    // Apply library functions to the data type.
    using IterableMapping for itmap;

    // Insert something
    function insert(uint k, uint v) public returns (uint size) {
        // This calls IterableMapping.insert(data, k, v)
        data.insert(k, v);
        // We can still access members of the struct,
        // but we should take care not to mess with them.
        return data.size;
    }

    // Computes the sum of all stored data.
    function sum() public view returns (uint s) {
        for (
            Iterator i = data.iterateStart();
            data.iterateValid(i);
            i = data.iterateNext(i)
        ) {
            (, uint value) = data.iterateGet(i);
            s += value;
        }
    }
}

#solidity #web3 #update #ether #اتریوم

به نکتهٔ ریز دیجن دقت کن که چرا فاندرش نمی‌تونه توکن رو مدیریت کنه و مجبوره به زور و تصمیم یه شبه بزنه تارو مار کنه!

۶۰ درصد از حجم مجموعهٔ توکن‌ها رو اختصاص داده به ایردراپ!!! ۱۵ درصد باز برای خود جامعست و ۱۵ درصد هم در بهترین حالت مال سرمایه‌گذار بدبخته!!!

الآن فقط ۳ درصد برای اکوسیستم باقی مونده وبقیش دست کسانی هست که توی ایردراپ شرکت کردن!!! چه فارمر چه آرتیست چه هرکسی!

خب تکلیف چیه؟ وقتی هر بار سر ماه میشه همه هجوم می‌برن برای فروش و نقد کردن چیزی که بیشترین فشار ممکن رو وارد می‌کنه.

خب نتیجش میشه همینی که الآن هست! کسانی که اوایل بودن خوردن فرار کردن! فارمر‌ها عشقشو بردن! الآن اون ته مونده‌ها امثال من و شما که خود اکوسیستم هستیم رو هوا داریم دنبال پرتقال فروش می‌گردیم.

تعادل باید وجود داشته باشه!

وقتی بیشترین دارایی رو اختصاص دادی به ایردراپ معلومه که به زور هم مجبور می‌شی به ملت بگی لاک کنید یا بزنی بنشون کنی!

از پایه و اساس بخش تخصیص دادن توکن‌ها اشتباه بوده و این منجر به فشار فروش در هر ماه میشه که وقتی به کندل‌ها هم دقت کنی همین رو دارن می‌گن.

ولی من معتقدم هر چیزی در زمان خودش رخ میده! این‌ها تجربیات خوبی هستن. 😉

میزان درصد تخصیصش خیلی بالاست! وحشتناک بالاست.
حالا تنها موضوع امیدوار کنندش اینه که این ایردراپ‌بازی‌ها تقریباً کمتر بشه یا حتی توکن‌سازی صورت بگیره و تعداد توکن در چرخش برگرده دست تریدر‌ها وسرمایه گذار‌هایی که قراره از این به بعد بیان تو بازار که این هم زمانی ممکنه که بازار حجم خوبی بخوره!

در کل پروژه نمرده اما وضعیت فعلیش هم به دلیل آزاد سازی گستردهٔ توکن هست! برگشتن به حالت‌های ایده‌آلش نیاز به ورود سرمایه سنگین به کل بازار کریپتو داره که همه امیدوار بودن آلت‌سیزن این رو حل می‌کنه! اما خب کو اتریوم ۵ هزار دلاری؟! 😁 اگه هنوز هم هولدرش هستید به نظر من وقتی بازار حجم خوبی بخوره همه اینارو میشه جبران شده دید. فقط صبر! ⚡️

GM

https://warpcast.com/compez.eth/0xa47254a7

تصویر + توضیح از هنرت رو بذار ببینیم چی به چیه...

https://warpcast.com/compez.eth/0xf86a1126

در استاندارد ۲۳ ویژگی std::forward_like یک الگوی تابعی است که به انتقال دسته‌بندی مقادیر (value category) در سناریوهای مختلف کمک می‌کند.

منظور از Value Category به نوع ارزش (value) یا مرجع (reference) یک شیء در ++C اشاره دارد. این موضوع به نحوهٔ استفاده از شیء در کد شما و نحوهٔ ارسال آن به توابع و عبارات مختلف مربوط می‌شود. که به صورت زیر دسته‌بندی می‌شوند:

- نوع Lvalue
به موقعیتی در حافظه اشاره می‌کند که می‌تواند مورد تغییر قرار بگیرد و می‌تواند شامل متغیرها، عناصر آرایه، مقادیر عضو کلاس و عبارات (مانند x + y) باشد.

- نوع Rvalue
به یک مقدار موقت (temporary value) اشاره می‌کند که قابل تغییر نیست و می‌تواند شامل مقادیر برگشتی توابع، نتایج عبارات (مانند "Hello" + "World") و مقادیر موقت ایجاد شده توسط اپراتورها باشد.

- نوع Xvalue
نوع خاصی از Rvalue است که فقط در موارد خاص مانند انتقال مالکیت (move semantics) استفاده می‌شود.

به طور کلی تابع جدید std::forward_like تابعی مشابه std::forward است، با این تفاوت که کنترل دقیق‌تری بر دسته‌بندی مقادیر (lvalue، rvalue، xvalue) بدون تغییر نوع خود ارائه می‌دهد و در سرآیند <utility> موجود است. قبل از ۲۳، انتقال عبارات عضو در یک تابع می‌توانست دشوار باشد، به‌ویژه برای (move semantics) دشوار‌تر بود که در این به‌روز رسانی std::forward_like این کار را ساده‌تر می‌کند.

- ویژگی std::forward به شما کمک می‌کند آرگومان را به گونه‌ای منتقل کنید که نوع اصلی آن حفظ شود.
- ویژگی std::forward_like به شما کمک می‌کند تا آرگومان را به گونه‌ای منتقل کنید که نوع عبارت دیگری را تقلید کند و آن را با نوع اصلی آن عبارت سازگار نگه دارد.

در ++C، نوع یک شیء می‌تواند به عنوان یک lvalue (مرجع) یا rvalue (مقدار موقت) در نظر گرفته شود. و در اینجا std::forward_like تضمین می‌کند که آرگومان با ارزش صحیح (lvalue یا rvalue) ارسال شود.

کلاس زیر را در نظر بگیرید که دو تابع get_value و get_value_ref را دارد:

import std;

class Data {
public:
    int get_value() const { return m_value; }
    int& get_value_ref() { return m_value; }
private:
    int m_value = 42;
};

auto main() -> int {

    Data data;

    int value = std::forward_like<decltype(data)>(data).get_value();
    std::println("value: {}", value);

    int& ref = std::forward_like<decltype(data)&>(data).get_value_ref();
    ref = 100;
    std::println("value: {}", data.get_value());
}

در تابع main عبارت std::forward_like برای ارسال آرگومان data با حفظ نوع (lvalue در این مورد) استفاده شده است.


#cpp20 #cpp23 #forward_like #forward #چالش #سی‌روزه #رمضان #روز_شانزدهم

بخش تخصصی دوم (به‌روز رسانی Solidity) | تبدیل ضمنی (Implicit Conversions)

در سالدیتی، تبدیل نوع ضمنی به طور خودکار توسط کامپایلر در برخی موارد در زمان اختصاص، هنگام ارسال آرگومان‌ها به توابع و زمان اعمال اپراتورها اتفاق می‌افتد. به طور کلی، تبدیل نوع ضمنی بین انواع مقادیر امکان‌پذیر است اگر از نظر معنایی منطقی باشد و هیچ اطلاعاتی از دست نرود.

به عنوان مثال، uint8 به uint16 و int128 به int256 قابل تبدیل است، اما int8 قابل تبدیل به uint256 نیست، زیرا uint256 نمی‌تواند مقادیری مانند 1- را نگه دارد.

اگر یک اپراتور به انواع مختلفی اعمال شود، کامپایلر سعی می‌کند یکی از عملوندها را به طور ضمنی به نوع دیگر تبدیل کند (همین موضوع برای اختصاص نیز صحیح است). این بدان معناست که عملیات همیشه با توجه به نوع یکی از عملوند‌‌ها انجام می‌شود.

در مثال زیر، y و z که عملوند‌های جمع هستند، از همان نوع نیستند، اما uint8 به طور ضمنی قابل تبدیل به uint16 است و بالعکس نیست. به همین دلیل، y قبل از انجام جمع در نوع uint16 تبدیل می‌شود. نوع نتیجه‌ٔ عبارت y + z و uint16 است. بعد از انجام جمع، به یک متغیر از نوع uint32 تبدیل نوعی دیگر نهانی صورت می‌گیرد.

uint8 y;
uint16 z;
uint32 x = y + z;

#solidity #web3 #update #ether #اتریوم

هعی دنیا! عجب دنیایی شده این حوزهٔ وب ۳ 😄
اونا همیشه با من رقابت می‌کنن، اما من هنوز تو بهترین نسخهٔ خودم نیستم! 😉😒👊🏼

Genetic Mutation Style (B/W)

https://warpcast.com/compez.eth/0x278e8894

نمی‌دونم چی شد ولی یه حرکتی زدم نوتیفیکیشن‌هام ترکید! 👀

والا هنوز هیچ چیزی رونمایی نکردیم ما 😄