[rust-dev] Rust Research Project Query

[Victor Barua]

Dear Rust Developers,

I'm a senior Computer Science undergraduate student at the University of
British Columbia. As part of my degree I have to complete an undergraduate
thesis which is a project of around 220 hours between now and next April.
Rust is a language that has caught my eye and I would be very interested in
working on something related to it that I could contribute back to the
community at the end of my project.

I was hoping to ask the community for ideas on any tools, language features
or research that would be useful to the community and fit the scope of 220
hours undergraduate project. I apologize in advance if this is the wrong
forum to post such a question.

Cordially,

Victor I. Barua
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.mozilla.org/pipermail/rust-dev/attachments/20141008/1a7cf7d3/attachment.html>

[Erick Tryzelaar]

Hey there Victor,

There are plenty of interesting projects that need to get done. The places
I would suggest looking would be the active RFCs [1] and the interesting
projects in our bug database [2]. Before you do anything though, you should
check with the RFC author to see if someone's already started working on
it. Also, I highly recommend coming into our irc channel #rust on
irc.rust-lang.org [3]. I'm sure people there will have even more ideas for
you.

Welcome to the project!
- Erick

[1]: https://github.com/rust-lang/rfcs
[2]:
https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-an-interesting-project
[3]: http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust




On Wed, Oct 8, 2014 at 10:51 AM, Victor Barua <victor.barua at gmail.com>

Post by Victor Barua
Dear Rust Developers,
I'm a senior Computer Science undergraduate student at the University of
British Columbia. As part of my degree I have to complete an undergraduate
thesis which is a project of around 220 hours between now and next April.
Rust is a language that has caught my eye and I would be very interested in
working on something related to it that I could contribute back to the
community at the end of my project.
I was hoping to ask the community for ideas on any tools, language
features or research that would be useful to the community and fit the
scope of 220 hours undergraduate project. I apologize in advance if this is
the wrong forum to post such a question.
Cordially,
Victor I. Barua
_______________________________________________
Rust-dev mailing list
Rust-dev at mozilla.org
https://mail.mozilla.org/listinfo/rust-dev

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.mozilla.org/pipermail/rust-dev/attachments/20141008/7690cb45/attachment.html>

[Sean McArthur]

A project I'd love to see (either separate, or eventually baked into the
test harness), is test coverage data. Something like how Go's cover[1]
works, by adding counters to the source code, seems simplest. I've thought
about this, and it could either be a CLI tool, like `rustc --cover --test`,
or a plugin. Perhaps including a `#![cover]` attribute in the crate or
something. With a plugin, the Plugin Registrar would need to add the
ability to register a Visitor that can modify the AST.

[1] http://blog.golang.org/cover
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.mozilla.org/pipermail/rust-dev/attachments/20141008/2219075d/attachment.html>

[Corey Richardson]

LLVM already has support for instrumenting code to generate gcov data,
I believe Luqman and Huon have looked into this, at least slightly.

Post by Sean McArthur
A project I'd love to see (either separate, or eventually baked into the
test harness), is test coverage data. Something like how Go's cover[1]
works, by adding counters to the source code, seems simplest. I've thought
about this, and it could either be a CLI tool, like `rustc --cover --test`,
or a plugin. Perhaps including a `#![cover]` attribute in the crate or
something. With a plugin, the Plugin Registrar would need to add the ability
to register a Visitor that can modify the AST.
[1] http://blog.golang.org/cover
_______________________________________________
Rust-dev mailing list
Rust-dev at mozilla.org
https://mail.mozilla.org/listinfo/rust-dev

[Manish Goregaokar]

Servo has a bunch of student projects
<https://github.com/servo/servo/wiki/Student-projects> that you might be
interested in.

-Manish Goregaokar

Post by Corey Richardson
LLVM already has support for instrumenting code to generate gcov data,
I believe Luqman and Huon have looked into this, at least slightly.

Post by Sean McArthur
A project I'd love to see (either separate, or eventually baked into the
test harness), is test coverage data. Something like how Go's cover[1]
works, by adding counters to the source code, seems simplest. I've

thought

Post by Sean McArthur
about this, and it could either be a CLI tool, like `rustc --cover

--test`,

Post by Sean McArthur
or a plugin. Perhaps including a `#![cover]` attribute in the crate or
something. With a plugin, the Plugin Registrar would need to add the

