Что нужно сделать перед тем, как выложить код открытого программного обеспечения

> «мне всё пофиг, пользуйтесь как хотите»

Такой подход может сильно помешать использованию кода людьми, которые не хотят нарушать закон.

Ненавижу, когда говорят «опен сорс»

В случае гитхаба — можно только читать и клонировать. Собирать/тестировать без разрешения, видимо, уже может быть незаконно) Использовать где-то без разрешения — тем более.

Ненавижу, когда говорят «опен сорс»

Ха. А если зарезать и ограбить человека в темном переулке и спрятать труп, то никто ничего не запретит.

Ненавижу, когда говорят «опен сорс»

О.о ээээ

И как можно запретить пользоваться опубликованным кодом?

Не разрешать просто.

https://ru.wikipedia.org/wiki/Лицензия

https://ru.wikipedia.org/wiki/Авторское_право

http://stackoverflow.com/questions/5521080/can-i-use-the-code-in-a-github-project-which-does-not-have-a-license-specified

CoLaboratory: Rust — поговорим о Rust в «Лаборатории Касперского» 17 мая

по ссылке: "Регистрация на событие закрыта"

Rust, дисциплинирующий язык программирования

Дело тихонько двинулось, кажется: http://smallcultfollowing.com/babysteps/blog/2016/04/27/non-lexical-lifetimes-introduction/

Rust через его основополагающие принципы

Упрощает грамматику языка, убирает неоднозначности. Слоты аргументов в сигнатуре создают контекст сопоставления (аналогично с let), так что не надо вводить лишнюю сущность в грамматику.
Так что можно писать, если вдруг надо, всякое странное:

struct S { a: u8, b: u8, c: u8 }

fn f(S{c, ..}: S) {
    println!("c={}", c);
}

https://play.rust-lang.org/?gist=dc15c72441ad9d9371f68080790637e5
Ну и не так мало людей считают, что так читаемость улучшается, но это уже вкусовщина.

Rust через его основополагающие принципы

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

Хотя конкретно в этой главе, которую, если не ошибаюсь, уже кучу раз переписывали, мотивация не так плохо показана.

man!(D => Rust).basics

Оно досталось внаследство от функциональщины, того же OCaml, насколько я помню.
Плюсы:

• помогает убрать изменяемость объекта без лишнего блока, иногда очень удобно.
  
• хорошо сочетается с семантикой перемещения — let foo = foo.unwrap();.
  
• если что-то пошло не так, то ты почти всегда получишь предупреждение о неиспользованной затененной переменной.
  
• ну и уж если совсем не нравится, то для своего проекта можно clippy подтянуть, в нем три проверки есть (по умолчанию все выключены):
  

  shadow_reuse — rebinding a name to an expression that re-uses the original value, e.g. let x = x + 1
  shadow_same — rebinding a name to itself, e.g. let mut x = &mut x
  shadow_unrelated — The name is re-bound without even using the original value
  

  
  

Rust через его основополагающие принципы

вообще с одной стороны GC нужен, тк есть огромный клас задач не требовательных к ресурсам. Да и некоторые алгоритмы значительно легчи написать с GC.

Как по мне, если для удобного решения задачи Rc не хватает, то лучше такое на другом языке это дело и написать.

Rust через его основополагающие принципы

Через Cell или RefCell скорее. Но, в любом случае, в статье же о работе по умолчанию говорится.

Rust через его основополагающие принципы

> Насколько я знаю в rust будет добавляться garbage collector

Меня эта перспектива очень смущает до сих пор, все надеюсь что откажутся. Не верю я, что на такой стадии получится гладко в язык вписать GC (статьи про текущий попытки это сделать лично мне ужасают количеством тонкостей) и сильно побаиваюсь разделения crates.io на два лагеря и вытекающие из этого сложности.

Rust через его основополагающие принципы

RustType, как я понимаю, написан с нуля на ржавчине, просто с сильным поглядыванием на структуры и алгоритмы stb_truetype. А потом проект несколько в сторону уходит и своих фишек уже добавляет.

А вот github.com/PistonDevelopers/truetype — это именно порт stb_truetype. У них там, особенно если в историю залезть, вообще все в unsafe и сырых указателях, которые они мееедленно вычищают. И до сих пор не вычистили. Так что портирование подобного сишного кода выглядит довольно трудоемко.

Rust через его основополагающие принципы

Интересно насколько возможно полуавтоматическое портирование с java, или C.

В идиоматичный код, наверное, не возможно. Все-таки система владения/одалживания требует специфической структуризации кода.

Rust через его основополагающие принципы

Мне кажется, вся статья как раз и намекает, почему синтаксически ржавчина идет не по "пути D или C#". У языков приоритеты сильно отличаются.

Rust через его основополагающие принципы

Про &String в clippy даже предупреждение есть: https://github.com/Manishearth/rust-clippy/wiki#ptr_arg

Rust через его основополагающие принципы

Мне в этой статье только немного странно, зачем на примере строк это показывать, раз до &str дело не доходит и он даже не упоминается. И тут никак не объясняется, почему в одном месте (println!) мы используем просто строковый литерал, а в других местах мы делаем String::from. Лучше было бы тогда, как мне кажется, завести структуру с каким-нибудь u8 полем и ее мучать, а то String/&str — это известное больное место для знакомящихся с языком.

man!(D => Rust).basics

a as i64

Вот, кстати, что это, что cast(long) a — одинаково не удобны в выражениях, в отличие от a.to!long

Они и должны быть громоздкими и обращающими на себя внимание, как по мне. Это ж преобразования типов — в этом месте легко вносятся логические ошибки.

man!(D => Rust).basics

Ага, я об этом подумал уже когда запостил и даже накидал аналогичную версию 3.0, но потом решил что не очень клево превращать комментарии к статье в git)

man!(D => Rust).basics

Вот даже 2.0, а то чего-то я параметры макроса не использовал:

use std::collections::HashMap;

#[derive(PartialEq, Eq, Hash)]
enum Lang {
    Go,
    D,
    Rust,
}

struct Info {
    basics: &'static str,
    concurrency: &'static str,
}

macro_rules! man {
    ($lang1:ident => $lang2:ident) => {{
        let mut db = HashMap::new();
        db.insert((Lang::Go, Lang::D), Info {
            basics: "https://habrahabr.ru/post/279657",
            concurrency: "https://habrahabr.ru/post/280378",
        });
        db.insert((Lang::D, Lang::Rust), Info {
            basics: "https://habrahabr.ru/post/280642",
            concurrency: "TODO: DarkEld3r еще не написал",
        });
        db.remove(&(Lang::$lang1, Lang::$lang2)).unwrap()
    }}
}

fn main() {
    println!("Go => D basics: {}", man!(Go => D).basics);
    println!("Go => D concurrency: {}", man!(Go => D).concurrency);
    println!("D => Rust basics: {}", man!(D => Rust).basics);
    println!("D => Rust concurrency: {}", man!(D => Rust).concurrency);
}

play.rust-lang
Эх, вечно я над всякой ерундой залипаю.