ਜੰਗਾਲ 1.53 ਜਾਰੀ ਕੀਤਾ ਗਿਆ। Google ਲੀਨਕਸ ਕਰਨਲ ਵਿੱਚ Rust ਸਮਰਥਨ ਜੋੜਨ ਲਈ ਫੰਡ ਦੇਵੇਗਾ

ਸਿਸਟਮ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ Rust 1.53 ਦੀ ਰਿਲੀਜ਼, ਜੋ ਕਿ ਮੋਜ਼ੀਲਾ ਪ੍ਰੋਜੈਕਟ ਦੁਆਰਾ ਸਥਾਪਿਤ ਕੀਤੀ ਗਈ ਸੀ, ਪਰ ਹੁਣ ਸੁਤੰਤਰ ਗੈਰ-ਲਾਭਕਾਰੀ ਸੰਸਥਾ ਰਸਟ ਫਾਊਂਡੇਸ਼ਨ ਦੀ ਸਰਪ੍ਰਸਤੀ ਹੇਠ ਵਿਕਸਤ ਕੀਤੀ ਗਈ ਹੈ, ਪ੍ਰਕਾਸ਼ਿਤ ਕੀਤੀ ਗਈ ਹੈ। ਭਾਸ਼ਾ ਮੈਮੋਰੀ ਸੁਰੱਖਿਆ 'ਤੇ ਕੇਂਦ੍ਰਤ ਕਰਦੀ ਹੈ, ਆਟੋਮੈਟਿਕ ਮੈਮੋਰੀ ਪ੍ਰਬੰਧਨ ਪ੍ਰਦਾਨ ਕਰਦੀ ਹੈ, ਅਤੇ ਕੂੜਾ ਇਕੱਠਾ ਕਰਨ ਵਾਲੇ ਜਾਂ ਰਨਟਾਈਮ ਦੀ ਵਰਤੋਂ ਕੀਤੇ ਬਿਨਾਂ ਉੱਚ ਕਾਰਜ ਸਮਾਨਤਾ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਦੇ ਸਾਧਨ ਪ੍ਰਦਾਨ ਕਰਦੀ ਹੈ (ਰਨਟਾਈਮ ਨੂੰ ਮਿਆਰੀ ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਮੁੱਢਲੀ ਸ਼ੁਰੂਆਤ ਅਤੇ ਰੱਖ-ਰਖਾਅ ਤੱਕ ਘਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ)।

ਜੰਗਾਲ ਦਾ ਆਟੋਮੈਟਿਕ ਮੈਮੋਰੀ ਪ੍ਰਬੰਧਨ ਪੁਆਇੰਟਰਾਂ ਦੀ ਹੇਰਾਫੇਰੀ ਕਰਦੇ ਸਮੇਂ ਗਲਤੀਆਂ ਨੂੰ ਦੂਰ ਕਰਦਾ ਹੈ ਅਤੇ ਘੱਟ-ਪੱਧਰੀ ਮੈਮੋਰੀ ਹੇਰਾਫੇਰੀ ਤੋਂ ਪੈਦਾ ਹੋਣ ਵਾਲੀਆਂ ਸਮੱਸਿਆਵਾਂ ਤੋਂ ਬਚਾਉਂਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਮੈਮੋਰੀ ਖੇਤਰ ਨੂੰ ਖਾਲੀ ਹੋਣ ਤੋਂ ਬਾਅਦ ਐਕਸੈਸ ਕਰਨਾ, ਨਲ ਪੁਆਇੰਟਰ ਡੀਰੇਫਰੈਂਸ, ਬਫਰ ਓਵਰਰਨ, ਆਦਿ। ਲਾਇਬ੍ਰੇਰੀਆਂ ਨੂੰ ਵੰਡਣ, ਅਸੈਂਬਲੀ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਅਤੇ ਨਿਰਭਰਤਾ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨ ਲਈ, ਪ੍ਰੋਜੈਕਟ ਕਾਰਗੋ ਪੈਕੇਜ ਮੈਨੇਜਰ ਨੂੰ ਵਿਕਸਤ ਕਰ ਰਿਹਾ ਹੈ। crates.io ਰਿਪੋਜ਼ਟਰੀ ਹੋਸਟਿੰਗ ਲਾਇਬ੍ਰੇਰੀਆਂ ਲਈ ਸਮਰਥਿਤ ਹੈ।

