rustup target add aarch64-linux-android armv7-linux-androideabi i686-linux-android x86_64-linux-android
rustup target add aarch64-apple-ios x86_64-apple-ios

В ответ на намерение Алмейда создать обвязку над написанными на языке Си интерфейсами файловых систем для их использования в коде на языке Rust, Тед Цо указал на то, что подобная обвязка неминуемо приведёт к проблемам, так как любое изменение Си-интерфейсов и проведение рефакторинга потребует изменения обвязки для Rust и он не хочет брать на себя лишней ответственности за исправление возникающих проблем в коде на Rust и отслеживании состояния Rust-обвязки. Код на Си постоянно развивается и если его изменение нарушит работу обвязки для Rust, это приведёт к нарушению работы и всех завязанных на эту обвязку файловых систем.

Тед также считает, что в обозримом будущем обвязка для Rust останется второстепенной и возникновение проблем в биндингах будет головной болью только для разработчиков Rust-for-Linux, а не для сообщества разработчиков файловых систем в ядре. Указано, что не все разработчики собираются изучать Rust и поэтому после внесения влияющих на другой код изменений, они смогут обновить только зависящий код на Си, но не смогут исправить Rust-обвязки, так как не знают Rust. К дискуссии также присоединился Джеймс Боттомли (James Bottomley), сопровождающий подсистему SCSI, который сказал, что чем больше семантики кодируется в обвязках, тем они становятся более ломкими с точки зрения обеспечения синхронизации.

Несколько рецензентов просили меня сравнить C++ с другими языками. Но я решил этого не делать. Ещё раз выскажу свою неизменную точку зрения: сравнение языков редко бывает осмысленным, а ещё реже честным. Для хорошего сравнительного анализа основных языков программирования требуется больше времени, чем можно себе позволить, нужно иметь опыт работы во многих прикладных областях, быть беспристрастным и объективным. Времени у меня нет, и вряд ли я, как создатель C++, могу рассчитывать, что многие поверят в мою беспристрастность по этому поводу.

Ещё меня беспокоит некий феномен, который я неоднократно наблюдал, когда другие пытались заняться честным сравнением языков. Авторы изо всех сил стараются быть объективными, но обязательно делают упор на каком-то одном виде приложений, одном стиле или определённой культуре программирования. А уж если один язык более известен, чем другой, то в оценке чуть ли изначально возникает некая предубежденность: дефекты хорошо известного языка признаются несущественными, для них предлагаются простые способы обхода, тогда как аналогичные изъяны в других языках объявляются фундаментальными проблемами. Но ведь часто бывает, что в менее популярном языке давно известны методы решения подобных задач, только автор сравнительного обзора о них не знает или считает неудовлетворительными, поскольку в знакомом ему языке они работать не будут.

Я не боюсь того, кто изучает 10'000 различных языков программирования.
Я боюсь того, кто изучает один язык программирования 10'000 раз.

Вместо адресации через URL (например, для записи в лог мог использоваться URL "log://", а для сетевого взаимодействия "tcp://") задействован традиционный для Unix-систем формат файловых путей, что положительно повлияло на совместимость с программами и библиотеками POSIX/Linux.

trait SomeUsefulInterface {
  ... // Набор методов.
}

trait SomeUsefulInterfaceFactory {
  fn create(&mut self) -> Box<dyn SomeUsefulInterface>;
}

fn getCurrentFactory() -> Box<dyn SomeUsefulInterfaceFactory>;

Software Rendering
We don't have GPU drivers yet but LLVMpipe (OpenGL CPU emulation) is working.

язык без ООП даже рассматривать не стоит

#include <iostream>

#include <stdexcept>
#include <utility>
#include <iterator>  // для std::iterator

template<typename T>
class SimpleVector {
private:
    T* _data; // Тип должен быть T*, а не uint8_t*
    uint8_t _size;
    uint8_t _capacity;
    
public:
    SimpleVector() : _size(0), _capacity(10)
    {
        _data = new T[_capacity]; // Соответствует типу T
    }
    
    ~SimpleVector()
    {
        delete[] _data;
    }
    
    SimpleVector(const SimpleVector& other) : _size(other._size), _capacity(other._capacity)
    {
        _data = new T[_capacity];
        for (uint8_t i = 0; i < _size; ++i)
        {
            _data[i] = other._data[i];
        }
    }
    
    SimpleVector& operator=(const SimpleVector& other)
    {
        if (this == &other) return *this;
        
        delete[] _data;
        
        _size = other._size;
        _capacity = other._capacity;
        _data = new T[_capacity];
        
        for (uint8_t i = 0; i < _size; ++i)
        {
            _data[i] = other._data[i];
        }
        
        return *this;
    }
    
    SimpleVector(SimpleVector&& other) noexcept(std::is_nothrow_move_constructible<T>::value)
    : _data(other._data), _size(other._size), _capacity(other._capacity)
    {
        other._data = nullptr;
        other._size = 0;
        other._capacity = 0;
    }
    
    SimpleVector& operator=(SimpleVector&& other) noexcept(std::is_nothrow_move_constructible<T>::value)
    {
        if (this == &other) return *this;
        
        delete[] _data;
        
        _data = other._data;
        _size = other._size;
        _capacity = other._capacity;
        
        other._data = nullptr;
        other._size = 0;
        other._capacity = 0;
        
        return *this;
    }
    
