Sylvan Clebsch and Sophia Drossopoulou (credited on Project Verona in a slide) work on the Pony, which has been described as a cross between Rust and Erlang.
The slides don't really add much detail. They're just a light introduction to the sort of region-based memory management that was already being used by Cyclone, well before the Rust project was even a thing.
> already being used by Cyclone, well before the Rust project was even a thing.
Let’s be a little more accurate here. Rust is an actively developed language, Cyclone was a research project that I don’t believe has received an update since 2006.
Rust also is explicit that it borrowed its lifetime concept from Cyclone. Rust is in use and gaining popularity in a way that Cyclone didn’t.
This is a bit like the debate between Apple and Xerox in terms of the beginnings of the desktop/mouse/GUI environment. Apple was the first to make it popular, xerox park invented it. Rust has a similar relationship with Cyclone.
It's clear to most that rust invented few, but that nobody cared because we just wanted these features to reach the mainstream, which rust embodies. Maybe the rust trend train gives people a false impression of innovative messiah... I don't know.
Process boundaries help you when you start jumping through a ROP chain that spawns a shell because your process doesn't have access to things that it shouldn't, even when compromised. Calling Heartbleed an example of a process "changing its behavior" doesn't really make sense in the context of exploits that can cause arbitrary code execution.
I always knew Rust was picking up from Cyclone, but I was, stupid enough to assume Cyclone was half baked, half finish programming languages with the Ownership idea.
It wasn't until today I did a search on it, and it reached 1.0!
Why wasn't Cyclone being used or continue to be developed?
The big breakthrough with Rust was ownership, and Microsoft seems to agree on that. Rust has a lot of other baggage that could be dispensed with. Of course, Microsoft has their own baggage.
I disagree about ownership being the big break through, I’d argue it’s the concept of multiple aliasing and handling that at the syntactic level through the borrow checker that leads to all the safety guarantees of Rust.
Microsoft has a huge problem: thousands of coders who aren't disciplined enough to write reliable code. They need a language to provide the needed discipline. They tried making their own language, and now understand that they are not good enough at that, either. Rust, or a fork of Rust, might suffice.
They are not interested in displacing Rust from wherever it is being used. They just need something for their things, that their customers can also use. Lock-in is exercised farther up the chain.
Talks about sandboxing C/C++ libraries that interact with Rust. Kinda make a safe unsafe sandbox Rust interface ("less unsafe?") if I understand it correctly (I likely don't).
The actual linked article is all over the place, I cannot make heads or tails of it and seems to be conflating multiple security issues/mitigations together into a mish mash.
Basically a new language for system software and containers that allow to tame existing software, due to the expenses of rewriting everything into safe languages.
> The actual linked article is all over the place, I cannot make heads or tails of it and seems to be conflating multiple security issues/mitigations together into a mish mash.
I'm surprised Microsoft didn't "invent" their own version of Go yet. Actually I'd use it in a heartbeat over Google's if they add generics to it. Just call it "Micro".
D is pretty much the opposite of Go, a pinnacle of feature bloat instead of stripped down simplicity. A C++ killer that turned into a kind of C++ with GC.
Go would be have an interesting language in 1986 [0], or in 1995 [1].
As it stands, it is forced to follow some of Java design mistakes by not integrating modern features and then being forced to actually adopt them in a half-baked way due to market pressure, while striving not to break backwards compatibility with existing code.
Modern C++ also uses GC, even it is opt-in.
And several modern C++ features actually originated in D.
D has the benefit of not being constrained by C copy-paste compatibility like C++.
But yeah, it suffers from having a tiny community.
If Go's design was perfect, its eco-system wouldn't feel like Java 1.0, full with libraries to replicate what should be language features to start with.
The first time I saw "go generate" it was on Borland C++ 2.0 for MS-DOS, released around 1990.
Zig's comptime is a very simple and minimalistic but still incredibly useful and strong approach to generics. I think that could fit into a language like that. I many ways I find Zig as keeping the minimalism trait that Go has (which they both take from C). But I get that people want a gc sometimes.
I'm curious what the next big language iteration will bring. It's been a while that I got excited about a new language, last time was probably C#, but that's 20 years ago... Crazy, that there hasn't been any new language revolution sort of how Java was one. But maybe I should look more into new things like Julia, but they seem a bit niche.
I hope the next big programming language will be one that is split into two language-variants: the "low-level-variant" and the "high-level-variant".
The high-level-variant is a dynamic language with optional typing, which is good for scripting, fast prototyping, fast time-to-market, etc.
The low-level-variant is similar to the high-level-variant (same syntax, same features mostly, same documentation), but it has no garbage collector, typing is mandatory and it runs fast like C/C++/Rust. Compiled packages that are written in the low-level-variant can be used from the high-level-variant with minimal effort or without additional effort at all. The tooling to achieve this comes with the language.
Yes, and I think Julia is a perfect starting point for an extremely productive general purpose language.
The one major wart with Julia is reliance on GC, I'm interested to hear what workarounds exist. If no common usage patterns rely on the GC, it should be possible to write "recycling" code that doesn't incur GC pauses and hence, unpredictable latency.
I really enjoy using Julia, it's a great balance of concision, expressiveness, and performance.
There is a common demand from people for extracting just a very concrete computation from a julia codebase and compiling it to a standalone library (or even just using it within an existing julia program, but guaranteeing certain allocation or real time behavior). For example, julia includes a pure julia implementation of libm, but we also maintain the openlibm C library, since we link it into some of our C dependencies that need good quality math functions. It would be nice just to compile the julia version and have it be a drop in replacement for the libm that can be linked. Of course for that you don't want the runtime, or GC or code generator. The challenge here is coming up with the right interfaces and abstractions to make this a feasible and useful thing, without splitting the community into those that care about it and those that don't. We've started some work in this direction, but it isn't really usable yet.
Is some concept of language support for traits/ interfaces and/or static typing part of this effort?
Also, would there be different levels of leanness for the static compile? I can see some people wanting binaries that use a minimal runtime or GC, but no heavy JIT etc so that a larger set of programs can be distributed but at some tradeoff.
Yes, for sure my suggestion was an incomplete answer, but still you would want the lower language be GC-aware/GC-compatible so I am not sure what the advantages of having two languages would be compared to having a GC language that can have non-GC modules/functions.
We also have an example of something more similar to what you are asking with Javascript+wasm (or better Typescript+wasm). I think they are both a fertile ground for future growth.
I believe the next evolution will be to combine Rust and Lisp; a programming language as flexible as LISP without giving up the safety of Rust, including a typesystem that can be entirely coded in the language itself, safely.
I have something similar in mind: I want to have homoiconicity but with typed data underneath (instead of just untyped lists) in order to add some structure and let compiler help you with macros. That plus advanced type system with gradual verification. I'm in early exploration phase, but I have some ideas written down: https://github.com/krcz/zygote .
It's about the ability, not the reality. As Racket, the base language can have no explicit rules for any type systems to be embedded. There can be more powerful candidates, e.g. Kernel: https://web.cs.wpi.edu/~jshutt/kernel.html.
Racket is special because its designers provide dedicated support of language-oriented programming. But that is about ecosystems, not typesystems.
I would imagine something closer to rust in terms of base and then being able to put Haskell on top without loosing any safety guarantees. Or possibly even allowing an arbitrary type system as long as you can prove it's sound with the guarantees of the language.
Types are closed terms of contracts encoded in a language within specific phases. If you really need any guarantees without further knowledge shaped before running, then, besides the typechecking, the typing rules should also be programmable by users (rather than the language designer) for the sake of providing proofs. The base system must practically have no mandated static type systems at all, which is far from Rust.
Rust's current macro's aren't as powerful as I would like them, and procedural macros are far more difficult and extremely hard to properly develop and debug.
The substitution macros aren't that much fun either since they lack certain capabilities (like introducing a new variable into the current scope without having to specify the name redundantly).
Without a lot of external libraries, procedural macros are almost impossible to write in my experience.
Neither of them allows one to properly code onto the type system or replace it and neither is properly supported by the IDEs (or RLS).
I really like the idea of implementing mutability control at the level of a collective as opposed to a single object. A great many transactions are multi-object.
Love the idea that a Netscape-legacy language has traction there. I hope they don’t return to their pre-Nadella practices.
Actually in Rust you have a problem where you can't express partial access to a struct at a function level. This means that you can't put some code into a separate function right now, making use of closures/iterators harder. There are attempts to fix this ([1] [2]). If borrow checking is done on collections of objects instead, the problem can be tackled more easily I think.
There's some friction there, but in practice it's easy to work around most of the time. I'm not sure extending the type system there is worth the weight.
If they’re rewriting Windows core bits with it, that’d seem a fairly strong indicator their involvement with it is serious. That’d be unnecessary technical debt otherwise.
Windows on ARM is probably fine. Windows Phone and the like eventually lost (losing? I haven’t kept up) support, but phones are traditionally a 2ish year supported device and then they’re not targeted (specifically in the Android OEM arena). Windows proper they have business clients and if they don’t support it for a reasonable amount of time, Microsoft is basically hosed. It is, I imagine, why once they decided to kill off older IEs everything prior to latest and greatest was killed at the same time: they had supported them for far too long and it required killing them all Off in one move.
It is not like that. C was supported before GCC project also but it was not of any use because it wasn't widely used. Either we need open source alternatives or there must be competition based on open standards.
> C was supported before GCC project also but it was not of any use because it wasn't widely used.
I’m pretty sure you’ve got your history backwards. GCC was created specifically to fill the need for a free C compiler for GNU. By that time C was already popular by association with Unix.
One reason of why I'm using Rust is because it's built by a group of people that I like, and Microsoft is not on that list.
However, I always keep a open-mind, I mean, I don't see anybody will be hurt if Microsoft become a direct contributor of Rust language itself. In fact, I could like Microsoft a bit if they did invest in Rust. I hope they do that <delete>instead of trying to fork things/build something alike (if that's the case here)</delete> (I watched their intro, their design is different than Rust and I somehow like what they did there).
I'm about as old-school anti-Microsoft as it gets (I had a 4-digit slashdot ID!) but even I have to admit that they've been pretty serious in offering olive branches to the broader open source community in the past decade. I'm prepared to give them the benefit of the doubt.
If someone had told me ten years ago that my favourite code editing environment on the Linux desktop ten years later would be browser-tech-based, MIT-licensed, and made by Microsoft, I'd have stared at them like they had just grown a second head. But here we are. Interesting times, man.
Given MS history, EEE was the first thing I thought about too. Take something, extend, then claim it's superior and everyone should stop using the original.
But if it simply means they are making a new language using lessons from Rust - then why not.
Though I didn't quite get what problem they found with using the idea of scope based lifetimes per object, that they needed to redefine it in context of groups.
Given their past years of behavior and focus on dev tools, what in the world makes you think that would be the case? They ported their chromium browser to every platform from day 1.
But he’s not the CEO any longer and he hasn’t been for years. So why is what he did more than a decade ago relevant absent of evidence that he has any direct control of the company today?
One CEO doesn't make an evil empire. Bad influence remains. Many evil minions that were forged from Bill Gates and then Steve Ballmer are still in the company. And ontop of this, Microsoft is still a big money-driven Company, so some natural evilness is always there.
Microsoft has become better in the last years, but they still do bad things. So why should people trust the wholeheartly?
Many developers and entrepreneurs had numerous very bad experiences with the Microsoft of the 1990s-2000s and you're expecting them to just move on like nothing happened?
Remember Microsoft tried to kill the internet and could have succeeded if it wasn't for the efforts of many, the US DOJ included, to prevent them from obtaining total control through their operating system monopoly.
Alternatively it could be what Microsoft Research does a lot which is take some subset of a language and add capabilities, like software verification with F*.
> I guess shipping Windows API cargo crates makes too much sense. Does anyone have any context for gaps in Rust they are addressing?
I haven't finished digging through the OP, but it looks like a bunch of Microsoft employees (already aware of Rust's safety benefits) have started recognizing the commitment to FFI as well. My last project had a feature that depended on a bind to win32, which turned out to be the most time consuming aspect - as it demanded a bunch of tooling that was otherwise unnecessary (valgrind, etc). If they were to take stewardship of that interface, lots of unsafe{} would disappear overnight.
Seems like Microsoft really needs Rust. They've completely gutted their prized aggressive prerelease testing, and the quality of the software they expose users to has declined dramatically.
I heard 70% of their bugs are related to memory handling or off-by-one errors. About 7 severe bugs per year. It can cost them from anywhere between 100k to 10M to fix the bugs and problems caused by these bugs.
Lol, if they wanted to make it better they'd adopt some practices and tools from Linux to get common-sense developers interested instead of looking for MS drones that don't know why they do what they do.
WSL performance is terrible not to mention WSL 2 is still pre-release with lots of bugs and so is their updated terminal app. I don't even think WSL 2 will support Docker, and it is using a broken VM and Plan 9 to share files so you lose most of the performance benefits of Linux. It appears MS is trying to get people to try Linux on Windows and make it bad so that they get a negative first impression.
I think it's gonna be something good from the creators of Typescript, the most flexible and object oriented language. Microsoft created too many languages compared to any other company and they really one step ahead in this field.
As a big proponent of F# it annoys me how much one still needs to fight "but M$" arguments if I point out a thing that F# does well. The same thing seems to happen when discussing Haskell with people who know just enough to recognise the influence MSR employees have on it.
It almost makes me wonder how they/we can work around that sentiment now. Either hope for generational shift to eventually kill it, or perhaps have them make a point of landing projects outside of MS and hoping nobody notices(GitHub R++ or whatever).
Tips on how others approach these discussions with Microsoft haters greatly appreciated!
“Fool me once, shame on you. Fool me twice, shame on me”
I try to be objective as much as possible, but having witnessed almost all of Microsoft’s behavior through history, we have been fooled 100s if not 1000s of times. How many times do you let the fox back into the hen house?
The only thing I think when I read recent “Microsoft is so great” comments is that the person is either too young to have any real knowledge, or they have simply not been paying attention for the past few decades.
For anyone who has seen what they have done through all of history, it will take decades to believe they have truly changed.
All those people who worked at Microsoft in the 90's and 2000's now work for at hundreds of other companies throughout the industry. And a whole bunch of people who weren't even born in those times now work for Microsoft.
I don't think your opinion is objective at all. It's based on treating a collective as a single mind.
Collectives and companies can keep the same culture and habits even if all people who worked there left. Because people come and leave not in the one go - they do it gradually, so every new employee is "indoctrinated" into the company culture, then indoctrinating new people themselves, even if their mentors left.
Obviously ms doesn’t have a candidate must be ruthless two faced bad person interview assessment. I think you are missing a very important ingredient to a company and that is its culture. Company cultures get diluted to the better or to the worse. As in either the company changes the newer employees or the new employees change the company
Or you are just so bogged down in history that you have a difficulty changing your opinion. Few decades is a long time in our line of work.
Microsoft didn't change out of charity or ethics. They were forced by the direction industry was heading as a whole. Cloud, opensource software, Google, AWS started making Microsoft irrelevant unless they changed.
Bogged down in history. One has to admire at least a little bit this attempt at gaslighting someone into not trusting their own experiences and Microsoft's long negative track-record which they're still adding to.
The telemetry scandal which has been reported on everywhere proves that Microsoft just changed into another Google. They're still collecting telemetry today, in spite of all the protests. A few hours isn't a long time in our line of work...
The argument is that if a language is developed/mainly contributed by a single company there is an inherent risk of that language being suddenly discountinued or lacking features that are needed by other people/companies.
At least that's how I understand the critics against microsoft in this case.
I don't know where you got that impression -- every new Go proposal document posted to HN garners a significant amount of Google criticism. The most recent example I can think of is the fairly widely-argued criticism of the "go mod" proxy. Not to mention all of the criticism over Google's consistent mishandling of community concerns.
I am an older fart and my preference for my own products is C/C++/Delphi/FreePascal for servers/desktop and JavaScript for web front. I program in many other languages as well but mostly because clients require them. In the latter case it is a consulting job and the last thing I care about is how their favorite languages are managed. It is their choice and I am here to take their money, not to judge their preferences. Advising client to use particular language instead of their favorites is straight road to disappointment.
It's hard to be nice and fluffy in a market where there's a lot of competition, but there's degrees. When you deliberately attempt to sabotage other people's software that has to run on your OS, but competes with an MS Product (e.g. Lotus vs Excel) then it's stepping over a line.
Thanks goodness for Linux and the web (and later mobile computing which MS failed to dominate) to pull us away from the brink of an MS monoculture.
Big companies are not autonomous and do not make their own decisions, individual people working at those companies do. I think it’s safe to say that anyone working there today has nothing to do with the time periods you’re referencing, so I don’t know why you would consider decades old issues to be relevant today.
Less propaganda that the whole "do no evil" stuff.
Windows 10 telemetry is a child's game compared how much Google and FB spy on people's lives, yet most MS haters just jump of joy to use any tech that comes out from them.
Legions of US parents just put their kids under Google surveillance getting them Chromebooks.
OS spying is so much more invasive than application or service spying because you can’t opt out as easily. You can go without Facebook but a lot of people just need windows (for their jobs if nothing else, though I sure wish unity3d ran better on Linux and that more games ran smoothly on Linux)
The OS is also theoretically able to watch what you do in other services by monitoring keystrokes etc, where Facebook merely dreams of such things
Serious question: are there any major closed-source software companies (so like, not Red Hat or Canonical, etc) who don't lobby for or use software patents?
I consider using patents to extract payment a far lesser evil than lobbying for them. And an even lesser evil if the patent has some merit to it, and is licensed openly (i.e. no confidentiality terms to prevent revealing which parts of Android they claim to have patented).
As for your question - Cloudfront springs to mind - they're pretty loud about going after patent trolls, which implies they might not use patents aggressively. I'm sure there are many others, but a company not using patents to extract payment isn't something you hear about, so it's hard to tell. That said, despite filing for many patents, I haven't heard of Facebook actually using them against others. Which isn't to say they haven't done so (and possibly, like MS, kept the agreement confidential), and of course Facebook is hardly ethical itself.
Another poster says Microsoft joined the Open Invention Network, so perhaps in that area, they've reformed. Though they could still be lobbying for patents, which does much more damage to user freedom.
There was a medium post about Microsoft's culture and their inability to move on past Gates and Balmer about 6 weeks ago [1]. According to that article you are objectively wrong in saying "it’s safe to say that anyone working there today has nothing to do with the time periods you’re referencing". The article claims that the majority of the power within Microsoft still lays precisely in the hands of people who worked for the company during the times referenced.
I know you referenced that article to prove you point but it ultimately does just as good of job as saying the opposite.
One example:
"Microsoft is killing it. Revenue is up. Stock is up. Industry stature is up. The places where Microsoft finds itself thriving all have one thing in common: key made-men were pushed aside for better people."
I was contradicting the clearly false claim made by OP, not trying to give the nuanced portrayal from the article. The thesis of the article I posted is that Microsoft continues to be haunted by the vestiges of Gates' and Balmer's influence. I think your cherry picking of a single quote praising some positives the author provides to balance his polemic is purposefully misleading.
The original argument was: "Microsoft still has the elements of its previous bad behaviour in its DNA." The counter claim was: "No one from Microsoft during that time is still in the company". The article clearly supports the first claim and shows the second claim is at its face false. I encourage everyone to read the article and not to take speculations and misleading quotes as support for false ideas.
Does the fact that some Microsoft employees, even those in positions of influence, remain from that time matter? Does the fact that there are new successful employees, with entirely new ideas about products and management, matter?
The article demonstrates that Microsoft is a complex organization with both good and bad and is changing for the better even if it has a way to go.
Supporting the good and praising Microsoft for what they're doing well is going to make Microsoft better. Crapping on what they're doing well because of actions from 20 years is not rational or helpful.
If you are asking: "Should Microsoft get some credit for the positive things it has done" then the answer is clearly yes. Even during the time periods where Microsoft was universally (and legally) perceived to be engaged in unfair business practices my own feeling is that their overall contribution to IT was a net positive.
That does not change the fact that Microsoft is a risk. Google is a risk since they have a habit of shutting down projects. Oracle is a risk due to their insane licensing and consulting fees. Open Source is a risk since the contributors can just decided to drop support. Everything has elements of risk. I guess I just won't back down from someone claiming there is no risk in Microsoft because all the bad people are gone. That is an absurd claim that also happens to be false.
That's arguing against a straw man. Nobody is claiming all the bad people are gone. But the claim that Microsoft is all bad was the source of this whole thread.
I am not claiming you are making that argument. I'm responding to the original poster, relevant part quoted here: "I think it’s safe to say that anyone working there today has nothing to do with the time periods you’re referencing, so I don’t know why you would consider decades old issues to be relevant today."
As demonstrated, people working during the time periods he referenced are still working for Microsoft, contrary to this claim. This also addresses why someone should consider the risk of "decades old issues" when making decisions today.
My only beef right now with Microsoft is their insistence on having creepy telemetry in everything. As someone _very_ interested in F#, I encountered this recently with both Visual Studio Code and .NET Core.
I followed the linked threads and I don't see where it says telemetry is off by default. I just see people saying that it _should_ be off by default. Am I missing something?
Sorry, I misread the threads, I think you're right. There's notification when you install it, but the notification is that it's on by default. The notification also explains how to switch it off (with an environment variable).
> It almost makes me wonder how they/we can work around that sentiment now.
From my perspective, the issue ultimately is - why? What do I gain from using Microsoft software?
I worked at a Microsoft shop for a short period. All of the 'new MS' stuff I've personally worked with has certainly been Windows first.
Take C#. It might work on Linux, sure, but you have stuff like the .NET runtime taking forever to start, the reliance on Visual Studio, .NET Framework isn't open source because.... why?
Or perhaps you have Microsoft Teams - for which, despite it effectively being a web app - there is no Linux client and in Firefox half the features are disabled. Even on Windows it's literally a shit version of Slack which presumably exists solely because it's bundled with other Microsoft stuff or because the name has appeal to some PHBs.
For the most part from what I can tell it's all still either Windows first, or a crap version of something else, or both. There might be some minor researchy fun bits, but anything that seems to actually see wide use is all Windows stack.
What's the point? I read the article, and it pretty much feels like they want to Windowsify Rust. Why should I care about that?
Literally everything I read about Microsoft seems to be from people who want an excuse to use Windows, or something. I want Windows to burn and die in a fire; so what is there for me?
Microsoft is actively collecting billions of dollars by patent suing (or threatening to) Android providers despite contributing nothing to Android. That's what kind of company they are. They also make some great stuff, esp MS Research. I'm hesitant to use anything made by a company that patent trolls other companies, though. I don't feel safe in long term.
Why F# was needed in the first place? OCaml[1] is vastly superior, and doesn't require .NET since can be compiled into the native code. Just in the need of the better Windows platform support. And they add more features with time than F# devs.
I can add F# projects to existing solutions and use F# in some places, C# in others, and C++ in still others, heck even VB.NET can come by for a drink if I'm feeling shameless and not needing to keep up appearances.
OCaml cannot do that. I say this as someone who currently is finishing a year of F# study with plans to study Rust in 2020 and OCaml in 2021.
They could have ported ocaml to the clr instead of doing their own ms thing. They could have promoted ocaml instead of splitting the community interested in a practical ml derived language - with the consequence that today neither has a relevant user base.
The access to .net framework libraries is a huge asset. If I recall correctly, Ocaml standard library never nearly that complete, and the language was a bit moribond few years ago.
I did read that. So it's not a straight clone, but still, Rust has enough of an uphill battle as it is to reach wide adoption, without having its target market fragmented. So I would've been excited to see Microsoft embracing it instead of building a competitor. Not that I can necessarily judge them for that, but it's still disappointing.
It is objectively worse for there to be two such languages, one of which is poorly funded and the other funded by Microsoft than have one such language that is cross platform.
Also the Java oxygen is sucked out of the room by C#. All the OCaml oxygen is sucked out of the room by F#. A world where all the rust oxygen is sucked out of the room by R# and tied to the windows ecosystem is a bad one.
They've tried this shit with a dozen other languages and besides C# being better than Java, (even though the .NET ecosystem sucks) it's always ended terribly. C++/CLR, IronPython, IronRuby, J#, etc.
Having your tech embraced by Microsoft is the kiss of death.
>> Having rust as the only low level language with ownership concept isn't ideal either.
I dont agree. Proliferation of languages has it's down side. Very few are self hosting, with most being built with C++. Rust is a safe C++ replacement. We dont need a bunch of those.
I think the amount of trust depends on the team and what they are supposed to deliver. For example, I think that VS Code and Power BI teams can be trusted to have monthly updates that improve the product. But on the other hand, I am never able to trust MS on shipping any language features, as I got burnt so hard by .NET Core 1.0 and F# tooling in VS2017.
I have always seemed them as political wars between WinDev and DevTools.
Google is much worse regarding Android development.
They reboot frameworks faster than MS, each IO the set of best practices is completely new, when something is finally working alright they come with the new one around the corner, I guess it was required the pressure of game developers to finally start having a more polished NDK.
Three teams competing for the mobile OS (ChromeOS, Android, Flutter), with a fourth one not clear what is coming out of it.
A Java subset nowadays cherry picked from OpenJDK, still most likely never to go beyond Java 8 and whatever they are able to desugar into what ART is capable of.
And I bet that if it wasn't for Flutter's uptake, JetPack Composer would never had happened.
Have you used windows recently? It sounds like you have. I installed it last week for the first time in ten-ish years - afraid I have to describe it as disgusting and completely undoing all the supposedly open work pr they've been getting. I'm on the phone so can't rant, but the install was endless info requests, some sneaky eg can we have your location, no, would you like us to find your device if stolen, erm. Open the browser, news thumbnails riddled with adverts. The timeline, extend beyond 30 days by giving us info. On and on. Sorry, they looked as though they had changed direction, but that surface laptop now runs Linux.
EEE strikes again? Why not just use and contribute into the Rust itself? Why creating one more copy? They could have extended C2Rust[1][2] to support C++[3] and C# to ease their migration instead.
Oh no, I bet it's gonna be a C# flavored Rust. None of Rust's terse syntax and functional influence. It's going to be full-blown Java-style OOP with plenty of Wnd handles to be thrown around. Yikes, I certainly hope I am not right.
this is what I'm hoping for. Introducing memory safety is enough I dislike Rust because of how different it decided it needed to be compared to most other systems languages.
Slides: https://www.slideshare.net/KTNUK/digital-security-by-design-...