1. 18

It’s Monday again, so let’s share the things we’ve been working on. Feel free to ask for help - many members of the community are experts and more than willing to share advice or expertise.

This week I am trying to get feedback on my Indiegogo campaign for a new approach to the semantic web:http://www.indiegogo.com/projects/brodlist

I think I blew it – it was too abstract for the non-technical audience, and not detailed enough for the technical audience. But I’d love to get more feedback. Thanks.

  1.  

  2. 6

    Away from work: Working on Chapter 6 of Storm Applied as well as revisions to chapters 1 and 5. Hopefully have 1 and 5 out in MEAP form soon.

    At work: Storm!

    1. 6

      At work: product design.

      Away from work: continuing to improve my environment parser library I spruced up to prepare for a Haskell talk. (http://github.com/tel/env-parser-talk). Right now I feel more confident in this code than I do in the original version; something I find interesting, but unsurprising given the fine-toothed comb treatment I gave the new version. I’ve rebuilt the core to work off of free applicatives which has made it much easier to reason about the right behavior for some of the static documentation purposes. I’m currently working through a free-seminearring model for the behavior of the defaults system which, despite the algebraic nonsense, should make the whole thing very intelligible.

      1. 2

        https://en.wikipedia.org/wiki/Near-semiring for anyone who’s curious.

        1. 3

          These posts by Chung-chieh Shan and Dylan Thurston are my favorite introduction

          http://conway.rutgers.edu/~ccshan/wiki/blog/posts/WordNumbers1/
          http://conway.rutgers.edu/~ccshan/wiki/blog/posts/WordNumbers2/
          http://conway.rutgers.edu/~ccshan/wiki/blog/posts/WordNumbers3/
          http://conway.rutgers.edu/~ccshan/wiki/blog/posts/WordNumbers4/
          

          Also here’s the particular pull request https://github.com/tel/env-parser-talk/pull/2

        2. 1

          Nice to know how to step through git commits:

          git checkout `git rev-list --topo-order HEAD..master | tail -1`
          

          (from https://github.com/tel/env-parser-talk/blob/master/Makefile).

          You have an interesting approach to tutorials, having the reader step through the commits as they learn. Maybe you could use branches to make it interactive, like “choose your own adventure” (not seriously!).

          1. 1

            It’s my first time trying this—I’m doing it to prepare some background material for a talk. It’s surprisingly difficult since you have a tendency to want to make each step perfectly, even though you can roll back and edit history as you need with rebase.

            Anyway, it’s been an interesting experience. I’ll probably write up a blog post about the first 16 commits or so at some point as well.

        3. 4

          I just open sourced a user tracking and funnel analysis application last night called Skybox. It’s still rough around the edges but I’m going to be polishing it up this week. It currently does Mixpanel-style event tracking and lets you build funnels on the fly.

          The goal of the project is to let people own their analytics data. Most tools like Google Analytics or Mixpanel have a limited API into the raw data or how you query it. Skybox is backed using SkyDB so I’ll be opening up the raw query API soon.

          Most analytics tools cost an arm and a leg too. Mixpanel, for example, costs $150/month to track 500K events. Skybox can process millions of events per month on a $5/month DigitalOcean droplet.

          I’d love to hear some feedback!

          1. 2

            Thanks for telling us about the demo. Can you add a bunch of dummy data on the demo site so there’s more to play with?

            1. 1

              Good call! I’ll put something together.

          2. 4

            Much like last week. My spare time is spent on Open Dylan.

            I’m working on Qt bindings for Dylan using a qt-generator extracted from Qt Jambi. This needs a lot more attention though than I gave in the last week as I’d like to have an initial release of this ready by the end of the month.

            I’m also working on our new build toolchain called deft, Dylan Environment For Tools. We need this improved toolchain for lots of things, but one big thing is our upcoming support for OS X and iOS stuff, like bundling an application. This is going to also result in some improvements in our core compiler as I clean up some parts of how we find and load projects.

            1. 4

              In an attempt to get familiar with Rust, I’m porting QuickCheck. (Including an emphasis on good shrinking.)

              1. 4

                At work: building a web-based viewer/control panel for spacecraft telemetry

                At home: finishing up a site that guarantees on-time phone meetings by calling both parties at exactly the appointed time (TalkThen). It stems from frustration with taking/making calls 5-15 minutes late. Now no one has to waste time, in theory.

                1. 1

                  Out of curiosity (I’m writing a book chapter on M2M protocols right now) what protocol are you using to send the telemetry data for spacecraft? And, if you can answer, why that choice?

                2. 3

                  This week is off to a good start - at least compared to last week - I managed to record another video for my “Stupid Programming Interview Questions” series. This time last week I was suffering with a head cold and couldn’t speak without coughing/spluttering.

                  The video is here: http://youtu.be/_eGxKnXepTI

                  I’m going to do a few of these “stupid question” videos and then move on to more serious/helpful programming interview topics.

                  …I think this is my first post on lobste.rs? About me: Freelance developer, founder of Social Coder (volunteering for programmers) and author of Ace the Programming Interview. Active on Twitter as @kiwicoder.

                  1. 3

                    This week I want to start working on clients and the frontend for Listens.ws.

                    The basic idea behind Listens.ws is to provide accurate per-user stats on music listening habits, without sacrificing any data for the sake of global or shared stats like Last.fm does.

                    1. 3

                      Last week I started implementing a Lisp compiler for my EZ8 processor in Go. After realizing how difficult was (mainly because of an impedance mismatch between the architecture and the needs of the compiler) I decided to pivot and turn it into an embedded extension language for Go. You can find it here. It’s still pretty incomplete, but it already has support for arithmetic, anonymous functions, defines, let, list manipulation (cons/car/cdr), and a conditional statement. So it’s usable albeit very bare-bones.

                      I plan on adding more features to it this week. Immediate goals are proper tail-call optimization, eval, and array operations.

                      1. 1

                        Also, I should mention that I am visiting the Bay Area later this week to attend Stanford and UC Berkeley’s grad school visit days.

                      2. 2

                        Finally moving out to SF this week. Preparing for the move has pre-empted most of my technical projects for the past couple weeks.

                        1. 2

                          This week is apparently new project week for me. Starting a lot of different little things, getting back to working on some old things.

                          Paid-for stuff is about the same, cranking away on ansible scripts. Still not loving the relative inflexibility compared to chef, but the simplicity is still nice, ultimately I’m still at a toss up for which is better / which I like more.

                          On the not-paid-for front, I started working on a little project in python last week that is still in the planning stages, the idea is to adapt the same sort of plagarism-detection techniques for identifying sockpuppet accounts on reddit. Using NLTK has been pretty fun so far, though I’m still in the planning/playing stage.

                          Also started futzing around with bittorrent sync some more, hoping to replace dropbox with it soon, but I need to come up with a way to easily configure it for new machines so I’m cut-and-pasting so much.

                          Finally, I got back to working on katuv, a project of mine which is best described as a ruby DSL for defining, parsing, and processing ruby DSLs. I’ll leave you all to make the Xhibit references.

                          Busy week ahead, going to be pretty fun.

                          1. 2

                            At work: looking at options for using Avro serialization in Python.

                            Avro is pretty cool (who doesn’t want a schema’d block-compressible format for their data warehousing needs?), but options for dealing with it outside Java are not the greatest. The Apache Python bindings work and are complete enough for our needs, but are incredibly slow (at least thirty times slower than reading gzipped plaintext) and extremely un-Pythonic. The latter I can fix with a simple wrapper, but the former is more difficult. Somebody’s written a library to do fast reads, but I haven’t found a good way to do fast writes yet. We’ll see if performance becomes a dealbreaker; adding fast writing to fastavro might become the next step.

                            At home: trying to patch i3 to do what I want with multimonitor setups, and in the process hopefully polish up my C a little bit.

                            1. 2

                              At work: learning Go and getting up to speed on the Logstash-Forwarder project. Lots of PRs to review, known bugs to sort out and general refactoring to be done. Looking forward to it…I’ve been wanting to get involved in Go for a long time, although diving into established projects with outstanding PRs is a bit daunting. Will be doing a lot of pair-reviews until i’m familiar with the code (luckily, it’s a pretty small project).

                              Away from work: totally tech-unrelated, which can be refreshing at times: working on a custom TV console/media center. Being built from raw 4/4 quartersawn oak, so I get to select clear faces from boards, plane to thickness, joint, etc. Should be fun (if a lot of work).

                              1. 2

                                I’ve been writing a game programming framework in Rust for the past couple months, trying to learn it and see how it measures up for game programming. Now I’m trying to hammer out a minimal roguelike game on top of it for the Seven-day Roguelike Challenge this week.

                                So far I’ve been having fun with Rust. I don’t particularly need its style of avoiding garbage collection whenever possible and the slight extra complexity that follows from that, but it is quite interesting how it is positioning itself as both a serious contender to C++ and something where the type system is robust enough to eliminate almost all runtime crashes.

                                1. 1

                                  Working on fixing some usability and confusing UI issues in Fire★ (http://firestr.com) that I didn’t get around to doing last week. Hopefully posting here will motivate me to actually do it! Cheer me on!

                                  1. 1

                                    Work: Auditing some services for another team.

                                    Away from work: Volunteer work for the WRCCDC and attempting to hack on some Julia stuff in my scant spare time.

                                    1. 1

                                      I’m working on checking if one can use link/cut tree to create a generalization of finger tree.

                                      Finger tree maintains a sequence of elements in a monoid(or one can consider a rooted path with each vertex weighted by a monoid element), and we can do many operations really fast. One can split the sequence, concat the sequence and find the sum of a sequence(so, the weight from the root to the end vertex). Note this allow us to find sum of a subsequence by split at appropriate positions and take the sum of the resulting middle sequence.

                                      From what I read, one might want to generalize it to work on a rooted tree instead of a rooted path. We still maintain the nice property the path from the root to any vertex is unique. link/cut tree seems to do the trick as a underlying data structure. The question is more about the semantics. What would be a way to define split,concat,sum so when it is restricted to a rooted path, we get the finger tree behavior, and it’s actually useful for something else…

                                      1. 1

                                        I’ve been working on an open source project, a port of Argot SDK (Java IoT communications library) over to Javascript, primarily targeting Node but I’ve also added support for client side with Browserify. It’s my first major piece of Node work so it’s been a great learning experience. The under-documented repo is https://github.com/danmidwood/argot.js if you’d like to take a look.

                                        In the free time I’ve had, I’ve been working on an iOS game with a couple of people back in the UK. I’d like to share the url but our domain expired. So, maybe next week.

                                        And, in my free free time I’ve been learning Spanish (I’m currently in Ecuador), attempting to talk to people (most shopkeepers) and watching and attempting to understand a bunch of Spanish shows on Netflix. I’m still at the extreme basic level, but I’m learning and it’s good.