1. 18

This is the weekly thread to discuss what you have done recently and are working on this week.

Be descriptive, and don’t hesitate to ask for help!


  2. 6

    Helping a client run their first A/B test, in early talks with a new client. Whee, sales.

    Heroku is shutting down the Postmark add-on on Friday, so I need to move Barnacles and NearbyGamers off it. The latter is a Rails app coming up on its 11th birthday. I still run it because I love tabletop gaming and I see someone make friends on it every week, but the code is some of the first OO I wrote and it’s pretty bad. I’m thinking of doing twitch streaming/a screencast series on rehabbing this legacy Rails app.

    And, last, I’m going to brush the dust off TwoFactorAuth, a Rails gem for the U2F hardware two-factor authentication standard. I mothballed it because nobody understood why they wanted 2FA or why SMS 2FA is garbage and I couldn’t afford the time and energy to educate everyone. In the last couple months I’ve had some inquiries from folks hoping it’ll be updated from Rails 4.x to 5.0 and 5.1, so I think I’ll get that started.

    1. 5

      Taught my Brainfuck compiler to generate a linkable object file, and a libc-dependent object file, meaning I mainly had to implement relocations. I’ve learnt a few things.

      Currently I’m trying to make some progress on my MPD client and I think I’m going to follow that by extending my shell directory navigator prototype into a real thing and learning to use it, so that I stop repeating pwd/ls/cd all the time, which is incredibly silly, while Midnight Commander is rather cumbersome. Thinking about making it extendable with git status and what not and how to achieve it.

      1. 4

        Websockets with Suave (F#) and React with reactive extensions. Having fun with “Stateless react functions” and trying to make a game with all this. We’ll see how it goes.

        1. 1

          How do you like F#?

          1. 1

            Oops sorry for not getting back to you! It’s going really well and I like it a lot. Still getting used to the syntax but it’s really nice and compact like python, but has the feeling of strictness that C# has. Pretty nice to work with.

        2. 4

          I am trying to, and retrying, and still hoping I can eventually, boot strap OpenStack from baremetal.

          The options are many and the documentation… maddeningly not accurate or useful. Makes me love OpenBSD documentation all the more.

          1. 3

            I’m receiving visits from a client and my boss (both super unusual things, considering we work at Buenos Aires and they live in the US). More importantly tho, I’m organizing a conference this Thursday/Friday.

            1. 3

              “Deployinator” our service management app on top of kubernetes. Runs docker builds as pods on the cluster, coordinates secrets mounting and encryption via vault. Creates webhooks for github to kick off ci builds for PRs.

              1. 3

                Work (GSoC): Comparing benchmarks for LLVM’s LTO vs ThinLTO. Mainly trying to determine which passes are missing in ThinLTO so I can figure out how to make it faster.

                Side projects: Found out about RPython this last week (in this blog post), and decided that getting a JIT for free would really speed up my development (since writing a bytecode vm from scratch in C is quite a bit of work). I wrote a simple SECD bytecode interpreter in C already, so I started rewriting it in RPython. Development is way faster, so I have a much better chance of actually getting a language project out the door and bootstrapped for once :)

                Also, toying around with implementing a text editor in Scheme. I love Vim’s bindings, minimalism and modal editing, and hate it’s configuration. I love emacs configuration, but dislike it’s general buginess (in my experience) and overall bloat, so I decided to try and see if I could have the best of both worlds. If it ever gets anywhere usable, I’ll post it on GitHub.

                1. 2

                  Remember you can always iterate in a high-level language that you can extract to C for its benefits. The trick is is using a subset of that language that corresponds pretty closely to C. If dynamic, keep the types, expected ranges, and similar info in the comments as you write the high-level code to ease the transition to static typing.

                  The next level of it is turning that into a DSL in a language like Racket or Haskell that automates the generation of the C code. One example is Ivory DSL in Haskell that generates safe, embedded C.

                  1. 2

                    You just described rpython which is what he is using.

                    1. 0

                      I just described LISP (esp Racket or CL), Haskell, and term-rewriting with many benefits over RPython. People wanting enhanced readability for average programmer, less flexibility, less safety, and/of less performance will find RPython a compelling alternative to a mature LISP or Haskell. ;)

                    2. 1

                      I’d far prefer to use Racket or some Lisp variant to build the interpreter (as I’m building a Lisp-y language and just like Lisp way better than Python). However, RPython has one killer feature: it generates a tracing JIT from the interpreter.

                      The reason it works is because RPython traces the interpreter rather than the executed program which makes it work for any interpreter that you write. PyPy is stupid fast, so I’m willing to put up with the annoyance of developing python for the speed payoff I’ll be getting.

                      1. 1

                        That’s a great reason to use it. Also one of my favorite things about it.

                  2. 2

                    Learning about Kubernetes, Terraform, Helm, Helm Charts, and Jenkinsfiles. Gonna invest a bit of time to install tooling locally, so that I can start doing cool stuffs on my own.

                    This is probably overkill by at least ten levels of magnitude but I’m trying to write out a thing that grabs Jenkinsfiles and is able to spit out rendered Helm charts for the benefit of not-having-to-look-for-them-since-in-this-system-the-path-of-Helm-charts-is-configurable. <insert shrug sequence of characters that I’m too lazy to search on the web to copy paste here>

                    1. 2

                      I finished the move to hashes of public keys in peergos last week, which smooths the way for switching to post quantum crypto. Hopefully that’s the last breaking change for a long time.

                      This week I’ll deploy that and flesh out some more parts of our website.

                      1. 2

                        Still trying to snatch little bits of time to work on a rate-limiter for elixir, but it’s pretty tough with a newborn around.

                        1. 2

                          Work: Writing a meta RFC to revamp our RFC process, to encourage better collaboration of shared resources.

                          Home: Final packing, and driving with the family for 4 days from Southern California to Portland, OR.

                          1. 2

                            At work I’m just pushing tickets along.

                            At home I am working a really bad framework called Bastard. Its a PHP framework built from Slim, uses the CakePHP ORM, and a bunch of other stuff. The idea is easily bust out RESTful APIs, and like my fourth half-assed iteration of a framework few will get any use from.

                            1. 2

                              Finally finished with exams, so probably going to be picking up some of my projects again :)

                              Working on a Pratt parser for a toy language, which I’m finding very fun.

                              1. 2

                                Building my own productivity tool, where I have a database in the form of:


                                • Name (String)
                                • Feeling (Timestamp, Score)
                                • Notes (Timestamp, Score)

                                And in this way I would keep track of my different projects, How have I worked on them. Which project, I am focussing more. I would add visualization also.

                                And I personally feel that some projects uplift my mood, on completion this would give me further insights.

                                1. 1

                                  This week there’s mainly two things to do:

                                  1. Ship the HIDIOT Kickstarter. Our PCBs are supposed to arrive today, and we’re starting shipping tomorrow.
                                  2. Do our first live Raw Hex show.

                                  Number 1 has been a wild ride, but number 2 has also been interesting. I’ve had to learn OBS, how to do rtmp caching with Nginx, forwarding upstream to another Nginx server so we can stream the live shows to facebook live and youtube live at the same time.

                                  1. 1

                                    Starting on ALSA bindings for Common Lisp.

                                    1. 1

                                      I still want to improve the Makefile for the Koalephant vagrant boxes, so that I can actually utilise a build server for creating the boxes when an update is required. The current one is kinda crufty from the upstream project we forked, so I think a simplified rewrite is in order.

                                      Still trying to help a client get comfortable working with git submodules, environment based config, vagrant, and numerous other improvements for their project. It’s nice to actually work with people that will listen to advice, and make a reasoned decision about which direction go!

                                      Another client has a tight-ish deadline for getting some ‘what/why/how’ type pages ready to show for a meeting with a 3rd party.

                                      Started doing some testing for infra level config packages to use in client projects, to reduce the amount of copying and tweaking from project to project.