www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - [gsoc]

reply Drason Chow <drasonchow gmail.com> writes:
Hey everyone! I'm a bit new to the D community but I've kinda 
fallen in love with the language.

Currently and sophomore undergrad studying Intelligent Systems 
(focus on robotics and automation). Work quite bit with real-time 
applications. Most of my current work uses sensors and systems to 
study and model human and animal behaviors.

We're working on building haptic devices that can render forces. 
I've found myself having to use more C++ than savory. We 
prototype a lot in Python and it can be really tedious to 
translate our prototypes to C++. Got a feel for Mir and D in 
general and it feels great! I'd love to help flesh it out in this 
area.

Would love to do some sort of GSoC project with the community 
going into 2020. I really liked the hardmetal D project from 2019 
and the ROS proposal in 2018 (though looks like that one was 
rejected).

I'm wondering what I can do to get started towards it. I 
currently operate a couple GitHub accounts (one for my lab and 
one personal that I fork stuff I work on from other accounts as 
well as put personal projects). I heard that maybe I should start 
a blog (was already working it actually :P)? If anyone could 
provide some guidance it'd be great.

Thanks for responses!
Dec 31 2019
parent Laeeth Isharc <laeeth kaleidic.io> writes:
On Tuesday, 31 December 2019 at 20:36:11 UTC, Drason Chow wrote:

 Hey everyone! I'm a bit new to the D community but I've kinda 
 fallen in love with the language.

 Currently and sophomore undergrad studying Intelligent Systems 
 (focus on robotics and automation). Work quite bit with 
 real-time applications. Most of my current work uses sensors 
 and systems to study and model human and animal behaviors.

 We're working on building haptic devices that can render 
 forces. I've found myself having to use more C++ than savory. 
 We prototype a lot in Python and it can be really tedious to 
 translate our prototypes to C++. Got a feel for Mir and D in 
 general and it feels great! I'd love to help flesh it out in 
 this area.

 Would love to do some sort of GSoC project with the community 
 going into 2020. I really liked the hardmetal D project from 
 2019 and the ROS proposal in 2018 (though looks like that one 
 was rejected).

 I'm wondering what I can do to get started towards it. I 
 currently operate a couple GitHub accounts (one for my lab and 
 one personal that I fork stuff I work on from other accounts as 
 well as put personal projects). I heard that maybe I should 
 start a blog (was already working it actually :P)? If anyone 
 could provide some guidance it'd be great.

 Thanks for responses!


Hi Drason and welcome.

I've often found its best to try something and see what happens 
rather than ask if it's a good idea, provided nothing terrible 
can happen if it doesn't work.

Walter Bright has written about the importance for programmers of 
having a personal home page and maybe blog, and I concur.

Autowrap is coming along - you can even use it to generate python 
bindings to C code when combined with DPP.

https://github.com/atilaneves/python-dpp-nanomsg

```
import autowrap;
mixin(wrapDlang!(LibraryName("nanomsg"), 
Modules(Yes.alwaysExport, "nanomsg")));
```

```
#include "nanomsg/nn.h"
#include "nanomsg/pipeline.h"
```

```
def test_push_pull():
     from nanomsg import (nn_socket, nn_close, nn_bind, nn_connect,
                          nn_send, nn_recv,
                          AF_SP, NN_PUSH, NN_PULL)
     import time

     uri = "inproc://test"

     pull = nn_socket(AF_SP, NN_PULL)
     raise_on_nanomsg_error(pull)
     raise_on_nanomsg_error(nn_bind(pull, uri))
     time.sleep(0.05)

     push = nn_socket(AF_SP, NN_PUSH)
     raise_on_nanomsg_error(push)
     raise_on_nanomsg_error(nn_connect(push, uri))
     msg = b'abc'
     assert nn_send(push, msg, len(msg), 0) == len(msg)

     time.sleep(0.05)

     buf = 100 * b'o'
     assert nn_recv(pull, buf, len(buf), 0) == len(msg)
     assert buf[0:len(msg)] == msg

     raise_on_nanomsg_error(nn_close(push))
     raise_on_nanomsg_error(nn_close(pull))


def raise_on_nanomsg_error(errorcode):
     from nanomsg import nn_strerror
     import ctypes

     if errorcode < 0:
         raise RuntimeError(nn_strerror(ctypes.get_errno()))

```

Others will know better, but I think if people are familiar with 
your work and have a good impression then you are more likely to 
be accepted.  You could look at some of the outstanding pull 
requests on druntime or help with making more tests for Phobos 
for betterC mode - Seb made a start.

I think D now works on the STM series used in Arduino so you 
could do something there too.
Jan 06 2020