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!

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.