[gsoc]

[Laeeth Isharc]

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)
     # horrible but works, essentially unsigned char buf[100]
     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.