К моим идея прислушались — федеративный гитхаб на ActivityPub: github.com
"We provide an importer to easily copy over project data from an existing GitHub project into our project hosting. We support both importing to a new project, as well as importing individual tools into an existing SourceForge project."
Безумная идея в связи с безвременной кончиной гитхаба: федеративный репозитарий кода с социальной частью на ActivityPub.
Японцы знают толк в языках: d-cube.connpass.com
"At long last, impl Trait is here! This feature has been highly desired for quite a while, and provides a feature known as “existential types.” It’s simpler than that sounds, however. The core of it is this idea:
Speaking of papercuts, since Rust uses the Result type for returning errors, and ? to make handling them easy, a common pain-point of new Rustaceans is to try and use ? in main:
Inclusive ranges with ..=
Another long-awaited feature is “slice patterns.” These let you match on slices similar to how you match on other data types."
The fastest and safest AV1 encoder.
Тем временем тихо и незаметно вышла новая версия 1.25, в которую вошли мои патчи чтобы Make Rust Gentoo Again! blog.rust-lang.org
i.ytimg.com ruby-lang.org "Ruby 2.6 introduces an initial implementation of JIT (Just-in-time) compiler.
JIT compiler aims to improve performance of any Ruby program execution. Unlike ordinary JIT compilers for other languages, Ruby’s JIT compiler does JIT compilation in a unique way, which prints C code to a disk and spawns common C compiler process to generate native code. See also: MJIT organization by Vladimir Makarov."
"Rust: implementation of `hg`
This commit provides a mostly-working implementation of the
`hg` script in Rust along with scaffolding to support Rust in
If you are familiar with Rust, the contents of the added rust/
directory should be pretty straightforward. We create an "hgcli"
package that implements a binary application to run Mercurial.
The output of this package is an "hg" binary.
Our Rust `hg` (henceforth "rhg") essentially is a port of the existing
`hg` Python script. The main difference is the creation of the embedded
CPython interpreter is handled by the binary itself instead of relying
on the shebang. In that sense, rhg is more similar to the "exe wrapper"
we currently use on Windows. However, unlike the exe wrapper, rhg does
not call the `hg` Python script. Instead, it uses the CPython APIs to
import mercurial modules and call appropriate functions. The amount of
code here is surprisingly small.
It is my intent to replace the existing C-based exe wrapper with rhg.
Preferably in the next Mercurial release. This should be achievable —
at least for some Mercurial distributions. The future/timeline for
rhg on other platforms is less clear. We already ship a hg.exe on
Windows. So if we get the quirks with Rust worked out, shipping a
Rust-based hg.exe should hopefully not be too contentious."
Теперь в компиляторе rust есть кусочек и моего кода: github.com
Программы на Расте, которые мы заслужили: github.com
"BrewStillery is a brewer's, vintner's, and distiller's calculator. It has a multitude of great functions, such as calculating ABV, determining carbonation, and total sparge water needed."
Нашёл единственную работающую библиотеку для XMPP: github.com
Но её даже на crates.io нет
Ещё одна purerust GUI библиотека. На этот раз даже работающая со stable версией: christolliday.github.io
"Using Rust in Mercurial
This page describes the plan and status for leveraging the Rust programming language in Mercurial.
Why use Rust?
Today, Mercurial is a Python application. It uses Python C extensions in various places to achieve better performance.
There are many advantages to being a Python application. But, there are significant disadvantages.
Performance is a significant pain point with Python. There are multiple facets to the performance problem:
General performance overhead compared to native code
GIL interfering with parallel execution
It takes several dozen milliseconds to start a Python interpreter and load the Mercurial Python modules. If you have many extensions loaded, it could take well over 100ms just to effectively get to a Mercurial command's main function. Reports of over 250ms are known. While the command itself may complete in mere milliseconds, Python overhead has already made hg seem non-instantaneous to end-users.
A few years ago, we measured that CPython interpreter startup overhead amounted to 10-18% of the run time of Mercurial's test harness. 100ms may not sound like a lot. But it is enough to give the perception that Mercurial is slower than tools like Git (which can run commands in under 10ms).
There are also situations like querying hg for shell prompts that require near-instantaneous execution.
Mercurial is also heavily scripted by tools like IDEs. We want these tools to provide results near instantaneously. If people are waiting over 100ms for results from hg, it makes these other tools feel sluggish.
There are workarounds for startup overhead problems: the CommandServer (start a persistent process and issue multiple commands to it) and CHg (a C binary that speaks with a Mercurial command server and enables chg commands to execute without Python startup overhead). chg's very existence is because we need hg to be a native binary in order to avoid Python startup overhead. If hg weren't a Python script, we wouldn't need chg to be a separate program.
Python is also substantially slower than native code. PyPy can deliver substantially better performance than CPython. And some workloads with PyPy might even be faster than native code due to JIT. But overall, Python is slower than native code.
But even with PyPy's magical performance, we still have the GIL. Python doesn't allow you to execute CPU-bound Python code on multiple threads. If you are CPU bound, you need to offload that work to an extension (which releases the GIL when it executes hot code) or you spawn multiple processes. Since Mercurial needs to run on Windows (where new process overhead is ~10x worse than POSIX and is a platform optimized for spawning threads — not processes), many of the potential speedups we can realize via concurrency are offset on Windows by new process overhead and Python startup overhead. We need thread-level concurrency on Windows to help with shorter-lived CPU-bound workloads. This includes things like revlog reading (which happens on nearly every Mercurial operation).
In addition to performance concerns, Python is also hindering us because it is a dynamic programming language. Mercurial is a large project by Python standards. Large projects are harder to maintain. Using a statically typed programming language that finds bugs at compile time will enable us to make wide-sweeping changes more fearlessly. This will improve Mercurial's development velocity.
Today, when performance is an issue, Mercurial developers currently turn to C. But we treat C as a measure of last resort because it is just too brittle. It is too easy to introduce security vulnerabilities, memory leaks, etc. On top of vanilla C, the Python C API is somewhat complicated. It takes significantly longer to develop C components because the barrier to writing bug-free C is much higher..."