For me, it’s probably “Will Serverless End the Dominance of Linux in the Cloud?” by Ricardo Koller and Dan Williams. It’s an interesting take on what the impact of serverless computing paradigm has on the OS (especially on Linux that dominates the cloud).

I am planning to finish my Haskell implementation of the Hindle-Milner type inference algorithm this week. I am using Basic Polymorphic Typechecking by Luca Cardelli (1987) as a reference. The paper includes a full implementation of the algorithm written in Modula-2 (see Appendix A for details). The same algorithm has previously been translated to Scala and Python. Once the implementation is finished, I am going to use it as a basis for type inference in Taylor (a Swift compiler written in Haskell).

There’s now also a blog post by the author that explains what the code is doing in great detail.

This week I will be improving Taylor, a work-in-progress Swift compiler written in Haskell. I have preliminary parser and LLVM codegen in place that understand simple constant declarations and I am hoping to add support for binary expressions and other primitive parts of the language next. As I am still more or less a Haskell newbie, I’m interested in feedback on how to structure the compiler properly. If anyone is interested in working on the compiler, drop me a line or send a pull request.

Most advanced statically typed languages completely SUCK in the programmability department. Unless you are some genius of course.

It feels like all people who say things like this haven’t actually tried learning the more “advanced” languages. Haskell is my main language I work in and is IMO really easy to both learn and program in, you certainly don’t need to be a genius or even smart. The whole point of having the compiler is so that you don’t have to be smart.

It always feels like a cop-out, because the rumours are that languages like Haskell are academic, you relegate them to “you need to be a genius to use them so I’m not even going to try”.

I may also be biased on the matter of course, but I have yet to find someone that learnt Haskell go “this is too complicated for me”. I do wonder how much of it is bias and how much of it is true to the authors point.

This week I am working on Hornet’s fast interpreter. Hornet is a OpenJDK-based JVM implementation that focuses on predictable execution for applications with low-latency requirements. It runs on both Linux and OS X.

I have about half of the JVM opcodes covered now. Hopefully I will be able to reuse much of the code for Dynasm and LLVM backends in the future. I managed to integrate MPS to the VM core few weeks ago but there’s no JVM stack walking yet so it’s not fully functional.

Questions, comments, testing, and pull requests are welcome!

Last week, I got off my ass and penned a blog entry on Hython. Oh goodness, I could write a book about this if I wanted to. Submitted it to a few places, regretting it a bit later. I’m normally OK with most criticism, but middlebrow dismissals really irritate me for some reason. On the code side, I got started on implementing exception handling in Hython. I’m leveraging continuations to do it properly, but even with those there’s still a lot of thinking to do. I’m going slowly on this part and following a guide on doing it well. Hopefully I don’t have to circle back to it much after I’m done.

This week, I’d like to continue working on exception handling, possibly while gathering notes to see what the next blog post on Hython will be about.

My entry is short this week as I’m not in the mood for talking much.

If anyone knows of interesting compiler or related work (including, say, LLDB, LLVM, etc), I may well be interested to hear about it. I prefer working remotely but might be interested in discussing other options.

As for Dylan, I don’t know what my future is with it at the moment. Multiple attempts to get others involved have largely failed. A comment that I made last week about what if I did something that mattered got 4 people to upvote it.

There are so many interesting things that can be done on top of an industrial quality foundation. Instead, people quake at the thought of working on something big or involved. We’re in a time where people are proud to try to proclaim that they’re less than average, as a number of posters here on lobste.rs like to do. So I’m frustrated, I’m sad, and overall, I’m just really tired.

I found an answer to my question last week. I started writing a new document as a project notebook listing existing projects, status, notes on them, etc. I just don’t see much point in continuing given the above and the lack of any payoff in doing so.

I am sharpening my Haskell skills by writing a compiler for the Swift programming language using Alex/Happy for lexer and parser and LLVM for code generation. It is in very early stages but feedback from fellow Haskellers and compiler hackers is welcome!

Too bad that unlike the rest of the scalac forks, this one seems to be intentionally license incompatible.

I am curious to know why some people are voting this submission as off-topic. The article makes interesting points about issues with Python 3 migration. I don’t personally agree with the conclusion of the article but it’s still a good read if you’re interested in programming language evolution and/or Python.

This week I am planning to integrate Memory Pool System to Hornet which is an experiental JVM implementation for low-latency applications that I have been working on for a while now.

How do you even know if /dev/(u)random is random in the first place? This may sound like a strange question, but it isn’t. You can’t just trust a file because of it’s path. Consider an attacker ran the following:

…

Now both random devices are actually large sparse files with known data. This is worse than not having access to these files, in fact, the attacker is able to provide you with a seed of his own choosing!

This seemed like a strange thing to even mention. In what environment could an attacker possibly control what comes out of the file */dev/urandom" but not have full control over everything else in the environment, like loading an LKM that keeps /dev/urandom as a device but spits out zeroes? I mean I guess if you are chroot()ing to some known valid path but somehow have such screwed up file permissions that an attacker was able to leave that bogus file beforehand, but if that happened I’d also assume the attacker could do much worse than screw up your randomness.

I finished a raycasting game engine demo last week. Raycasting is a 3D rendering technique that was used pseudo 3D games like Wolfenstein 3D and Duke Nukem 3D in the 1990s. Of course, I ended up using OpenGL for the actual drawing which is actually what Wolfenstein 3D port for iPhone does as well.

This week I will modernize the rendering pipeline and switch to the common subset of OpenGL ES 3 and OpenGL 4 core using programmable GPU.