ਮੁੱਖ ਨਵੀਨਤਾਵਾਂ:

• ਐਰੇ ਲਈ, IntoIterator ਵਿਸ਼ੇਸ਼ਤਾ ਨੂੰ ਲਾਗੂ ਕੀਤਾ ਗਿਆ ਹੈ, ਜੋ ਤੁਹਾਨੂੰ ਮੁੱਲਾਂ ਦੁਆਰਾ ਐਰੇ ਐਲੀਮੈਂਟਸ ਦੇ ਦੁਹਰਾਅ ਨੂੰ ਸੰਗਠਿਤ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ: i ਵਿੱਚ [1, 2, 3] {.. }

  ਐਰੇ ਨੂੰ ਉਹਨਾਂ ਤਰੀਕਿਆਂ ਲਈ ਪਾਸ ਕਰਨਾ ਵੀ ਸੰਭਵ ਹੈ ਜੋ ਦੁਹਰਾਓ ਨੂੰ ਸਵੀਕਾਰ ਕਰਦੇ ਹਨ, ਉਦਾਹਰਨ ਲਈ: let set = BTreeSet::from_iter([1, 2, 3]); ਲਈ (a, b) some_iterator.chain([1]).zip([1, 2, 3]) ਵਿੱਚ { .. }

  ਪਹਿਲਾਂ, IntoIterator ਨੂੰ ਸਿਰਫ ਐਰੇ ਸੰਦਰਭਾਂ ਲਈ ਲਾਗੂ ਕੀਤਾ ਗਿਆ ਸੀ, ਜਿਵੇਂ ਕਿ. ਮੁੱਲਾਂ ਨੂੰ ਦੁਹਰਾਉਣ ਲਈ ਸੰਦਰਭਾਂ (“&[1, 2, 3]”) ਜਾਂ “[1, 2, 3].iter()” ਦੀ ਵਰਤੋਂ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਐਰੇ ਲਈ IntoIterator ਨੂੰ ਲਾਗੂ ਕਰਨ ਵਿੱਚ array.into_iter() ਤੋਂ (&array).into_iter() ਵਿੱਚ ਪਹਿਲਾਂ ਦੇ ਕੰਪਾਈਲਰ ਪਰਿਵਰਤਨ ਕਾਰਨ ਅਨੁਕੂਲਤਾ ਸਮੱਸਿਆਵਾਂ ਕਾਰਨ ਰੁਕਾਵਟ ਆਈ ਸੀ। ਇਹਨਾਂ ਸਮੱਸਿਆਵਾਂ ਦਾ ਹੱਲ ਇੱਕ ਹੱਲ ਨਾਲ ਕੀਤਾ ਗਿਆ ਸੀ - ਕੰਪਾਈਲਰ array.into_iter() ਨੂੰ (&array).into_iter() ਵਿੱਚ ਬਦਲਣਾ ਜਾਰੀ ਰੱਖੇਗਾ ਜਿਵੇਂ ਕਿ IntoIterator ਵਿਸ਼ੇਸ਼ਤਾ ਨੂੰ ਲਾਗੂ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਸੀ, ਪਰ ਸਿਰਫ ".into_iter( ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਢੰਗ ਨੂੰ ਕਾਲ ਕਰਨ ਵੇਲੇ। )" ਸੰਟੈਕਸ ਅਤੇ "[1, 2, 3] ਵਿੱਚ", "iter.zip([1, 2, 3])", "IntoIterator::into_iter([1, 2, 3]) ਵਿੱਚ ਕਾਲਾਂ ਨੂੰ ਛੂਹਣ ਤੋਂ ਬਿਨਾਂ )"।