    T& operator[](uint8_t index)
    {
        if (index >= _size) throw std::out_of_range("Index out of range");
        return _data[index];
    }
    
    void pushBack(const T& value)
    {
        if (_size == _capacity) resize();
        _data[_size++] = value;
    }
    
    uint8_t size() const
    {
        return _size;
    }
    
    uint8_t capacity() const
    {
        return _capacity;
    }
    
    // Итератор (неконстантный)
    class iterator {
    private:
        T* _ptr;
        
    public:
        using iterator_category = std::random_access_iterator_tag;
        using value_type = T;
        using difference_type = std::ptrdiff_t;
        using pointer = T*;
        using reference = T&;
        
        explicit iterator(T* ptr) : _ptr(ptr) {}
        
        T& operator*() const
        {
            return *_ptr;
        }
        
        iterator& operator++()
        {
            _ptr++;
            return *this;
        }
        
        iterator operator++(int)
        {
            iterator temp = *this;
            ++(*this);
            return temp;
        }
        
        iterator& operator--()
        {
            _ptr--;
            return *this;
        }
        
        iterator operator--(int)
        {
            iterator temp = *this;
            --(*this);
            return temp;
        }
        
        bool operator==(const iterator& other) const
        {
            return _ptr == other._ptr;
        }
        
        bool operator!=(const iterator& other) const
        {
            return _ptr != other._ptr;
        }
        
        iterator operator+(difference_type n) const
        {
            return iterator(_ptr + n);
        }
        
        iterator operator-(difference_type n) const
        {
            return iterator(_ptr - n);
        }
        
        difference_type operator-(const iterator& other) const
        {
            return _ptr - other._ptr;
        }
    };
    
    // Константный итератор
    class const_iterator {
    private:
        const T* _ptr;
        
    public:
        using iterator_category = std::random_access_iterator_tag;
        using value_type = T;
        using difference_type = std::ptrdiff_t;
        using pointer = const T*;
        using reference = const T&;
        
        explicit const_iterator(const T* ptr) : _ptr(ptr) {}
        
        const T& operator*() const
        {
            return *_ptr;
        }
        
        const_iterator& operator++()
        {
            _ptr++;
            return *this;
        }
        
        const_iterator operator++(int)
        {
            const_iterator temp = *this;
            ++(*this);
            return temp;
        }
        
        const_iterator& operator--()
        {
            _ptr--;
            return *this;
        }
        
        const_iterator operator--(int)
        {
            const_iterator temp = *this;
            --(*this);
            return temp;
        }
        
        bool operator==(const const_iterator& other) const
        {
            return _ptr == other._ptr;
        }
        
        bool operator!=(const const_iterator& other) const
        {
            return _ptr != other._ptr;
        }
        
        const_iterator operator+(difference_type n) const
        {
            return const_iterator(_ptr + n);
        }
        
        const_iterator operator-(difference_type n) const
        {
            return const_iterator(_ptr - n);
        }
        
        difference_type operator-(const const_iterator& other) const
        {
            return _ptr - other._ptr;
        }
    };
    
    // Методы для получения итераторов
    iterator begin()
    {
        return iterator(_data);
    }
    
    iterator end()
    {
        return iterator(_data + _size);
    }
    
    const_iterator begin() const
    {
        return const_iterator(_data);
    }
    
    const_iterator end() const
    {
        return const_iterator(_data + _size);
    }
    
    const_iterator cbegin() const
    {
        return const_iterator(_data);
    }
    
    const_iterator cend() const
    {
        return const_iterator(_data + _size);
    }
    
private:
    void resize()
    {
        _capacity *= 2;
        T* newData = new T[_capacity];
        for (uint8_t i = 0; i < _size; ++i)
        {
            newData[i] = _data[i];
        }
        delete[] _data;
        _data = newData;
    }
};


int main(int argc, const char * argv[]) {
    // Создаем вектор с элементами типа int
    SimpleVector<int> vec;
    
    // Добавляем несколько элементов
    vec.pushBack(10);
    vec.pushBack(20);
    vec.pushBack(30);
    
    // Выводим элементы с помощью индекса
    std::cout << "Элементы вектора (индексация):" << std::endl;
    for (uint8_t i = 0; i < vec.size(); ++i)
    {
        std::cout << vec[i] << " ";
    }
    std::cout << std::endl;
    
    // Используем итератор для вывода элементов
    std::cout << "Элементы вектора (итератор):" << std::endl;
    for (auto it = vec.begin(); it != vec.end(); ++it)
    {
        std::cout << *it << " ";
    }
    std::cout << std::endl;
    
    // Используем range-based for для вывода элементов
    std::cout << "Элементы вектора (range-based for):" << std::endl;
    for (const auto& elem : vec)
    {
        std::cout << elem << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

S>    void resize()
S>    {
S>        _capacity *= 2;
S>        T* newData = new T[_capacity];
S>        for (uint8_t i = 0; i < _size; ++i)
S>        {
S>            newData[i] = _data[i];
S>        }
S>        delete[] _data;
S>        _data = newData;
S>    }
S>

SimpleVector<int> first;
first.pushBack(1);
first.pushBack(2);
SimpleVector<int> second{std::move(first)};
first.pushBack(3);

std::vector<int> a{...};
std::vector<int> b{ std::move(a) };

std::vector<int> a{...};
std::vector<int> b;
b.reserve(a.size());
std::move(a.begin(), a.end(), std::back_inserter(b));
a.clear();
a.shrink_to_fit();