It’s Monday, so it is time for our weekly “What are you working on?” thread. Please share links and tell us about your current project. Do you need feedback, proofreading, collaborators?
Addendum: I’m looking for someone to take over posting the weekly thread. It’s gotten a bit tedious for me, since I haven’t had much to report myself lately.
I’m also writing a post on introducing dependent types to Haskellers for when I’m too angry at JS to work on Hasquito.
If anyone’s interested in how lazy functional languages are implemented and wouldn’t mind lending a hand with JS, please ping me :) (contact info is on the project homepage).
Please port js-the-good parts to Hasquito and make it selfish hosting!
the project goals remind me a bit of the loell language, back in the day. worth looking at if you haven’t seen it: http://w3future.com/html/loell/
I think loell is a little more ambitious than Hasquito. I really just want a small, self contained example of compiling a lazy functional language. The language being compiled is really quite boring :)
In the OSS world, I’ve begun to contribute to the Hex package manager, I’ll be assisting in the web interface redesign, API documentation, trying to close all current issues and bring it into a state where it can be run on an isolated system, as well as many small improvements , such as email verification, password resets, and better support links.
I’ve also pushed some bug fixes to my Lobsters browser for iOS which was accepted today!
In !OSS, I’ve been working on my MVP application which is starting to take shape, as well as reading many papers on targeted advertising for the service!
Until next week! :)
Ive always been curious what sort of use erlang gets in the real world. It seems odd (from my perspective of course) that there is enough demand for it to need a package manager.
Erlang is really good in applications that can’t go down, and where jobs can be picked up from where they left off in disposable processes, although, the syntax is quite a change, and in some cases inefficient. Elixir fixes a lot of these problems and makes writing OTP applications a lot easier and productive (and sometimes even fun), whilst still maintaining the power and VM of Erlang, hence why many are starting to experiment with it, and even use it in production systems. And from now on, there is a breaking change freeze until 1.0, so now is a perfect time for people to start using it. And people want packages, and it needs to be done well cough npm cough
I’m refactoring the API on my Go W3C-compliant CSS3 parser/lexer. This project is a stepping stone to writing a pure Go LESS compiler and build a zero-dependency asset pipeline tool.
I actually have something to put here, for once! Going to try and do a complete tear-down of the recent FinFisher leaks and spin up some VMs with old versions that are actually susceptible to the attack vectors. It’s a work in progress:
The matasano challenges are up! (http://cryptopals.com/sets/1/challenges/3/) I am working my way through the problem sets (writing code in scheme).
Working on documentation for theft and an MQTT client library for low-memory (e.g. < 512 bytes) embedded systems (whose pre-release is being deployed soon by an industrial client).
Making slides and practicing a presentation for a local user group about applying “compiler stuff” to day to day problems: using various practical parsing algorithms to scrape data, doing some basic static analysis, simplifying interpreters for DSLs with bytecode VMs, and compiling via continuations.
More content for my new VR usability website twentymilliseconds.com. Today I published a post that plots Oculus Share ratings alongside information like the comfort level, number of downloads, and frame rate, was sort of sad to see it disappear in the aether of social media, oh well. Can’t all be winners.
I also bought the PC parts so I can actually run content for an Oculus, will have to figure out how to put that together and, if everything works, maybe try a few demos, which I assume will help me actually write content (so far I have been writing without any first hand experience).
More work on my PureScript book. This week’s chapter will probably be an extended example on using the HTML5 canvas from PureScript.
I feel like I always get to these late… But this week im working on building a DSHT for Ipfs. (http://ipfs.io). It is really interesting to see all the different error cases and considerations you have to take into account when making such a distributed application.
I’m working on migrating a couple Meteor apps to Amazon Web Services from an IaaS provider. We’re going to use Terraform to have infrastructure-as-code, which is awesome. Going with the hashicorp theme, we’re also going to use Packer to create images to actually deploy the apps.
So, I’m learning a lot about AWS, Terraform, and Packer, and whipping up some bash scripts to further automate things. Also, contributed a couple pull requests to Terraform - no clue if they’ll be accepted or not, because I’ve never touched golang before, but the functionality seems to work!
At $WORK, continuing work on migrating a multi-level stack to AWs. Currently evaluating eb_deployer from ThoughtWorks for automating zero-downtime blue-green releases.
I’m porting a complex signal processing algorithm written in Matlab to an iOS app. Since Swift is new (and very powerful!) I developed the basics of a framework called swix that makes an line-by-line conversion between Python/Matlab and Swift. Last week, I was putting finishing touches on that framework. Of course, using it in the real world exposes areas it needs further improvement. This week is devoted to those improvements along with further integrating OpenCV for a future project.
I’m doing research on ways to compute maximum flow over a unit capacity undirected graph with a subset T of vertices having unit capacity in O(n2.5) time.
If T is an empty set, then there exist an algorithm to solve the problem in O(n2.5) time (in fact O(n2.375) is possible) (see the introduction in Ran Duan: Breaking the O(n2.5) Time Barrier for Undirected Unit-Capacity Maximum Flow. SODA 2013: 1171-1179 for a survey of such results)
If T is the entire set of vertices, then we can also solve it in O(n2.5) time (and this also works for directed graphs). See this paper. https://www.cs.princeton.edu/courses/archive/fall03/cs528/handouts/network%20flow%20and%20testing.pdf
but when T is just some arbitrary subset, no known algorithm takes O(n2.5) time. Combine the techniques in 1 and 2, one can up with an algorithm that runs in O(n2.5) time if any one of the following is true
n-|T| = O(n¾).
number of edges between vertices in |T| = O(n1.5).
Each component of V\T is constant size.
Adding buttons and screens to my secret game TCFODS. I wanted to start a blog post showing progress but unfortunately lots of errands this week. (this is a side project after all).
last week, I did manage to update my Fire★ website with new logo and reorganization! Yay!
At $DAYJOB interfacing with Wincor-Nixdorf credit card terminal. It hurts, but cannot explain details due to the NDA. The tech is so hopeless that not spreading the docs actually makes the world a nicer place. It eats babies.
At work: Writing a “top”-like utility to monitor various parts of our distributed system (process resource usage, when processes are starting and stopping, etc.). I’m just starting, and hoping to do it in a way that the curses based UI can be replaced with a GUI at some point.
Outside of work: I’m reading Shimon Even’s “Graph Algorithms” and Paul Graham’s “On Lisp.” The plan is to implement some of the algorithms in Common Lisp as I read through both books.
I’m developing a distributed job scheduler that heavily leverages Datomic, core.async, and Mesos. There’s lots of interesting asynchronous messages constructions, since Datomic and Mesos are event-based, and core.async makes a wonderful “glue” fabric.
Convincing the right people that it’s a good idea to write a realtime streaming implementation of SQL. Software engineering isn’t all about programming, unfortunately…
what do you mean by realtime streaming implementation of SQL ?
It’s a language that’s syntactically identical to ANSI SQL except that it’s defined in terms of streams instead of sets (well, SQL is actually defined in terms of bags, not sets). I use the term “realtime” because that’s how business people refer to it, however it has nothing to do with hard or soft realtime systems - just that records are processed and results are produced as input arrives. There are response time goals, but a slow response time isn’t considered an error.
So basically a complex event processing engine? Why roll your own?
All the CEP engines out there are either not-scalable, complex, or both (usually both). There are a few that are simple and fast, but they have very limited capabilities. SQL is already familiar to a lot of people (even non-devs) which significantly lowers the barrier to entry. It’s also very expressive - decades have passed while SQL satisfied most people’s needs. Last, I can decouple the data selection/querying from actions. By having these two parts seperate, we could use SQL alongside another CEP engine that has a much better UI (like nodered). Plus it would be fun to implement SQL :)
This should really be automated, or it’s own section.
Shit happened last week, so not a whole lot of progress on Hython (https://github.com/mattgreen/hython). I’m converting the Python metagrammar by hand this week, so that’s pretty awesome, and should fix all of the weird edge cases. I spent way too much time fiddling with Alex and Happy last week, but I hope to be back to where I was pretty soon.
What’s incredible I never thought I could handle the real metagrammar, and I’m at least 50% through it. Big confidence boost. This whole project has been one of pushing limits. Very refreshing.
It was automated, but the VPS broke or something along those lines. Some complaints about the bot too.
I’m working on a social analytics site written purely in Go with the help of MongoDB. Will be FOSS and ad free. I’m actually really happy with the progress so far.
I’m also working on a monitoring app for my University’s rail system known as the PRT (Personal Rapid Transit). Will alert users on their Google Glass, Android phone, Android Wear, or Pebble if the PRT goes down and the students need to find alternative transportation. Currently written in Go for the server and using Google Cloud Messaging to send the alert payload to users. Also FOSS and can be found on my Github: https://github.com/AustinDizzy/prtstatus-go for the server and https://github.com/AustinDizzy/prtstatus-java for the client. I’m a little new to Go in production and persistent DB connections, so if anyone sees any room for improvement please feel free to submit a pull request.