What's everyone working on this week (33/2018)?


#1

New week, new Rust! What are you folks up to?


#2

Learning Concurrency.


#3

Implementing some new features for https://github.com/ruscur/snowpatch


#4

Im still working on my weather station. My current goal is to reduce the power consumption when idle from ~60-100 mA to as little as possible. Turning off the wifi module took it down to ~10 mA so now im going to investigate turning off the CPU while in standby as well.


#5

I started working on a new project: Providing Rust support for the Decawave DWM1001, a board that can be used for short-range wireless communication and indoor position tracking. The board contains a Nordic nRF52 microcontroller, and I managed to get a simple Rust program running on that. Next up is some cleanup work, then I’ll get started on an SPI interface to talk to the radio chip.

This is the first time (of many, I hope) that I’m paid to do Embedded Rust work, so I’m especially excited about this project!


#6

Working on a Rust-based Direct3D 9 to Direct3D 11 converter (for better gaming performance with Linux / Wine).

I initially tried to do this in C++, but I got tired of the compiler throwing unintelligible errors at me and getting memory safety bugs. Ever since I moved to Rust, I’ve only had bugs of my own making, and helpful compiler messages.


#7

Managed to finish my orion v0.5.0 release. Dropped support for various SHA2 variants but got both HMAC, HKDF and PBKDF2 with SHA512 working and supporting #![no_std] now.


#8

Still working on my “Call for Participation”-blog post for
imag. Soooo many things to do!


#9

Learning LLVM. I am now with a dummy brainfuck compiler, but I intend to start something bigger.


#10

This is what I have by now. It currently does JIT.

You may want to build using the file build.sh, which is just a thin wrapper over Cargo + environment for build.


#11

This week I’ll be learning about Writing Automated Tests first, then with luck move on to Rust’s Functional Language Features (yep, working through the book).

https://www.rustyelm.com/2018/08/13/alright-lets-do.html


#12

Trying to wire up the rustc LLVM sanitizers for powerpc64 - and in the process learning a lot about the rust build system as I’ve never touched the rust compiler source before!


#13

Blogged about weak linkage in Rust and will be in Portland for RustConf!


#14

Automatic categorization on crates.rs. I’ve created categories for:

Behind the scenes it uses graph coloring and fuzzy logic. So fuzzy, it would have been featured on CuteOverload.


TWiR quote of the week
#15

Just started on Boa an experimental Javascript parser and just-in-time compiler written in Rust.

It’s a rewrite of https://github.com/someguynamedmatt/js.rs which is a fork of https://github.com/TomBebbington/js.rs both are old and no longer compile (due to the fact they were made before Rust 1.0.0)

Im basically starting again,


#16

Paying back tech debt in terms of automated testing for my game, code (line) coverage slowly climbing back up (now at 95.7%).

I’m using Amethyst, and have written a test harness that lets you go:

#[test]
fn stand_x_and_z_velocity_are_zero() {
    // kcov-ignore-start
    assert!(
        // kcov-ignore-end
        AutexousiousApplication::game_base("stand_x_and_z_velocity_are_zero", false)
            .with_setup(|world| {
                world.exec(
                    |(map_selection, maps, mut status_storage, mut kinematics_storage): (
                        Read<MapSelection>,
                        Read<AssetStorage<Map>>,
                        WriteStorage<CharacterStatus>,
                        WriteStorage<Kinematics<f32>>,
                    )| {
                        let map_handle = map_selection
                            .map_handle
                            .as_ref()
                            .expect("Expected map to be selected.");
                        let map = maps.get(map_handle).expect("Expected map to be loaded.");

                        for (status, kinematics) in
                            (&mut status_storage, &mut kinematics_storage).join()
                        {
                            status.object_status.sequence_id = CharacterSequenceId::Stand;
                            status.object_status.grounding = Grounding::OnGround;

                            kinematics.position[1] = map.margins.bottom;
                            kinematics.velocity[0] = 3.;
                            kinematics.velocity[1] = 0.;
                            kinematics.velocity[2] = 3.;
                        }
                    },
                );
            }).with_system_single(
                CharacterKinematicsSystem::new(),
                CharacterKinematicsSystem::type_name(),
                &[]
            ).with_assertion(|world| {
                world.exec(
                    |(status_storage, kinematics_storage): (
                        ReadStorage<CharacterStatus>,
                        ReadStorage<Kinematics<f32>>,
                    )| {
                        for (_, kinematics) in (&status_storage, &kinematics_storage).join() {
                            assert_eq!(0., kinematics.velocity[0]);
                            assert_eq!(0., kinematics.velocity[2]);
                        }
                    },
                );
            }).run()
            .is_ok()
    );
}

#17

I’m currently adding new features to my project spacebar. It’s an anti plagiarism tool for basically any unicode formatted text. It has the ability to persist over copy-pastes.


#18

I also started a new project this week, to write a http server with RESTful API.
And I happened to find a new framework call actix which looks promise. It’s built on top of futrues and come out with some feature such as routing handler and middlewares.
I’d tried hyper and rocket. But the first one is so basic that I have to match every request by thier method and url manually and then call the corresponding handler function. It’s quite annoying. On the other hand, the second one is very powerful and extensive. However, it requires rust nightly… And I don’t want to run nightly on my productive server now.
That’s what I get so far, and I know there are plenty of web server frameworks written in Rust. So if any of you has a better choice, please let me know! Thanks in advance.