This is the weekly thread to discuss what you’ve done recently and are working on this week.
Please be descriptive and don’t hesitate to ask for help, advice or other guidance.
This last week has been great.
I’ve started submitting some warnings fixes for LLDB.
I’ve also been writing some more documentation for
Open Dylan and the Dylan compiler internals.
That’s been enjoyable and has led to me learning a lot about parts that
I haven’t previously looked at.
As part of writing more documentation, I also made a couple more big
improvements to our documentation skeleton generator. It is now generating
almost all of the information that is available finally.
In addition to writing documentation, I thought “what if I started
that we have an LLVM back-end that is nearing completion and that could
probably be used with emscripten to generate JS, but emscripten JS
and “regular” JS are 2 very different things. I am also learning a
lot that I’ll be documenting this week.
As part of the JS backend, I found that we’d want to change our compilation
model to generate a single “object” file per library rather than an “object”
file per Dylan file and then link them together, like we do with C and
LLVM. Interestingly, I found that the compiler already has support for
doing this! In 1998, support for this was added. Re-enabling this breaks
a few things due to assumptions that have changed, but they’ll be easy
to fix. It is always amazing to me to see how much code was written
for this in the past and just not completely finished up due to the
finanical troubles that largely destroyed Harlequin in the late 1990s.
I’ve also done a couple of cleanups in the compiler, removing the remnants
of some functionality that was obsoleted in 1998. I also took a technique
used by the LLVM back-end and applied it to the C back-end to reduce the
number of exported symbols in shared libraries by a little bit.
In a bit of bright news, it seems that since last Thursday, my physical
and mental ailments that have been bothering me for the last few months
have gone away. I’m hoping this stays that way. I love feeling alive
and like I’m able to think and reason and remember again.
$work: Another day, another <redacted>ing pivot. Off gitlab-ci, back on jenkins. Off Ubuntu, on RHEL (except maybe not everywhere because everything in <redacted>ing <redacted> <redacted> <redacted> world is <redacted>ing built on <redacted> <redacted> <redacted> <redacted> Ubuntu <redacted> Docker <redacted> <redacted> IA IA CTHULU F'TAGHN.
!$work: playing a lot of Factorio with some buddies, that’s pretty awesome. I’m taking a bit of a break from other programmy projects to do some more music production stuff, mostly because I’m so phenomenally frustrated with $work. Infinifactory and Factorio are both really excellent games. The former is a 3-d minecraft-factory building puzzler, great aesthetic, great storyline, really just a wonderful game. The latter is an insane logistics puzzling factory-building oh-my-god-how-am-I-going-to-get-that-ore-over-to-those-smelters-so-I-can-un<redacted>-my-whole-production-system game. It’s pretty awesome, and the multiplayer is pretty nice too (it just gets out of your way and lets you do whatever you want w/ more than one person, exactly how a sandbox game should).
Yah. It’s going to be a fun week.
Last week, I got a lot of cool things into Hython:
I added a REPL on the train ride up to Compose. It’s very basic: it only supports simple statements, doesn’t report back the result of exprs, and doesn’t use readline. But it is very handy for poking at things. I’m sure I’ll be improving it in the future.
I added a primitive mechanism to the language. Think of this as a generalized, small portal from Python -> Haskell: __hython_primitive__("primitiveName", vararg1, vararg2...), or like a syscall-type boundary. Python objects go in, Haskell code gets called with those arguments, and a Python object comes out. I used it to build Python’s built-in list data structure in Python itself. Delightfully meta!
__hython_primitive__("primitiveName", vararg1, vararg2...)
Now, I’m at a bit of a decision point: do I box all types, or only composite ones? I’m leaning towards keeping primitives (ints/floats/bools/None) defined only in Haskell because it’s quite good at how they’re typically used. There’s a tension here, because boxing all primitives makes the interpreter much simpler for many operations, but painful when I need a real integer, rather than the box around integer. If I box nothing (as I was doing before), then building out many composite data type operations is pretty painful. Would be curious if anyone had any guidance here.
I also need to decide on some sort of acceptance criteria (aka: point at which it’s declared done) for this project. Any ideas?
At work, I got promoted to management awhile ago again, so I’m not really coding much anymore.
At home, I’ve been doing some documentation improvements to Factor, using Factor to work through cryptopals, adding Factor bindings to libcouchbase, and a few other things that are piquing my interest in Factor. I’d also like to dust off and finish my Python package hosting tool, but I’ve been finding it very hard to motivate myself to finish that project when I would personally derive no benefit from it and would probably have to fight to get it adopted at work.
Material for the book and planning out my talk and possibly workshop for Lambda Conf.
Possibly picking up another Haskell contract in the next week or two. This intermittent employment thing is good for my health.
Kicking around possibly writing a terminal client for Twitter since the Ruby one is difficult to get working.
Last week my goals were almost completely swamped by external factors, so this week’s goals look pretty similar, albeit more modest.
Last week I finally bit the bullet properly with Go and got something better than hello world written & working. Started off with command_missing for my ZSH shell. (Catch typos like gi tstatus and exec git status for me instead.)
Jumped off that back of that to write a proof of concept replacement in Go for an ageing service at work, wrapping a external resource intensive process with a throttled pool of connections. Once I’d figured out using a sized channel for handling “slots” in the pool, it all fell into place pretty easily. Very impressed with it for those things that I don’t think Ruby fits too well. (Nothing can do everything well!)
Also re-learned that outside ruby, argv includes the command’s name as the first element, and blogged about that for when I inevitably forget it next time.
This week I’m trying out a new training schedule for running & swimming (turns out just running the distance I want to run each training run isn’t an ideal way to train/improve. Who knew.) And will be carrying on with command_missing, writing tests for it and finishing the implementation.
Found a bug in Fire★ windows build that I will fix. Also working more on my muda todo list project.
I have been sick last week so everything is dragging down.
Hello! I’m afraid I missed last week, so here’s a bigger update on my project.
Startups are hard. In everything before this, I made something, pushed it to GitHub, went “Wheee!”, and that was it. Here, I’ve had to iterate on the product three times before I started getting positive feedback. The good news is fourth time’s the charm, and people are starting to like it! Bad news is I’ve been keeping a pretty low quality barrier for my codebase as most likely, I’d have to throw it all away. So that’ll need to be cleaned up eventually.
I don’t think it’s quite ready for the public, but I’ll link here anyway. Please, please, please provide feedback (either here or via email in the footer link): http://cardminion.com
Putting together a simple service for delivering Pocket + Instapaper + Readability content to my Kindle (which was on my backlog for almost 2 years): http://dailycrunch.mobi/
90% done over the weekend, now to some extra features (archiving/starring/sharing directly from the Kindle, etc)
$work: I’m working on tools to grab UK news articles from the national papers and broadcasters (works out to around 3000-5000 articles/day) and tools to help my non-techy colleagues analyse said articles. Aim at the moment is to monitor the media coverage of the upcoming UK general election, with an eye to producing regular reports on how things are being reported. I’ll post some links when we get some results to show. The larger goal is to produce tools which can help analyse the media coverage of any particular issue or event. Development mostly in Go, at the moment. I’m starting to nibble away at the corners of some NLP techniques, but really, we’re still at the ‘stupid’ phase - lots of hand-crafted keyword rules to identify articles about various people and topics.
$home: utterly failing to make any headway in getting a game I started writing about 15 years ago out the door. It’s 95% done, so there’s only the other 95% to do :-)