• ਸਮੀਕਰਨ ਨਿਰਧਾਰਤ ਕਰਨਾ ਸੰਭਵ ਹੈ “|” ਟੈਂਪਲੇਟ ਦੇ ਕਿਸੇ ਵੀ ਹਿੱਸੇ ਵਿੱਚ (ਲਾਜ਼ੀਕਲ ਜਾਂ ਕਾਰਵਾਈ), ਉਦਾਹਰਨ ਲਈ, “Some(1) | ਕੁਝ(2)" ਤੁਸੀਂ ਹੁਣ "ਕੁਝ(1 | 2)" ਲਿਖ ਸਕਦੇ ਹੋ: ਮੈਚ ਨਤੀਜਾ { Ok(Some(1 | 2)) => { .. } Err(MyError { ਕਿਸਮ: FileNotFound | ਇਜਾਜ਼ਤ ਤੋਂ ਇਨਕਾਰ, .. }) => { .. } _ => { .. } }
• ਪਛਾਣਕਰਤਾਵਾਂ ਵਿੱਚ ਗੈਰ-ASCII ਅੱਖਰਾਂ ਦੀ ਵਰਤੋਂ ਦੀ ਇਜਾਜ਼ਤ ਹੈ, ਜਿਸ ਵਿੱਚ ਯੂਨੀਕੋਡ UAX 31 ਨਿਰਧਾਰਨ ਵਿੱਚ ਪਰਿਭਾਸ਼ਿਤ ਕੋਈ ਵੀ ਰਾਸ਼ਟਰੀ ਅੱਖਰ ਸ਼ਾਮਲ ਹਨ, ਪਰ ਇਮੋਜੀ ਅੱਖਰਾਂ ਨੂੰ ਛੱਡ ਕੇ। ਜੇਕਰ ਤੁਸੀਂ ਵੱਖਰੇ ਪਰ ਇੱਕੋ ਜਿਹੇ ਅੱਖਰ ਵਰਤਦੇ ਹੋ, ਤਾਂ ਕੰਪਾਈਲਰ ਇੱਕ ਚੇਤਾਵਨੀ ਜਾਰੀ ਕਰੇਗਾ। const BLÅHAJ: &str = "🦈"; struct 人 { 名字: ਸਤਰ, } let α = 1; let'os = 2; ਚੇਤਾਵਨੀ: ਪਛਾਣਕਰਤਾ ਜੋੜਾ 'ｓ' ਅਤੇ 's' ਵਿਚਕਾਰ ਉਲਝਣਯੋਗ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ
• API ਦੇ ਇੱਕ ਨਵੇਂ ਹਿੱਸੇ ਨੂੰ ਸਥਿਰ ਸ਼੍ਰੇਣੀ ਵਿੱਚ ਤਬਦੀਲ ਕਰ ਦਿੱਤਾ ਗਿਆ ਹੈ, ਜਿਸ ਵਿੱਚ ਹੇਠਾਂ ਦਿੱਤੇ ਸਥਿਰ ਸ਼ਾਮਲ ਹਨ:
  • ਐਰੇ::from_ref
  • ਐਰੇ::from_mut
  • AtomicBool::fetch_update
  • AtomicPtr::fetch_update
  • BTreeSet::retain
  • BTreeMap:: ਬਰਕਰਾਰ ਰੱਖੋ
  • BfReader::seek_relative
  • cmp::min_by
  • cmp::min_by_key
  • cmp::max_by
  • cmp::max_by_key
  • DebugStruct::finish_non_exhaustive
  • ਮਿਆਦ::ZERO
  • ਮਿਆਦ::MAX
  • ਮਿਆਦ:: is_zero
  • ਮਿਆਦ::ਸੰਤ੍ਰਿਪਤ_ਜੋੜੋ
  • ਮਿਆਦ::ਸੰਤ੍ਰਿਪਤ_ਸਬ
  • ਮਿਆਦ:: ਸੰਤ੍ਰਿਪਤ_mul
  • f32::is_subnormal
  • f64::is_subnormal
  • ਐਰੇ ਲਈ IntoIterator
  • {ਅੰਕ}::ਬਿਟਸ
  • io::ਗਲਤੀ::ਅਸਮਰਥਿਤ
  • ਗੈਰ-ਜ਼ੀਰੋ*::ਲੀਡਿੰਗ_ਜ਼ੀਰੋ
  • ਗੈਰ-ਜ਼ੀਰੋ*::ਟ੍ਰੇਲਿੰਗ_ਜ਼ੀਰੋ
  • ਵਿਕਲਪ:: ਪਾਓ
  • ਆਰਡਰਿੰਗ::is_eq
  • ਆਰਡਰਿੰਗ::is_ne
  • ਆਰਡਰਿੰਗ::is_lt
  • ਆਰਡਰਿੰਗ::is_gt
  • ਆਰਡਰਿੰਗ::is_le
  • ਆਰਡਰਿੰਗ::is_ge
  • OsStr::make_ascii_lowercase
  • OsStr::make_ascii_uppercase
  • OsStr::to_ascii_lowercase
  • OsStr::to_ascii_ਅੱਪਰਕੇਸ
  • OsStr::is_ascii
  • OsStr::eq_ignore_ascii_case
  • ਪੀਕਬਲ::ਪੀਕ_ਮਟ
  • Rc::increment_strong_count
  • Rc::decrement_strong_count
  • ਟੁਕੜਾ::IterMut::as_slice
  • AsRef<[T]> ਟੁਕੜੇ ਲਈ::IterMut
  • impl SliceIndex for (Bound , ਬੰਧੂਆ )
  • Vec::extend_from_within