ability

Post by Sean McArthur
to register a Visitor that can modify the AST.
[1] http://blog.golang.org/cover
_______________________________________________
Rust-dev mailing list
Rust-dev at mozilla.org
https://mail.mozilla.org/listinfo/rust-dev

--
http://octayn.net/
_______________________________________________
Rust-dev mailing list
Rust-dev at mozilla.org
https://mail.mozilla.org/listinfo/rust-dev

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.mozilla.org/pipermail/rust-dev/attachments/20141009/4f08848b/attachment.html>

[Davis Silverman]

Well, I've been looking forward to an actor library (
https://github.com/rust-lang/rust/issues/3573) although I think someone
already wrote a paper on that.

You could look into Rust's wishlist issues
<https://github.com/rust-lang/rust/labels/I-wishlist?page=3&q=is%3Aopen+label%3AI-wishlist>
or
the "An Interesting Project"
<https://github.com/rust-lang/rust/labels/A-an-interesting-project> issues

Rust also has been looking to verify that the type system works? Niko
has a redex
model <https://github.com/nikomatsakis/rust-redex> and you can probably
work with that.

Sincerely,
~~Davis Silverman
~Sinistersnare


On Wed, Oct 8, 2014 at 9:27 PM, Manish Goregaokar <manishsmail at gmail.com>

Post by Manish Goregaokar
Servo has a bunch of student projects
<https://github.com/servo/servo/wiki/Student-projects> that you might be
interested in.
-Manish Goregaokar

Post by Corey Richardson
LLVM already has support for instrumenting code to generate gcov data,
I believe Luqman and Huon have looked into this, at least slightly.

Post by Sean McArthur
A project I'd love to see (either separate, or eventually baked into the
test harness), is test coverage data. Something like how Go's cover[1]
works, by adding counters to the source code, seems simplest. I've

thought

Post by Sean McArthur
about this, and it could either be a CLI tool, like `rustc --cover

--test`,

Post by Sean McArthur
or a plugin. Perhaps including a `#![cover]` attribute in the crate or
something. With a plugin, the Plugin Registrar would need to add the

ability

Post by Sean McArthur
to register a Visitor that can modify the AST.
[1] http://blog.golang.org/cover
_______________________________________________
Rust-dev mailing list
Rust-dev at mozilla.org
https://mail.mozilla.org/listinfo/rust-dev

--
http://octayn.net/
_______________________________________________
Rust-dev mailing list
Rust-dev at mozilla.org
https://mail.mozilla.org/listinfo/rust-dev

_______________________________________________
Rust-dev mailing list
Rust-dev at mozilla.org
https://mail.mozilla.org/listinfo/rust-dev

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.mozilla.org/pipermail/rust-dev/attachments/20141008/4854bb3a/attachment.html>

[Victor Barua]

There has been some work done on generating gcov data based on:
https://github.com/rust-lang/rust/issues/690

Looking at cover though there appear to be benefits of doing this at the
language level. More importantly, at least for me, based on feedback from
my supervisor implementing something like cover has multiple qualities that
would make it a good thesis project (plus it looks like it would be fun) so
that closes the deal for me. Thanks for the ideas everyone.

Post by Corey Richardson
LLVM already has support for instrumenting code to generate gcov data,
I believe Luqman and Huon have looked into this, at least slightly.

Post by Sean McArthur
A project I'd love to see (either separate, or eventually baked into the
test harness), is test coverage data. Something like how Go's cover[1]
works, by adding counters to the source code, seems simplest. I've

thought

Post by Sean McArthur
about this, and it could either be a CLI tool, like `rustc --cover

--test`,

Post by Sean McArthur
or a plugin. Perhaps including a `#![cover]` attribute in the crate or
something. With a plugin, the Plugin Registrar would need to add the

ability

Post by Sean McArthur
to register a Visitor that can modify the AST.
[1] http://blog.golang.org/cover
_______________________________________________
Rust-dev mailing list
Rust-dev at mozilla.org
https://mail.mozilla.org/listinfo/rust-dev

--
http://octayn.net/

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.mozilla.org/pipermail/rust-dev/attachments/20141012/f11743a7/attachment.html>

[Tony Arcieri]

On Wed, Oct 8, 2014 at 10:51 AM, Victor Barua <victor.barua at gmail.com>

