Nowy język programowania tworzony przez Microsoft. Na razie nic więcej
nie wiadomo. Najwięcej jeszcze informacji znalazłem w
https://www.infoworld.com/article/3487676/microsoft-
readies-new-language-for-safe-programming.html

Project Verona, incorporates three core ideas:

Data-race freedom, which gives up concurrent, arbitrary mutation to
enable scalable memory management with temporal safety without global
synchronization.
Concurrent owners, which provides a new concurrency model that
offers lightweight, asynchronous coordination of resources.
Linear regions, with the ownership model based on groups of
objects. This differs from the memory-safe Rust language, which is based
on a single object, Microsoft explained. In Verona, there are memory
management strategies per region. Also featured is compartmentalization
for legacy components.


Linearne regiony: to moźe być coś nowego, może nie będzie tak
wymagającyjak kompilator Rusta? Ciekawe czy będzie miał RTTI i metaklasy?

do góry

W dniu 09.12.2019 o 20:10, Borneq pisze:
> Linearne regiony: to moźe być coś nowego, może nie będzie tak
> wymagającyjak kompilator Rusta? Ciekawe czy będzie miał RTTI i metaklasy?

Na razie puste repozytorium : https://github.com/verona-lang/verona
ale warto zaglądać

do góry

On 12/12/19 11:22 PM, Borneq wrote:
> W dniu 09.12.2019 o 20:10, Borneq pisze:
>> Linearne regiony: to moźe być coś nowego, może nie będzie tak
>> wymagającyjak kompilator Rusta? Ciekawe czy będzie miał RTTI i metaklasy?
>
> Na razie puste repozytorium : https://github.com/verona-lang/verona
> ale warto zaglądać


Są nowe wieści:
https://bulldogjob.pl/news/912-verona-nowy-jezyk-od-
microsoft-research

Badacze z Microsoft Research udostępnili niedawno na GitHubie zalążek
nowego języka programowania, który nazwali Verona. Język ten ma się
skupiać na badaniu możliwości wykorzystania modelu współbieżności
opartego na własności (ownership). Microsoft zdecydował się na
upublicznienie projektu, pomimo bardzo wczesnego etapu prac, by zachęcić
najlepszych programistów oraz badaczy do wspólnej pracy nad językiem.
......

Widać, że tutaj najbardziej skupiają się na wielowątkowości.


I repozytorium:
https://github.com/microsoft/verona

a jeszcze inny język:
https://bulldogjob.pl/news/572-bosque-nowy-jezyk-pro
gramowania-od-microsoftu

któ(C)y ma upraszczać składnię

do góry

Czy może ktoś wyjasnić składnię, np:
----------------------------------------------------
------------
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
class Fib
{
/**
* This example illustrates creating a lot of recursive work by
calculating
* fibonacci numbers top down.
*
* It uses promises to allow results to be reacted to.
*
* The compiler does not have syntax support for promises, and they
are just
* treated as a special type of cown at the moment. This will change
but the
* code illustrates roughly how they would be used.
*
* Cown's only currently wrap object types, not primitives, so the
example
* uses a U64Obj, that boxes a U64. This is not essential, and will be
* addressed in the future.
*
* The idealised syntax we are aiming for is given below
* fib(x: U64): promise[U64]
{
if (x < 2)
{
// Implicitely lifting a Value to a promise
1
}
else
{
// When returns a promise for the value it evaluates to.
// Thus nested when would require an implicit coercion from
// promise[promise[U64]] to promise[U64]
when ()
{
var p1 = Fib.fib(x - 1);
var p2 = Fib.fib(x - 2);
when (p1, p2) {
p1 + p2
}
}
}
}
*/

fib(x: U64 & imm): cown[U64Obj] & imm
{
var pw = Promise.create();
var pr = (mut-view pw).wait_handle();

if (x < 2)
{
pw.fulfill(U64Obj.create(1));
}
else
{
// `when` with no arguments used to start a new asynchronous task.
// Better syntax may be needed for this.
// This is required, so that the whole promise graph isn't
constructed
// sequentially.
when ()
{
var p1 = Fib.fib(x - 1);
var p2 = Fib.fib(x - 2);
// When both computations complete, fulfill the result with the
addition
// of the two sub calls.
when (p1, p2) {
var r = U64Obj.create(p1.v + p2.v);
pw.fulfill(r)
}
}
};
pr
}
}

class Main
{
main()
{
when (var uo = Fib.fib(12))
{
// CHECK-L: result=233
Builtin.print1("result={}\n", uo.v);
}
}
}
----------------------------------------------------
------------
kompiluje się, najpierw (po skompilowaniu kompilatora i interpretera):
~/veronac --output fib fib.verona
potem
~/interpreter --cores 2 fib
--cores nieobowiązkowe
można zamiast interpretera od razu uruchamić przez kompilator, ale warto
skompilować do kodu bajtowego.
zamiast 12 mozna wpisać 24, lepiej nie wpisywać wię...szych wartości typu
120 bo złożoność jest wykładnicza.
co oznaczają
1.Promise
2.when
3.mut-view
4.fulfill
szkoda że nie ma większego opisu, dokumentacji.

do góry

On 1/31/20 7:43 PM, Borneq wrote:
> ~/interpreter --cores 2 fib

u mnie najlepszy czas jest dla --cores 2 bo mam na razie procesor
dwukorowy, choć można by użyć w przyszłości verony na karcie graficznej,
skoro tak dobrze radzi sobie z wątkami.

do góry

On 1/31/20 7:49 PM, Borneq wrote:
> On 1/31/20 7:43 PM, Borneq wrote:
>> ~/interpreter --cores 2 fib
>
> u mnie najlepszy czas jest dla --cores 2 bo mam na razie procesor
> dwukorowy, choć można by użyć w przyszłości verony na karcie graficznej,
> skoro tak dobrze radzi sobie z wątkami.

Nikt się nie interesuje Veroną?

do góry