• wasm64-ਅਣਜਾਣ-ਅਣਜਾਣ ਪਲੇਟਫਾਰਮ ਲਈ ਸਮਰਥਨ ਦਾ ਤੀਜਾ ਪੱਧਰ ਲਾਗੂ ਕੀਤਾ ਗਿਆ ਹੈ। ਤੀਜੇ ਪੱਧਰ ਵਿੱਚ ਬੁਨਿਆਦੀ ਸਹਾਇਤਾ ਸ਼ਾਮਲ ਹੁੰਦੀ ਹੈ, ਪਰ ਸਵੈਚਲਿਤ ਜਾਂਚ ਤੋਂ ਬਿਨਾਂ, ਅਧਿਕਾਰਤ ਬਿਲਡਾਂ ਨੂੰ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰਨਾ, ਜਾਂ ਇਹ ਜਾਂਚ ਕਰਨਾ ਕਿ ਕੀ ਕੋਡ ਬਣਾਇਆ ਜਾ ਸਕਦਾ ਹੈ।
• ਕਾਰਗੋ ਪੈਕੇਜ ਮੈਨੇਜਰ ਨੂੰ ਡਿਫੌਲਟ ਰੂਪ ਵਿੱਚ ਗਿੱਟ ਰਿਪੋਜ਼ਟਰੀ (HEAD) ਦੀ ਮੁੱਖ ਸ਼ਾਖਾ ਲਈ "ਮੁੱਖ" ਨਾਮ ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ ਭੇਜਿਆ ਗਿਆ ਹੈ। ਰਿਪੋਜ਼ਟਰੀਆਂ ਵਿੱਚ ਹੋਸਟ ਕੀਤੀਆਂ ਨਿਰਭਰਤਾਵਾਂ ਜੋ ਮਾਸਟਰ ਦੀ ਬਜਾਏ ਮੁੱਖ ਨਾਮ ਦੀ ਵਰਤੋਂ ਕਰਦੀਆਂ ਹਨ, ਨੂੰ ਹੁਣ ਬ੍ਰਾਂਚ = "ਮੁੱਖ" ਨੂੰ ਸੰਰਚਿਤ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ।
• ਕੰਪਾਈਲਰ ਵਿੱਚ, LLVM ਦੇ ਘੱਟੋ-ਘੱਟ ਸੰਸਕਰਣ ਦੀਆਂ ਲੋੜਾਂ ਨੂੰ LLVM 10 ਤੱਕ ਵਧਾ ਦਿੱਤਾ ਗਿਆ ਹੈ।