Post by Victor Barua
I'm a senior Computer Science undergraduate student at the University of
British Columbia. As part of my degree I have to complete an undergraduate
thesis which is a project of around 220 hours between now and next April.
Rust is a language that has caught my eye and I would be very interested in
working on something related to it that I could contribute back to the
community at the end of my project.

What are you interested in? I think it'd be really cool to create a
language based on Rust for proving properties about Rust programs using
things like dependent types, refinement types, or otherwise.

[Victor Barua]

I'm interested in a project from a programming languages perspective. It's
an area I've recently gotten into and it would also align with the research
focus of my supervisor. I think it would be interesting to work on some
static analysis tooling. Sean mentioned a test coverage tool earlier in the
thread which is actually a pretty good baseline for a project as it's a
combination of mucking with the language internals (which I could talk
about in a report) and implementing a useful tool. Your idea about proving
properties of Rust programs would also make an excellent project as its a
great combination of theory and implementation.

I'd like to thank everyone for the ideas so far, there's a lot of good
material and I'm slowly accumulating project ideas to run past my
supervisor. If you've got more keep them coming.

Post by Erick Tryzelaar
On Wed, Oct 8, 2014 at 10:51 AM, Victor Barua <victor.barua at gmail.com>

Post by Victor Barua
I'm a senior Computer Science undergraduate student at the University of
British Columbia. As part of my degree I have to complete an undergraduate
thesis which is a project of around 220 hours between now and next April.
Rust is a language that has caught my eye and I would be very interested in
working on something related to it that I could contribute back to the
community at the end of my project.

What are you interested in? I think it'd be really cool to create a
language based on Rust for proving properties about Rust programs using
things like dependent types, refinement types, or otherwise.
--
Tony Arcieri

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.mozilla.org/pipermail/rust-dev/attachments/20141008/ff356121/attachment.html>

[Tuncer Ayaz]

Post by Victor Barua
I'm interested in a project from a programming languages
perspective. It's an area I've recently gotten into and it would
also align with the research focus of my supervisor. I think it
would be interesting to work on some static analysis tooling. Sean
mentioned a test coverage tool earlier in the thread which is
actually a pretty good baseline for a project as it's a combination
of mucking with the language internals (which I could talk about in
a report) and implementing a useful tool. Your idea about proving
properties of Rust programs would also make an excellent project as
its a great combination of theory and implementation.
I'd like to thank everyone for the ideas so far, there's a lot of
good material and I'm slowly accumulating project ideas to run past
my supervisor. If you've got more keep them coming.

Two things I've been missing which are language level problems:

alignment syntax
https://github.com/rust-lang/rust/issues/4578
https://github.com/rust-lang/rfcs/issues/282
https://github.com/rust-lang/rfcs/issues/325

bit syntax
https://github.com/rust-lang/rust/issues/5346
https://github.com/rust-lang/rfcs/issues/346

[Josh Matthews]

Finishing the DXR (https://wiki.mozilla.org/DXR) support for Rust that Nick
Cameron started would be extremely valuable and intersect with your static
analysis interests. https://bugzilla.mozilla.org/show_bug.cgi?id=956768 is
our tracking metabug for the DXR-side work that is still required;
presumably Nick (nrc on irc) can clarify the Rust-side stuff remaining.

Cheers,
Josh

Post by Victor Barua
I'm interested in a project from a programming languages perspective. It's
an area I've recently gotten into and it would also align with the research
focus of my supervisor. I think it would be interesting to work on some
static analysis tooling. Sean mentioned a test coverage tool earlier in the
thread which is actually a pretty good baseline for a project as it's a
combination of mucking with the language internals (which I could talk
about in a report) and implementing a useful tool. Your idea about proving
properties of Rust programs would also make an excellent project as its a
great combination of theory and implementation.
I'd like to thank everyone for the ideas so far, there's a lot of good
material and I'm slowly accumulating project ideas to run past my
supervisor. If you've got more keep them coming.

Post by Erick Tryzelaar
On Wed, Oct 8, 2014 at 10:51 AM, Victor Barua <victor.barua at gmail.com>

Post by Victor Barua
I'm a senior Computer Science undergraduate student at the University of
British Columbia. As part of my degree I have to complete an undergraduate
thesis which is a project of around 220 hours between now and next April.
Rust is a language that has caught my eye and I would be very interested in
working on something related to it that I could contribute back to the
community at the end of my project.

What are you interested in? I think it'd be really cool to create a
language based on Rust for proving properties about Rust programs using
things like dependent types, refinement types, or otherwise.
--
Tony Arcieri

_______________________________________________
Rust-dev mailing list
Rust-dev at mozilla.org
https://mail.mozilla.org/listinfo/rust-dev

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.mozilla.org/pipermail/rust-dev/attachments/20141009/510e1576/attachment.html>

[Nick Cameron]

Finishing DXR is probably quite boring - it mostly just needs porting to a
different database at this stage. Although I'd be happy to have some help
:-)

