News for hackers. Stuff that matters.
Re:Rust in 2018: easier to use by eecc on Sunday January 14, 2018 @03:54AM (#16143387)
Julia writes she wouldn’t yet use Rust to write webservices. Right there, this could be the mission for 2018.

http://www.arewewebyet.org

Nobody with a sane mind would write C or CPP micro-services, but post-Spectre and Meltdown any reclaim in performance is tangibility valuable. Rust could be the one to swoop in and claim the position

Re:Rust in 2018: easier to use by pjmlp on Sunday January 14, 2018 @04:21AM (#16143451)
Neither I think Rust is fit for that purpose, any GC language is a better fit in terms of productivity, unless we are speaking about tiny IoT devices with a few KBs.

Also, it is not yet fit for writing GUI code. It is quite far from what is possible to achieve today in Qt/WPF/Cocoa/Android/... tooling and even the latest NLL improvements don't fix all issues regarding writing callbacks.

Re:Rust in 2018: easier to use by vkjv on Sunday January 14, 2018 @10:00AM (#16144489)
Thanks to Rust's great C interoperability, hybrid can be a great approach. I've really been enjoying re-writing sections of node.js applications in Rust. It fits fairly seamlessly and can really broaden the scope of what is possible.

https://github.com/neon-bindings/neon

Re:Rust in 2018: easier to use by vhakulinen on Sunday January 14, 2018 @04:46AM (#16143518)
Writing GUI with rust is totally possible: http://gtk-rs.org/
Re:Rust in 2018: easier to use by pjmlp on Sunday January 14, 2018 @06:34AM (#16143827)
It is possible, but far from productive, which I learned exactly by trying to use Gtk-rs to port an old basic Gtkmm demo, that I used for a C/C++ Users Journal article.
Re:Rust in 2018: easier to use by amelius on Sunday January 14, 2018 @07:25AM (#16143971)
Wasn't Rust invented to write a GUI? A webbrowser can be regarded as a kind of GUI.
Re:Rust in 2018: easier to use by foldr on Sunday January 14, 2018 @07:33AM (#16143998)
There aren't any good GUI libraries available for Rust at the moment. GUI libraries are huge and take an enormous amount of work to get right. It's typically only the most popular three or four languages at any given point in time that have satisfactory GUI libraries. Rust has the additional burden that it is far from trivial to wrap Gtk, Qt or other C/C++ toolkits in a safe manner.
Re:Rust in 2018: easier to use by amelius on Sunday January 14, 2018 @07:43AM (#16144030)
Didn't Mozilla write a GUI library before they wrote Firefox? It would strike me as odd if they didn't.
Re:Rust in 2018: easier to use by foldr on Sunday January 14, 2018 @07:46AM (#16144039)
There is no mature GUI library for Rust that I'm aware of. I believe the servo project is focused on writing a browser rendering engine, not a browser GUI. It certainly has not so far yielded a GUI toolkit that can be straightforwardly used in other projects.
Re:Rust in 2018: easier to use by coldtea on Sunday January 14, 2018 @09:32AM (#16144378)
No, it was invented to write a generic (web) rendering engine.

So, even if we consider a web app as a GUI, Rust wasn't invented for writing that (you still use CSS, HTML, JS etc for that part). It was invented for writing the backend for that UI.

In other words, Rust is not GTK (a UI library), it's C (the language the UI library itself is written in).

Re:Rust in 2018: easier to use by amelius on Sunday January 14, 2018 @11:19AM (#16144850)
Ok what is the GUI of Firefox written in/using?
Re:Rust in 2018: easier to use by coldtea on Sunday January 14, 2018 @11:31AM (#16144888)
Until recently-ish something called XUL, a markup language for UI (similar to HTML, or even better XAML). Not sure if they've moved on since.

https://developer.mozilla.org/en-US/docs/Mozilla/Tech/XUL

Re:Rust in 2018: easier to use by lima on Sunday January 14, 2018 @07:57AM (#16144067)
Rust was invented for low-level parsing/rendering code. The high level GUI in Firefox is not implemented in Rust for all I know.
Re:Rust in 2018: easier to use by StavrosK on Sunday January 14, 2018 @05:55AM (#16143711)
Yes but "possible" and "pleasant" are very different :(
Re:Rust in 2018: easier to use by v_lisivka on Sunday January 14, 2018 @10:26AM (#16144604)
gtk-rs needs a macro package to parse a HTML or a XML snippet and generate GUI, with embedded rust code in appropriate place. Look at Yew for example: https://users.rust-lang.org/t/yew-a-framework-for-client-sid... .
Re:Rust in 2018: easier to use by coldtea on Sunday January 14, 2018 @09:30AM (#16144366)
Yeah, but the parent point is that "possible" is a very low bar.
Re:Rust in 2018: easier to use by chmln on Sunday January 14, 2018 @09:38AM (#16144407)
> Neither I think Rust is fit for that purpose, any GC language is a better fit in terms of productivity

There is nothing in Rust that makes it inherently unfit for APIs or the web. To dismiss the entire language is simply lazy. Having GC also doesn't necessarily make one language superior to another.

While http ecosystem is still in active development, if there was really a choice between Rust and JS for e.g. writing an API I would go with Rust in a heartbeat.

Re:Rust in 2018: easier to use by pjmlp on Sunday January 14, 2018 @10:41AM (#16144673)
The thing is, the choice isn't between Rust and JavaScript, rather between Rust and a list of other languages.

Having a GC means having easier ergonomics to write data structures and distributed algorithms.

I do like a lot Rust's type system, just the ergonimcs aren't quite there yet.

Re:Rust in 2018: easier to use by chmln on Sunday January 14, 2018 @05:40PM (#16146940)
> just the ergonimcs aren't quite there yet

You're correct, but "Rust isn't easy to use for purpose X just yet" is substantially different from "Rust is inherently unfit for X"

Re:Rust in 2018: easier to use by Thaxll on Sunday January 14, 2018 @11:26AM (#16144871)
Except it takes 10x time to write anything backend related. Why would you choose Rust over Java / C# / Go ect ...?
Re:Rust in 2018: easier to use by pimeys on Sunday January 14, 2018 @02:00PM (#16145645)
I don't buy this claim. I've written many services with Rust and I'm not slower with it that I am with GC'd languages I also need in my work, such as Clojure, Scala or Python.

Please explain me where is this idea of slow development time coming from? Is it only because people try Rust for two weeks, cannot get the lifetimes and decide the development speed is slow?

Re:Rust in 2018: easier to use by computerphage on Sunday January 14, 2018 @11:49AM (#16144959)
Except that number is completely made up. Why do believe it takes ten times as long?
Re:Rust in 2018: easier to use by Thaxll on Sunday January 14, 2018 @11:53AM (#16144977)
What Rust framework replace Java spring or equivalent, none of them so you have to write everything yourself. Rust doesn't have any ecosystem to write service side services so you're going to spend time by just re implementing a framework.
Re:Rust in 2018: easier to use by steveklabnik on Sunday January 14, 2018 @02:47PM (#16145941)
While Rust doesn't have many full-stack frameworks, many ecosystems don't favor full-stack frameworks. Rust has tons (arguably too many!) microframeworks/libraries.

I do agree that there are holes, and that's part of being a young ecosystem, but I think you're being a bit too pessimistic. I understand this deeply, as I was once too! As things have evolved, my opinions have changed, though.

Re:Rust in 2018: easier to use by viraptor on Sunday January 14, 2018 @05:09AM (#16143575)
> any GC language is a better fit in terms of productivity

But that's not the only constraint. If you want to save memory, due to the environment you run on, or your workload, a non-GC runtime can be pretty awesome.

Re:Rust in 2018: easier to use by pjmlp on Sunday January 14, 2018 @06:51AM (#16143888)
Just because a language has a GC, doesn't mean it doesn't have language features to have more fine grained control over how memory allocation takes place, or even when the GC has to run if at all.
Re:Rust in 2018: easier to use by littlestymaar on Sunday January 14, 2018 @07:31AM (#16143991)
In that case it's no different from Rust, Rust has a GC option (ref counting). It's limited and opt-in then you still carry the cognitive burden of memory management, you have to think when to use it. But if you need that level of control, you'll need to think about memory anyway.

And in my experience, it's way easier to reason about allocations in Rust that it is in Java (automatic type erasure if you want to use generic code) or Go (how will escape analysis behave in that case ?) for example. Rust traits are way better than C++ interfaces in that regard also.

Re:Rust in 2018: easier to use by pjmlp on Sunday January 14, 2018 @08:09AM (#16144108)
Java and Go are just two examples, and surely not those that I had in mind.

Rather languages in the Oberon and Modula family, D, Nim, Eiffel, C# as of 7.2, Common Lisp, and a few MLs.

If you do RC everywhere, using library types, it is slower than a tracing GC, and still not as productive.

Re:Rust in 2018: easier to use by seanmcdirmid on Sunday January 14, 2018 @09:40AM (#16144414)
UWP has ref counting, garbage collection (via C#), and stack allocation. It does native compilation to boot, unfortunately it isn’t quite universal.
Re:Rust in 2018: easier to use by pjmlp on Sunday January 14, 2018 @10:46AM (#16144696)
And is built on an improved COM, thus requiring first class support for it, by any language targeting UWP.
Re:Rust in 2018: easier to use by seanmcdirmid on Sunday January 14, 2018 @11:02AM (#16144778)
Ya, that’s right. But I think this is only C++ and C# at the moment.
Re:Rust in 2018: easier to use by pjmlp on Sunday January 14, 2018 @12:10PM (#16145057)
JavaScript on Chackra's engine, VB.NET, C# and C++. F# support is still to be done, due to how .NET Native handles MSIL.

Borland was in the process of doing it for Delphi and C++ Builder, but I don't know the current state. Originally they were only replicating the Metro UI, back on Windows 8.

Re:Rust in 2018: easier to use by trumpsamerica on Sunday January 14, 2018 @12:05PM (#16145020)
Isn't it universal windows? :)
Re:Rust in 2018: easier to use by Narishma on Monday January 15, 2018 @05:12AM (#16149656)
Yes, runs universally on all Windows 10 versions.
Re:Rust in 2018: easier to use by rapsey on Sunday January 14, 2018 @04:42AM (#16143512)
You're comparing a language to an OS and three GUI frameworks.
Re:Rust in 2018: easier to use by sho_hn on Sunday January 14, 2018 @04:50AM (#16143526)
I think there's some merit to the statement nonetheless - e.g. Qt is native to C++ and its API designed around C++ language features and semantics in many ways. There has been success in writing bindings for languages that can emulate those semantics without too much pain (e.g. PyQt), but Rust is not one of them.

Inside the Rust community, there's been a lot of debate about what an idiomatic Rust API for a GUI toolkit would look like, particularly because the traditional tree-of-widget-objects design of C++ GUI toolkits appears a bit inconvenient to realize within Rust's stricter semantics.

IOW, "are we gui yet?" might depend on some sort of new written-in-Rust GUI toolkit to appear. There's 20 years of work by many hundreds of people in Qt, many of whom rallied not just around Qt specifically, but around projects using it. Getting that many people moving isn't easy. Alternatively, major progress has to be made on bindings and bridging to the semantics of other languages in Rust.

That said - of course C++ was around quite a while before being adopted by Qt.

Re:Rust in 2018: easier to use by rapsey on Sunday January 14, 2018 @05:49AM (#16143702)
Servo guys have the potential to make something amazing (i.e. a sane electron type library). But I'm not sure how much they care about that. Other then that there is nothing serious going on.
Re:Rust in 2018: easier to use by sho_hn on Sunday January 14, 2018 @11:58AM (#16144993)
> a sane electron type library

There's no version of that concept that's sane at this time, though. Wrapping full-fidelity APIs the browser engine has access to in a lossy abstraction layer of shoddy web platform APIs isn't a practice Servo can improve upon. It takes improving those APIs.

Re:Rust in 2018: easier to use by IshKebab on Sunday January 14, 2018 @06:06AM (#16143748)
There's a project called Limn trying to do this. I doubt it has solved the ergonomics issue though.
Re:Rust in 2018: easier to use by rapsey on Sunday January 14, 2018 @06:20AM (#16143786)
Anyone pinning hope on limn should take a look at the activity on the project since start of December.
Re:Rust in 2018: easier to use by laumars on Sunday January 14, 2018 @07:35AM (#16144002)
You're talking about just over a month. I think it's a little unfair to expect people to maintain hobby projects every week of every year. Particularly over Christmas and the new year when our lives are often busier than usual.

To use a personal example, an open source project I actively maintain only yesterday saw it's first commits since the end of November. But I am still very much committed to that project.

Re:Rust in 2018: easier to use by littlestymaar on Sunday January 14, 2018 @07:22AM (#16143964)
I wouldn't be too pessimistic about a project just because the main author stopped pushing changes for one month in the holliday season. It also happened in August for the same project and work resumed later at a fast path.
Re:Rust in 2018: easier to use by coldtea on Sunday January 14, 2018 @09:35AM (#16144386)
If the project has only one main author, I would be. Even more so if they are on and off and not paid for it. Heck, TextMate and somewhat Sublime Text had such issues with 1 single dev, and those are projects that actually make them money...
Re:Rust in 2018: easier to use by laumars on Sunday January 14, 2018 @11:56AM (#16144984)
That's not a fair comparison as they weren't open source so it was impossible for the community to help contribute (and the community did want to contribute when it looked like development had stalled). Where as limn is open source so if it does prove worthwhile but development stalls it would be trivially easy for any number of other developers fork the git repo and carry on the work.
Re:Rust in 2018: easier to use by coldtea on Sunday January 14, 2018 @12:32PM (#16145176)
>That's not a fair comparison as they weren't open source so it was impossible for the community to help contribute

It is fair, as whether it's possible for the community to contribute is a moot point if the community wont contribute.

Heck, GTK+, which is used by millions, had just one person working on it full time a few years ago (not sure if changed since), and lamenting how there's no community help in the project's blog. And that's for a hugely used and know project. I doubt a Rust UI lib would get more than that.

Re:Rust in 2018: easier to use by laumars on Sunday January 14, 2018 @03:49PM (#16146329)
> It is fair, as whether it's possible for the community to contribute is a moot point if the community wont contribute.

Well as I had already said in my previous post, the community did want to contribute to Sublime Text but couldn't. Hence why I posted my rebuttal stating the original examples weren't really fair.

Your revised example is far more apt however in a roundabout way it just reinforces my original point. Since, by your own admission, any Rust UI lib is unlikely to see many dedicated contributors; it would be daft to criticize limn for a trait that you have just acknowledged would be typical for any Rust UI library.

To put things another way: if the project had stalled for months at a time then I could understand people's skepticism trusting the maintainer. However a brief period without commits during the holiday season seams more than reasonable for an active project. Particularly when you even comment afterwards that any similar project isn't likely to see more active development anyway. So why single this one out as being less trustworthy? It feels very much like your applying double standards here.

Re:Rust in 2018: easier to use by Conan_Kudo on Sunday January 14, 2018 @01:11PM (#16145392)
> Heck, GTK+, which is used by millions, had just one person working on it full time a few years ago (not sure if changed since), and lamenting how there's no community help in the project's blog. And that's for a hugely used and know project. I doubt a Rust UI lib would get more than that.

This is not true for GTK+ 3. GTK+ 2, however, has been in maintenance mode since the introduction of GTK+ 3 and has been in that state since.

Re:Rust in 2018: easier to use by rapsey on Sunday January 14, 2018 @12:25PM (#16145140)
> it would be trivially easy for any number of other developers fork the git repo and carry on the work.

Expecting that is wishful thinking. The fact of the matter is making something like that is an insane amount of tedious work and 99% of the time it is started up by people playing around with the concepts and abandoned once the initial fun problems are tackled. Something I am sure will happen with limn.

Re:Rust in 2018: easier to use by laumars on Sunday January 14, 2018 @04:03PM (#16146417)
I agree however that could equally happen with any similar Rust UI library that isn't backed by a corporate entity. And seeming as there isn't any corporate backed UI libraries for Rust (at least that I'm aware of), you're literally no worse off with limn than you are with anything else.
Re:Rust in 2018: easier to use by vvanders on Sunday January 14, 2018 @11:35AM (#16144901)
Qt uses way more than vanilla C++ though, it practically has its own dsl for a whole host of things.
Re:Rust in 2018: easier to use by sho_hn on Sunday January 14, 2018 @11:51AM (#16144970)
This often gets over-reported; old memes die hard.

There's a small number of macros that a custom preprocessor expands to (very pedestrian) generated code, but they are optional to use (though it's certainly uncommon not to use them) and these days there's template-based versions of some of them that are preferred and steadily finding adoption over the macro ones because they're superior. Beyond that there's a few more normal preprocessor-based macros that are entirely optional.

In that sense Qt also tracks vanilla C++ very closely and has adopted features from newer language versions at a fairly steady pace and swiftly for such a large production library set.

None of this matters much to my point though - that was about much more basic language semantics like classes-based OOP and the absence of ownership rules.

Re:Rust in 2018: easier to use by pjmlp on Sunday January 14, 2018 @06:48AM (#16143877)
No, I am comparing the selection of a specific programming language, given the existence of tooling for a specific purpose.

I need to fulfil task X, with tool Y, then I choose language Z among those supported by Y.

Not I chose language Z, then try to find some kind of Y, that helps me solve X somehow.

When C++ came into the picture we got Turbo Vision on MS-DOS bundled with Borland compilers, Apple adopted Metrowerks tools and used PowerPlant, OS/2 promoted CSet++, UNIX guys were into Motif.h++.

Then came Windows, Borland pushed forward with OWL followed by VCL. Microsoft created MFC, adopted by Symatec and Zortech compilers.

Apple eventually went Cocoa, and Microsoft UWP as of latest.

And then there is Qt, literally the only game in town for C++ GUIs not related to any OS vendor.

Followed by what in possible in Java and .NET eco-systems.

All with good visual tooling support, allowing for productive workflows between developers and designers.

I am not saying that Rust some day won't catch up, and offer something similar in terms of productivity.

I hope it does, but right now in 2018 it doesn't.

Re:Rust in 2018: easier to use by k__ on Sunday January 14, 2018 @07:20AM (#16143958)
Isn't Rust perfect for severless?

Since cloud providers do all the plumbing, Rust would only have to deliver a tiny Linux binary for the function.

Re:Rust in 2018: easier to use by AzzieElbab on Sunday January 14, 2018 @07:27AM (#16143980)
I do not think it will be tiny after including all the required and atm non existent SDKs
Re:Rust in 2018: easier to use by banachtarski on Sunday January 14, 2018 @04:07AM (#16143420)
> Nobody with a sane mind would write C or CPP micro-services

why? I do this all the time. Maybe I should check into a nearby asylum.

Re:Rust in 2018: easier to use by shadowmint on Sunday January 14, 2018 @04:28AM (#16143470)
The point isn’t that no one does it, its that its hard to do right.

...and that is flat out the case for c++, unequivocally.

In rust you’d expect it to be better, because of (reasons rust is good here, like safety, having a package manager and an ecosystem, etc etc), but practically, there are too many halfbaked solutions, too much ‘use nightly’ and few good stable proven solutions to look at.

Rust isn’t the right solution for every problem, but it should be a good solution for secure very high performance network services.

Its definitely a good goal for the year~

Re:Rust in 2018: easier to use by e12e on Sunday January 14, 2018 @06:29PM (#16147209)
> ...and that is flat out the case for c++, unequivocally.

Arguably, this is why Google made go.

But I'm not sure c++ micro services are a terrible idea. I think the real problems come with a) feature creep as opposed to writing new micro services, and b) the temptation to write "fast" c++.

Just writing plain obvious c++ should give you a leg up on most languages (esp for micro services). But then, rather than refactor and think about the algorithm and data structures (and get a 10x performance benefit from a simpler solution), you could probably get a 2x improvement from a more convoluted, "special" c++ implementation.

And that's where you're likely to encounter elder horrors lurking.

[ed: I'm however more and more convinced there's no such thing as "plain obvious c" that doesn't have a number of serious issues along the lines of not checking mallloc return values, to utf8 string handling etc.]

Re:Rust in 2018: easier to use by sebcat on Sunday January 14, 2018 @06:22AM (#16143792)
I also do this. I make use of Capsicum/seccomp-bpf and jail/chroot to a ro mountpoint, use SSP, ASLR where possible, ... But I still use C as my primary programming language. I've also written code in golang professionally for a year or two.

It's quite common in the embedded space to use C or C++. It's easy to run everything as root and skip fundamental bound checking, so those languages get a bad rep in that space. Totally understandable. But it is possible to engineer solutions that are a lot safer too. It's just a question of priorities. Companies not prioritizing writing safe code or not working on having a safe architectural design will not bother with Rust or other memory safe languages. There's little to no market incentive in most areas. Sad but true.

Re:Rust in 2018: easier to use by pjmlp on Sunday January 14, 2018 @06:56AM (#16143906)
Even using C++ in embedded is an issue, mostly cultural.

A common theme in the C++ community is to advocate C++ to devs that only see Assembly and C89, and don't see any reason to move beyond that.

Most recent example "Embedded & C++ - Meeting 2017 Keynote"

https://www.youtube.com/watch?v=mNPfsUZb3vs

Re:Rust in 2018: easier to use by michaelchisari on Sunday January 14, 2018 @04:16AM (#16143442)
It must depend on what you're building with it. I haven't seen any reason why it couldn't be used for serving up data for an api.

But as far as using it as a full featured web framework, a la Rails, Django or even Laravel, I can see why people say it's got a long way to go.

That said, I haven't built anything production or large scale in Rust, so I can't claim to be an expert.

Re:Rust in 2018: easier to use by raverbashing on Sunday January 14, 2018 @05:53AM (#16143709)
Because your code has bugs and/or security vulnerabilities. It's pretty safe to assume this without looking at your code
Re:Rust in 2018: easier to use by civility on Sunday January 14, 2018 @06:22AM (#16143794)
Heh, so does yours. I can say this without even knowing what language you use to write your software, much less looking at it... All software has bugs, and most of those are security vulnerabilities waiting to happen.
Re:Rust in 2018: easier to use by raverbashing on Sunday January 14, 2018 @09:42AM (#16144417)
Of course. Code is hard.

Using a safer language makes it easier and less prone to out-of-bounds memory accesses.

By using C/C++ you're choosing to make a hard problem harder.

Re:Rust in 2018: easier to use by banachtarski on Monday January 15, 2018 @04:10AM (#16149431)
And slower or impractical even for some things. Maybe we should write a real-time media codec in python 'cause security. I don't understand why you, like the OP, make these sweeping generalizations as though all of engineering is black and white. Sometimes, I reach for a higher abstraction, sometimes not. It depends on the problem domain.

Oh and btw, "out of bounds memory accesses" are not the primary source of security vulnerabilities at all. In fact, such out of bounds access is more likely to just make your program crash (which is a good thing).

Re:Rust in 2018: easier to use by duneroadrunner on Sunday January 14, 2018 @03:08PM (#16146076)
C++ does have a practical, memory-safe subset[1]. Recommended for anyone writing internet facing C++ code.

[1] shameless plug: https://github.com/duneroadrunner/SaferCPlusPlus

Re:Rust in 2018: easier to use by kbwt on Sunday January 14, 2018 @06:17AM (#16143779)
I wouldn't be so sure lower level code necessarily has more vulnerabilities. It's certainly easier to find the vulnerabilities because the attack vectors are well-known.

Software written in higher level languages is often less widely deployed, so less people are trying to find vulnerabilities. All the complexity adds up, and can result in new vulnerabilities that wouldn't have been there if the code was written in a simpler language.

Re:Rust in 2018: easier to use by sambe on Sunday January 14, 2018 @06:27AM (#16143806)
What complexity adds up?
Re:Rust in 2018: easier to use by fauigerzigerk on Sunday January 14, 2018 @05:22AM (#16143612)
>Maybe I should check into a nearby asylum.

If you do, make sure it says "believes in micro-services" on the referral ;-)

Re:Rust in 2018: easier to use by banachtarski on Sunday January 14, 2018 @05:28AM (#16143627)
I just mentally edit "micro-services" to "services" any time I read it hehe.
Re:Rust in 2018: easier to use by StavrosK on Sunday January 14, 2018 @05:56AM (#16143719)
What, do you edit the "web" out of "webscale" too? Certifiable.
Re:Rust in 2018: easier to use by paulddraper on Sunday January 14, 2018 @01:47PM (#16145575)
And "REST" to "HTTP"
Re:Rust in 2018: easier to use by curiousGambler on Sunday January 14, 2018 @04:19AM (#16143446)
I get the impression Go runs the microservice space. It's built for it and is incredibly fast despite the GC. I don't see Rust claiming that position anytime soon.
Re:Rust in 2018: easier to use by eecc on Sunday January 14, 2018 @04:44AM (#16143517)
Where I live and work, golang is only used at one major client (because they’re US based, the decision must have happened elsewhere.)

Everything else is Spring Boot (java), Akka (Scala) or Nodejs. Apparently nobody wants to embrace a language designed for offshoring, so no Meetups, noisy user groups and so on... even Clojure is more popular

Re:Rust in 2018: easier to use by K0nserv on Sunday January 14, 2018 @05:47AM (#16143696)
Golang is a language designed for offshoring? It was invented at one of the largest engineering orgs to be used in house
Re:Rust in 2018: easier to use by pjmlp on Sunday January 14, 2018 @07:04AM (#16143918)
In the words of Rob Pike:

"The key point here is our programmers are Googlers, they’re not researchers. They’re typically, fairly young, fresh out of school, probably learned Java, maybe learned C or C++, probably learned Python. They’re not capable of understanding a brilliant language but we want to use them to build good software. So, the language that we give them has to be easy for them to understand and easy to adopt. – Rob Pike 1"

"It must be familiar, roughly C-like. Programmers working at Google are early in their careers and are most familiar with procedural languages, particularly from the C family. The need to get programmers productive quickly in a new language means that the language cannot be too radical. – Rob Pike 2"

So a language that makes it quite easy for enterprises to deal with developers as cogs.

Source:

http://channel9.msdn.com/Events/Lang-NEXT/Lang-NEXT-2014/Fro...

https://talks.golang.org/2012/splash.article

Re:Rust in 2018: easier to use by foldr on Sunday January 14, 2018 @07:43AM (#16144031)
I don't see what that has to do with offshoring. Developers of the kind Rob Pike is referring to exist everywhere in the world.
Re:Rust in 2018: easier to use by pjmlp on Sunday January 14, 2018 @07:59AM (#16144074)
I do enterprise consulting, in projects which happen to always have some kind of offshoring involved.

Projects where the languages are easy to pick up and anyone can do it, are always the first on the pipeline to give away.

Re:Rust in 2018: easier to use by foldr on Sunday January 14, 2018 @08:12AM (#16144118)
Are you really saying that Rob Pike is part of some kind of conspiracy to offshore all the coding that's currently being done at Google SF? Golang has been around for a while now, and there's no sign of that happening.
Re:Rust in 2018: easier to use by pjmlp on Sunday January 14, 2018 @08:23AM (#16144144)
No, I am just stating that the goals of having the language designed for such target audience, can have that as side effect.

Just like it happened with Java.

Re:Rust in 2018: easier to use by foldr on Sunday January 14, 2018 @02:52PM (#16145970)
Your responses to K0nserv and singhrac suggested that you were defending the claim that golang was "designed for" outsourcing.

If you're making the weaker claim that Go's design "can" have the effect of triggering outsourcing, then that's speculative and consequently rather difficult to refute. But you haven't provided a single piece of evidence that this has actually occurred, so far as I can see.

Re:Rust in 2018: easier to use by pjmlp on Sunday January 14, 2018 @03:23PM (#16146164)
I was making the claim that can be a side effect of its design and the way the community is against common features in modern languages, deemed too complex.

Lets see how it looks a few years from now, given that it is becoming a mainstream language thanks to Docker and K8s adoption.

Re:Rust in 2018: easier to use by foldr on Sunday January 14, 2018 @04:12PM (#16146492)
Many of those features (e.g. generics) are in Java and/or C#, which are nonetheless widely outsourced.
Re:Rust in 2018: easier to use by pjmlp on Sunday January 14, 2018 @04:37PM (#16146633)
True, however Go is like a Java or C# 1.0, they did not start as they look today.

So Go is in the right track to follow their path.

Re:Rust in 2018: easier to use by dullgiulio on Sunday January 14, 2018 @09:01AM (#16144261)
It's pretty bad that people outside the SV can code /s
Re:Rust in 2018: easier to use by wwweston on Sunday January 14, 2018 @12:32PM (#16145182)
Exactly. :)
Re:Rust in 2018: easier to use by singhrac on Sunday January 14, 2018 @07:49AM (#16144049)
Software is more than just language features. Rob undoubtedly meant that he wanted it to be quick to be understood by a vast majority of Googlers, so that they can focus on writing good software.
Re:Rust in 2018: easier to use by pjmlp on Sunday January 14, 2018 @08:00AM (#16144079)
Yet Google is known for having one of the hardest hiring processes, where they even give the candidates CS subjects to study before the interview.
Re:Rust in 2018: easier to use by shaklee3 on Sunday January 14, 2018 @03:56PM (#16146374)
He really said they're not capable?
Re:Rust in 2018: easier to use by nicoburns on Sunday January 14, 2018 @05:19PM (#16146831)
Rust's USP over Go isn't more speed, it's better abstraction, and better correctness. Go is definitely a good tool for microservices, and it isnt going anywhere. But writing Rust is a joy, and I wouldnt be at all surprised if it also carves itself a niche in this area.
Re:Rust in 2018: easier to use by FridgeSeal on Sunday January 14, 2018 @04:53PM (#16146707)
I'm actually writing a lambda function in Rust at work right now! Whilst I could do it in Python, it was straightforward enough to be a good first thing to try with Rust and it's actually been easier to write than I anticipated.

Plus the performance benefits will be nice.

Re:Rust in 2018: easier to use by Shoothe on Sunday January 14, 2018 @08:48AM (#16144226)
Thanks for mentioning the page. I'm about to write a simple JSON/HTTP service and decided to use Rust but I was wondering why the author would not use Rust for web services.
Re:Rust in 2018: easier to use by Yuioup on Sunday January 14, 2018 @04:25AM (#16143463)
Just out of curiosity, how many web framework platform are originally written and compiled in C? CPython, udev, node, v8, ... rust?
Re:Rust in 2018: easier to use by Tuna-Fish on Sunday January 14, 2018 @05:37AM (#16143662)
IIRC, the rust compiler started out as an OCaml project, but is now self-hosting.
Re:Rust in 2018: easier to use by steveklabnik on Monday January 15, 2018 @08:25AM (#16150307)
This is true.
Re:Rust in 2018: easier to use by dmitriid on Sunday January 14, 2018 @05:35AM (#16143655)
The platform may be written in C. The OS you're running microservices on is written in C/C++.

It doesn't mean that your services are written in C/C++.

Re:Rust in 2018: easier to use by penetrarthur on Sunday January 14, 2018 @01:15PM (#16145406)
It is not about languages. It is mostly about frameworks. I want to write my next web project in a mature framework.