ਇਸ ਤੋਂ ਇਲਾਵਾ, ਅਸੀਂ ਰਸਟ ਭਾਸ਼ਾ ਵਿੱਚ ਭਾਗਾਂ ਨੂੰ ਵਿਕਸਤ ਕਰਨ ਲਈ ਟੂਲਸ ਦੇ ਲੀਨਕਸ ਕਰਨਲ ਵਿੱਚ ਏਕੀਕਰਣ ਦੇ ਵਿਕਾਸ ਲਈ ਫੰਡਿੰਗ ਦੇ ਪ੍ਰਬੰਧ ਨੂੰ ਨੋਟ ਕਰ ਸਕਦੇ ਹਾਂ। ਇਹ ਕੰਮ ISRG ਸੰਗਠਨ (ਇੰਟਰਨੈੱਟ ਸਿਕਿਓਰਿਟੀ ਰਿਸਰਚ ਗਰੁੱਪ) ਦੀ ਸਰਪ੍ਰਸਤੀ ਹੇਠ ਪ੍ਰੋਸੀਮੋ ਪ੍ਰੋਜੈਕਟ ਦੇ ਢਾਂਚੇ ਦੇ ਅੰਦਰ ਕੀਤਾ ਜਾਵੇਗਾ, ਜੋ ਕਿ Let's Encrypt ਪ੍ਰੋਜੈਕਟ ਦਾ ਸੰਸਥਾਪਕ ਹੈ ਅਤੇ HTTPS ਨੂੰ ਉਤਸ਼ਾਹਿਤ ਕਰਦਾ ਹੈ ਅਤੇ ਸੁਰੱਖਿਆ ਨੂੰ ਵਧਾਉਣ ਲਈ ਤਕਨਾਲੋਜੀਆਂ ਦੇ ਵਿਕਾਸ ਨੂੰ ਉਤਸ਼ਾਹਿਤ ਕਰਦਾ ਹੈ। ਇੰਟਰਨੈੱਟ. ਫੰਡ ਗੂਗਲ ਦੁਆਰਾ ਪ੍ਰਦਾਨ ਕੀਤੇ ਜਾਣਗੇ, ਜੋ ਕਿ ਰਸਟ-ਫੋਰ-ਲੀਨਕਸ ਪ੍ਰੋਜੈਕਟ ਦੇ ਲੇਖਕ ਮਿਗੁਏਲ ਓਜੇਡਾ ਦੇ ਕੰਮ ਲਈ ਭੁਗਤਾਨ ਕਰਨਗੇ। ਪਹਿਲਾਂ, ISRG ਅਤੇ Google ਨੇ ਪਹਿਲਾਂ ਹੀ curl ਉਪਯੋਗਤਾ ਲਈ ਇੱਕ ਵਿਕਲਪਕ HTTP ਬੈਕਐਂਡ ਬਣਾਉਣ ਅਤੇ Apache HTTP ਸਰਵਰ ਲਈ ਇੱਕ ਨਵੇਂ TLS ਮੋਡੀਊਲ ਦੇ ਵਿਕਾਸ ਲਈ ਫੰਡ ਦਿੱਤੇ ਹਨ।