One area I haven't touched with DXR yet and would like to see done is
handling macros, I think there is enough info in the compiler to do this
really well, and if there is not, we should add it. If you're keen, ping
me, I'd be happy to see this worked on.

On a different note, I would be really keen to see dynamic or static
analysis of unsafe blocks to show that they do in fact re-establish the
invariants that the rust compiler expects by the end of the unsafe block. I
expect this is hard to do, but would be super-interesting research.

Cheers, Nick.

On Fri, Oct 10, 2014 at 5:06 AM, Josh Matthews <josh at joshmatthews.net>

Post by Josh Matthews
Finishing the DXR (https://wiki.mozilla.org/DXR) support for Rust that
Nick Cameron started would be extremely valuable and intersect with your
static analysis interests.
https://bugzilla.mozilla.org/show_bug.cgi?id=956768 is our tracking
metabug for the DXR-side work that is still required; presumably Nick (nrc
on irc) can clarify the Rust-side stuff remaining.
Cheers,
Josh

Post by Victor Barua
I'm interested in a project from a programming languages perspective.
It's an area I've recently gotten into and it would also align with the
research focus of my supervisor. I think it would be interesting to work on
some static analysis tooling. Sean mentioned a test coverage tool earlier
in the thread which is actually a pretty good baseline for a project as
it's a combination of mucking with the language internals (which I could
talk about in a report) and implementing a useful tool. Your idea about
proving properties of Rust programs would also make an excellent project as
its a great combination of theory and implementation.
I'd like to thank everyone for the ideas so far, there's a lot of good
material and I'm slowly accumulating project ideas to run past my
supervisor. If you've got more keep them coming.

Post by Erick Tryzelaar
On Wed, Oct 8, 2014 at 10:51 AM, Victor Barua <victor.barua at gmail.com>

Post by Victor Barua
I'm a senior Computer Science undergraduate student at the University
of British Columbia. As part of my degree I have to complete an
undergraduate thesis which is a project of around 220 hours between now and
next April. Rust is a language that has caught my eye and I would be very
interested in working on something related to it that I could contribute
back to the community at the end of my project.

What are you interested in? I think it'd be really cool to create a
language based on Rust for proving properties about Rust programs using
things like dependent types, refinement types, or otherwise.
--
Tony Arcieri

_______________________________________________
Rust-dev mailing list
Rust-dev at mozilla.org
https://mail.mozilla.org/listinfo/rust-dev

_______________________________________________
Rust-dev mailing list
Rust-dev at mozilla.org
https://mail.mozilla.org/listinfo/rust-dev

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.mozilla.org/pipermail/rust-dev/attachments/20141013/7596d804/attachment.html>

[Daniel Micay]

Post by Nick Cameron
On a different note, I would be really keen to see dynamic or static
analysis of unsafe blocks to show that they do in fact re-establish the
invariants that the rust compiler expects by the end of the unsafe
block. I expect this is hard to do, but would be super-interesting research.

Unsafety isn't currently contained within unsafe blocks even in correct
code. The lack of unsafe fields means leaning on the privacy systems to
implement much of the unsafe code in the standard libraries.

-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: OpenPGP digital signature
URL: <http://mail.mozilla.org/pipermail/rust-dev/attachments/20141012/6b185ccf/attachment.sig>

[Alfie John]

Hey Victor,

Post by Victor Barua
I was hoping to ask the community for ideas on any tools, language features
or research that would be useful to the community and fit the scope of 220
hours undergraduate project. I apologize in advance if this is the wrong
forum to post such a question.

If you're keen, how about an generic database interface like:

- DBI (https://metacpan.org/pod/DBI)
- Class::DBI (https://metacpan.org/pod/Class::DBI)

Alfie