1. 23

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. 9

    Finishing up some changes to my spaceflight programming adventure game to improve the in-game SSH simulation: https://gitlab.com/technomancy/bussard/tree/threads

    My first cut at this did everything in a single thread using coroutines and a half-baked channel implementation I created with Lua tables. I’ve since spun out remote OSes that you can connect to into their own threads using the threading system provided by LÖVE, which is essentially isolated Lua processes that can communicate over CSP-style channels. Basic login and stdio functionality is humming along, and I’ve extended the protocol to add support for RPC so that scripts in the remote side can affect game state in the main thread.

    That part all works swimmingly, but I also want to add support for tab completion that works over SSH connections, which probably means allowing RPCs to go the other direction. The problem I just realized falling asleep last night is that I can’t block the main thread waiting for RPC return values like I do the OS threads. Luckily this is a great fit for Lua coroutines; the code can be written in a wonderful linear fashion instead of ripping it into callback soup.

    1. 6

      I’m working on a comment-preserving parser for ssh_config files. Very alpha software here: http://github.com/kevinburke/ssh_config

      Previously I wrote a comment-preserving parser for /etc/hosts files: https://github.com/kevinburke/hostsfile

      Eventually I will collect all of the Unix config file formats.

      1. 6

        Learning all over again that the “S” in “SNMP” is a vile lie.

        1. 3

          “It’s a trap!”

          1. 3

            Oh, like in SOAP :-)

            1. 2

              Oh goodness. I remember looking at that spec and canceling a project immediately. Totally not worth whatever I was planning on doing with it at the time.

          2. 5

            My team at work is migrating to git, and suddenly I’m the version control expert.

            1. 5

              in a rut for some time now so trying to do a few side projects

              • Wanted to brush up on F# so wrote an (optimizing) Befunge→.NET compiler. I’ve always had a soft spot for Befunge. I don’t support the dreaded p command or much of Befunge ’98 yet.
              • Trying to contribute C# support to Hedgehog.
              • Collected a few StackOverflow answers and old blog posts into the start of a small collection of ‘history of programming language ideas’. This is something I’ve wanted for a while…
              1. 4

                I’ve been working on my mutation testing research project. Mostly its been fighting the out of memory issues which crop up halfway through the builds.

                1. 4

                  Last week I launched my Kickstarter.

                  This week I’m at CrestCon tomorrow, then I’m mostly catching up on stuff I missed last week and writing tutorials for the HIDIOT.

                  1. 4

                    I’m working my way through Think Stats.

                    1. 4

                      Third-pass editing of Farisa’s Courage. I’m now at the point where word count decreases with most edits. I’m at 132k words and I’d like to reach 120k without cutting story– if possible. It becomes harder as a first-timer to get published if you break that 120k barrier.

                      Thinking through the agonizing “self-pub vs. trad-pub” decision. Self-pub wins if you’re not aiming for NYT bestseller list and various trad-only awards … but to figure out if it has that potential takes an agent at the least, and just getting one of those takes forever.

                      Been working through a couple compiler design papers too but most of my time’s been spent on fiction (writing, reading, reading about) of late.

                      1. 4

                        I’ve been hacking together a small and mostly LDoc-compatible documentation generator for distribution with luakit, so that up-to-date docs can be installed with the main program. Shortcoming: type inference isn’t as nice. Benefit: it’s very easy to tweak the documentation generation and include project-specific information, e.g. auto-generate nice-looking keybinding descriptions.

                        1. 4

                          Been putting the finishing touches on the first release of Maia for Scala. It’s a GraphQL inspired API library that fits so nicely into Scala and Scala.js’ type systems that your clients and servers can no longer fall out of alignment with one another.

                          Doing this requires a lot of type level programming on my part, but the final interface isn’t too bad. An API specification looks like a set of types like

                          case class Person[F <: Field](
                            name: F#Atom[String],
                            age: F#Atom[Int],
                            mother: F#Obj[Person],
                            father: F#Mk[Nested[Person], HasCardinality[Opt]],
                            friends: F#Mk[Nested[Person], HasCardinality[Many] & TakesArg[FriendFilter]]

                          I’m giving a talk on the design of Maia for LambdaConf in a couple weeks, too. Ultimately, the hope is that I’ll get this all released and then be able to use V1 for live examples for my talk.

                          (Also, always looking for contributors.)

                          1. 3

                            Working on an app you can use to clean data. Used for cleaning up data before putting it into machine learning algorithms. The steps you took to clean the data can be deployed as a pipeline. That way, the cleaning process is repeatable and re-runnable as you explore what data is better for your algorithms.

                            We’re able to filter the data, as well as a single transformation with an redo/undo history. For now, the data sizes we’ll handle will fit in memory.

                            1. 3

                              Having just concluded a big upgrade to my company’s industrial learning site LunchBox Sessions, I get to flip back to the domain I enjoy most — interactive animations and the tools for building them. I spent a good portion of last summer squeezing every drop of perf out of SVG, and I’m excited to get back to it with the ideas I’ve accumulated in the time since: splitting static elements into separate GPU layers to avoid excessive painting, encoding lines separately so I can do dynamic LOD, adding null to the end of all my loops (sigh, CoffeeScript), and so forth. But, first on the table for this week: hammock time.

                              1. 3

                                I’m still plugging along on the business end of Turnkey Telemetry.

                                In my spare time, I’m trying to make F5Bot monitor all of Reddit, instead of only specific sub-reddits. Reddit’s API and rate limiting don’t make this very easy. I think I’ll need to take an approach that makes multiple simultaneous requests.

                                1. 3

                                  Still learning tons of stuff at my new employer.

                                  Otherwise, gonna be moving plenty of boxes to the new house, of which I’ve received the keys yesterday. It’s a hell of a commute, but I’m right across from my parents’, and with the three kids I expect that to be awesome. The wife and I also have a very good relationship with my parents.

                                  1. 3

                                    I’ve been doing some retro computing (writing 6809 assembly code for fun—haven’t done that since I was a kid) and I’m working on my own assembler. The one I’ve been using, A09, is … shall we say, a bit of a mess (magic numbers everywhere and globals oh my!) and thus, hard to extend (with new pseudo-ops, local labels, etc). I’ve written my assembler in Lua, using LPeg for the parsing, and it’s an interesting experience.

                                    Interesting bit #1) on pass 1 dealing with expressions with undefined labels (that are defined later on) and keeping track of such for pass 2. Example:

                                    past equ $10
                                        ldx #future * 2 + past

                                    Interesting bit #2) local labels. Example:

                                    start lda varx
                                    .1     bne foo
                                           bra .1
                                    foo    bmi .1
                                           bra start.1 
                                    .1     nop

                                    Interesting bit #3) Getting both of those working in concert.

                                    Interesting bit #4) keeping track of undefined value on pass 1 for pass 2 so I generate consistent code.

                                    Most of the code is for dealing with issue #4. Next up, put in actual error handling, and then macros.

                                    1. 3

                                      I’m doing school and work related stuff, and more implementations of data-mining related programs than I care to do. I graduate soon, which I’m very much looking forward to.

                                      I’ve finally got a Github mirror for PISC up, so that is now available for anyone that would like to hack on a stack-based programming language written in Go. I’m also two entries into a weekly tech blog called Andy Rambles that I publish on Fridays.

                                      1. 3

                                        Work stuff, plus more MicroPython (I haven’t done a lot of coding on it lately, but want to talk about it at MPUG, PyConAU and/or YOW! Connected, so I’d better start writing some talk proposals). Plus sketching some ideas re: non-text-file-based programming environments,

                                        1. 2

                                          We’re in week 3 of my programming languages class (which can be found at http://www.proglangs.com), and this week is the final Haskell lab, where we’ll be covering Functor, Applicative, Monad, and their usefulness (along with the rest of Haskell’s type system) in providing sequencing and controlling effects. All three will be introduced not through metaphor, but through their interfaces and respective laws. We’ll go through IO, State, Reader, and Writer as well, and talk about the idea of cordoning off the portions of the code that are imbued with particular effectful capabilities. Should be fun!

                                          1. 2

                                            I’m halfway through O’Reilly’s Beginning Javascript Learning Path and really enjoying it.

                                            Pairs well with Crockford’s Javascript The Good Parts which I’m also re-reading, and this time actually understanding more.

                                            1. 1

                                              At home, just trying to prepare a VM image for use on this decade’s deployment of Artifex.org. (Nothing more that dovecot + postfix + ssh + nginx, but I took an excursion to automate bringing up single instance K8S without minikube. Was that a good idea?…)

                                              Oh, and still working my way through The Origins of Totalitarianism! I gave up on a recall battle with a fellow London Library patron and bought my own copy….it’s macabre but unsurprising that Penguin has made a new, 2017 edition.

                                              Otherwise, I need to circulate some more in the London technology scene. It’s been a different world than all those years in the Golden State.