ਮਾਈਕ੍ਰੋਸਾੱਫਟ ਅਤੇ ਗੂਗਲ ਦੇ ਅਨੁਸਾਰ, ਲਗਭਗ 70% ਕਮਜ਼ੋਰੀਆਂ ਅਸੁਰੱਖਿਅਤ ਮੈਮੋਰੀ ਹੈਂਡਲਿੰਗ ਕਾਰਨ ਹੁੰਦੀਆਂ ਹਨ। ਇਹ ਉਮੀਦ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਕਿ ਕਰਨਲ ਕੰਪੋਨੈਂਟਸ ਜਿਵੇਂ ਕਿ ਡਿਵਾਈਸ ਡਰਾਈਵਰਾਂ ਨੂੰ ਵਿਕਸਤ ਕਰਨ ਲਈ ਜੰਗਾਲ ਭਾਸ਼ਾ ਦੀ ਵਰਤੋਂ ਅਸੁਰੱਖਿਅਤ ਮੈਮੋਰੀ ਹੈਂਡਲਿੰਗ ਕਾਰਨ ਹੋਣ ਵਾਲੀਆਂ ਕਮਜ਼ੋਰੀਆਂ ਦੇ ਜੋਖਮ ਨੂੰ ਘਟਾ ਦੇਵੇਗੀ ਅਤੇ ਗਲਤੀਆਂ ਨੂੰ ਦੂਰ ਕਰੇਗੀ ਜਿਵੇਂ ਕਿ ਮੈਮੋਰੀ ਖੇਤਰ ਨੂੰ ਖਾਲੀ ਕਰਨ ਅਤੇ ਬਫਰ ਸੀਮਾਵਾਂ ਨੂੰ ਓਵਰਰਨਿੰਗ ਕਰਨ ਤੋਂ ਬਾਅਦ।

ਮੈਮੋਰੀ-ਸੁਰੱਖਿਅਤ ਹੈਂਡਲਿੰਗ ਰੈਫਰੈਂਸ ਚੈਕਿੰਗ, ਆਬਜੈਕਟ ਦੀ ਮਾਲਕੀ ਅਤੇ ਆਬਜੈਕਟ ਲਾਈਫਟਾਈਮ (ਸਕੋਪ) ਦੇ ਨਾਲ-ਨਾਲ ਕੋਡ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਦੌਰਾਨ ਮੈਮੋਰੀ ਐਕਸੈਸ ਦੀ ਸ਼ੁੱਧਤਾ ਦੇ ਮੁਲਾਂਕਣ ਦੁਆਰਾ ਕੰਪਾਈਲ ਸਮੇਂ 'ਤੇ ਜੰਗਾਲ ਵਿੱਚ ਪ੍ਰਦਾਨ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਜੰਗਾਲ ਪੂਰਨ ਅੰਕ ਓਵਰਫਲੋ ਦੇ ਵਿਰੁੱਧ ਸੁਰੱਖਿਆ ਵੀ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ, ਵਰਤੋਂ ਤੋਂ ਪਹਿਲਾਂ ਵੇਰੀਏਬਲ ਮੁੱਲਾਂ ਦੀ ਲਾਜ਼ਮੀ ਸ਼ੁਰੂਆਤ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਮਿਆਰੀ ਲਾਇਬ੍ਰੇਰੀ ਵਿੱਚ ਗਲਤੀਆਂ ਨੂੰ ਬਿਹਤਰ ਢੰਗ ਨਾਲ ਸੰਭਾਲਦਾ ਹੈ, ਮੂਲ ਰੂਪ ਵਿੱਚ ਅਟੱਲ ਸੰਦਰਭਾਂ ਅਤੇ ਵੇਰੀਏਬਲਾਂ ਦੀ ਧਾਰਨਾ ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ, ਲਾਜ਼ੀਕਲ ਗਲਤੀਆਂ ਨੂੰ ਘੱਟ ਕਰਨ ਲਈ ਮਜ਼ਬੂਤ ​​ਸਥਿਰ ਟਾਈਪਿੰਗ ਦੀ ਪੇਸ਼ਕਸ਼ ਕਰਦਾ ਹੈ।

ਸਰੋਤ: opennet.ru