Originally posted by liam
View Post
Announcement
Collapse
No announcement yet.
Making The Case For Using Rust At Low Levels On Linux Systems
Collapse
X
-
Originally posted by atomsymbol
In a sense, mutability is "native" also to functional programming languages because it is possible to implement a Turing machine in a functional programming language.
A problem to solve is how create a compiler that can recognize the presence of Turing machines in functional programs and thus can generate efficient assembly code for such cases.
Leave a comment:
-
Originally posted by mmstick View Post
C++ isn't good for anything. There's good reason why everyone is moving away from C++ and using other languages instead, and why both Google and Mozilla decided to attempt to ditch their usage of C++ for Go and Rust respectively. C++ really isn't good for software libraries either due to C++ not having a stable exportable interface. That's a good reason why everyone writes their software libraries in C, and why all languages implement a C ABI as the foreign interface of choice. Rust, likewise, has the ability to export Rust libraries with a C interface, and many languages are now starting to take advantage of that, including Python and Ruby.
My biggest current complaint with Rust is that library support (Rust to Rust) is currently bad and as far as I can tell, not considered a problem (see: https://github.com/rust-lang/rust/issues/16402 and "non-goals" https://internals.rust-lang.org/t/pe...-the-plan/2767). Fetching the world and statically linking everything is such a boring solution. Imagine if libc were written in a way that required the machine to be rebuilt on update.
Cargo is a particularly badly designed, hyper-coupled tool requiring a python script (that appears to reimplement much of cargo, https://github.com/dhuseby/cargo-bootstrap) to bootstrap. As a package manager myself I'm not quite sure how to cope with rust software---some suggestions strike me as crazy, e.g.
In Debian's packaging solution for Rust they are not planning on installing Rust libraries globally, only Rust applications, so will not hit this problem. They will be packaging Rust libraries as source to a custom system location. When their package Rust applications are built, they will redirect cargo to look in that location for the source code to their dependencies, which will then be built and statically linked to the application. But the libraries will never be installed anywhere that could cause such a conflict.
In any case, if you want to look deeper into issues around packaging, at least there's work being done to address some issues (though personally it doesn't satisfy me): https://internals.rust-lang.org/t/pe...-the-plan/2767
I understand that to get really high-performance specialization as seen in C++ header libraries you're effectively statically linking but I feel like the community at large gives much thought to libraries and abi (e.g. pimpl).
- Likes 1
Leave a comment:
-
Originally posted by atomsymbol
Immutable data structures are an efficient computational model of just a restricted subset of phenomena of the world.
That being said, I take the sentiment. Working with the prototypical non-inductive data structures like graphs and matrices is a huge pain without mutation.
Leave a comment:
-
Originally posted by Hi-Angel View PostAlthough I do agree about C++ being unreadable for no reason when templates are come in place, I'd say that «verbosity» have little to do with code readability. More over, C++ with templates is verbose, too verbose!
The most readable language from ones that I know, in my opinion, is Haskell (so called ML-syntax), and it by no means is verbose, the code is very short. I even have for a year in mind the idea of creating a parser for a text editor, which would translate on the fly parts of code in C or C++ or C# or whatever, into Haskell like syntax look — i.e. the real code remains unchanged, it's just the reader sees it like this (the idea though not even close to its realization for a number of different reasons).
I'm not saying anything against Ada though, as I don't know this language.
Leave a comment:
-
Originally posted by totoz View PostThe verbosity of Ada is intentional: since the language aimed to be used for safety critical systems, code readability and clarity was very important, even for some newcomers or people not familiar with the language (but with some IT skills, though). When I see modern C++, it's just klingon for non C++ developers. Even for me, although I did program in C++ for years a decade ago.
About tools, there's an IDE (GNAT Programming Studio) and an Eclipse plugin that you can get for free (GPL). And of course, Emacs ;-)
The most readable language from ones that I know, in my opinion, is Haskell (so called ML-syntax), and it by no means is verbose, the code is very short. I even have for a year in mind the idea of creating a parser for a text editor, which would translate on the fly parts of code in C or C++ or C# or whatever, into Haskell like syntax look — i.e. the real code remains unchanged, it's just the reader sees it like this (the idea though not even close to its realization for a number of different reasons).
I'm not saying anything against Ada though, as I don't know this language.
Leave a comment:
-
Originally posted by cl333r View Post
I moved from Gtk3 to Qt5 after dealing with it for like 2 years and finding out it's crap and at the time poorly supported on windows (at the time). The shittiest part is that it's written in C which is too low level, Python is a hog because it's interpreted that's one of the reasons Canonical couldn't keep up its software center because Python like any interpreted language only scales so much. And the C++ bindings to Gtk3 are crappy because they're still a wrapper around C logic with some bit of OO design. Anyone who tells me C++ isn't good for graphical apps, or any iteration of this idea, is only telling me he's not worth my time.
Leave a comment:
-
Originally posted by ssokolow View Post
Also, I find it irritating that, during the GTK+ 3.x series, it's become more and more difficult to maintain the desktop experience I had under GTK+ 2.x without regressions and their excuse is "GTK+ 3.x is an unstable series". If it's an unstable series, attack, name, and shame any distro which ships GNOME 3 as if it's a stable desktop! GNOME isn't the only consumer of the GTK+ APIs!
Like the LXDE developers, I'm in the process of upgrading from GTK+ 2.x to Qt 5.x and the main thing limiting my adoption of Rust is that, as someone focused on UI/UX design, most of my creations are I/O-bound things which glue together non-QML (QML native widget support is too immature) UI elements in novels ways, so my creations will be 99% PyQt regardless of whether I use Rust and adding another language just complicates the build process.
(I really want to be able to write pure Rust apps because the type system would greatly simplify the task of bringing all of my projects, old and new, up to my new unit testing standards... especially given how defining a state machine within Rust's type system lets you get compile-time validation of proper use of a wire protocol or file format.)
Leave a comment:
-
Originally posted by Hi-Angel View PostJust C++, really?.
Also, from my little experience in both GTK and Qt, the last is better to code. E.g. I remember, as part of a student thesis, I was trying to fix a problem in GTK GUI of Yi with cursor, which doesn't become «big black box» in «normal mode», like it is in vim. Long story short, it turned out GTK didn't have that capability. In GVIM it is done via custom widget, and someone told a story, that for alike needs they hacked the mode of cursor when you press «Insert» key.
I also met some other problems, which I badly remember, but what I do remember — I googled whether they could be easily done in Qt, and yes, they are! Plus — though it is subjective — to me Qt apps looks much prettier than GTK ones. So I consider Qt to be better than GTK.
The only thing I'm miss in Qt, is that GTK allows creating global keybindings for textboxes via .gtkrc, e.g. for movement like in Emacs.
- Likes 1
Leave a comment:
-
Originally posted by totoz View Post
Runtime checks can be disabled at compile time, and Ada does also a lot of static checks and analysis at compile time.
GC is optional for Ada, and the GNAT compiler (probably the most popular compiler, based on GCC) does not provide one, so we can almost consider there is no GC unless you target a specific compiler.
The same is true for segmentation faults and dangling pointers without a GC. You can't compile code with rust if there is a possibility for a dangling pointer or segmentation faults.
Leave a comment:
Leave a comment: