1. 23

It’s Monday, which means it’s time for our (semi-) weekly “What are you working on” thread! Please share links and tell us about your current project. Do you need feedback, proofreading, collaborators?

  1. 10

    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.

    1. 5

      Using Haskell’s llvm-general as well. Very nice, I will watch this project with great interest.

      1. 4

        Awesome, will be watching your progress!

      2. 9

        3/4s of the way through porting our book from pandoc+markdown -> latex, to straight latex. Also using Literate Haskell in the tex as part of a Cabal project to type-check and test the code snippets. Wrote some material on recursion and fixpoints. About to explain the y combinator. Coauthor should be coming on board to write material and edit next week, hoping things will pick up in speed then.

        Sniffed around the IPFS paper, touches on some things I wanted anyway, but takes the whole concept further down a particular evolutionary road I hadn’t fully considered. Thinking about attempting a limited implementation in Haskell with a friend of mine.

        1. 5

          Doing IPFS in Haskell is exactly what I have been thinking about for the past few days. Let’s do it.

        2. 6

          A silly idea, as I’m out on vacation: a random tweet generator using Markov chains and books from the Gutenberb project, in the lines of the “King James Programming” tumblr. Twitter: @markovian_lit (code is on github - https://github.com/herval/markovian_literature)

          1. 6

            Writing a HTTP client for Rust

            1. 6

              It has been a few weeks since I’ve posted here …

              For my client work involving emscripten, I delivered a 30% performance improvement for my client’s codebase. This was entirely from changing some low-level details of how they communicated with WebGL from their C++ code. That was pretty exciting and happened a couple of weeks ago.

              After that, I spent a while inspecting the JS that is generated from their C++ code and found a number of things that could be improved (in the C++ code) to generate better, faster or smaller JS. Code size is important in an emscripten-compiled application since the application is downloaded via the browser and you have to worry about things like JS parsing and compilation times. This is pretty fun work and reminds me a lot of long-past days where this mattered in the PC world. I’m hoping to find the time to write a blog post or two about reading emscripten-generated JS and understanding how the C++ code maps to the JS, including things like RVO.

              I’m currently working on upgrading them from the “old” emscripten compiler to the “fastcomp” emscripten compiler and something closer to valid asm.js. We’ll see how that goes! It is looking promising, but there are a lot of details to sort out and a lot of generated code to inspect, profiling to be done, etc.

              In Open Dylan land, I’m slowly working towards doing a new release and am clearing out some long-standing branches and tasks that I’d had built up over the last year. It has also been exciting to watch the progress on our upcoming LLVM backend which is generating pretty nice code.

              I’ve also continued my experiments and work with Atom Shell and TypeScript. A short while ago, an Atom Shell Starter template project was released and that’s been a huge aid in figuring out a lot of things. It uses CoffeeScript, so I’ve got a fork where I’m making it use TypeScript instead.

              I’ve also been supervising a couple of construction projects around the house, including the addition of maid’s quarters. This is a nice change of pace from programming work. :)

              Finally, I’m trying to decide if we’ll go to Jakarta next week or not. I’m hoping that we can avoid that though.

              1. 5

                Outside of work, I’ve been getting back to embedded development. I’ve quite missed doing that. This week I get to write support for a UART to enable the serial port on an ARM device, and I’m going to (potentially) be playing around with some mesh networking.

                1. 5

                  I found out that I passed my Google interview (for an internship)! I’m waiting for a project manager at Google to get in touch now.

                  I’d like to thank Peter for helping me prepare for the interview. The community here is fantastic!

                  1. 4

                    Last Week

                    Instead of expanding the API for Fire★, I updated the GUI a bit. I added a contact list on the start tab to allow easily starting a conversation with people who are online. I also added vector clocks to messages sent in the chat app. For now I am using it to not show duplicate messages. But you can imagine in the future I can actually sort messages in the ui partially.

                    This Week

                    I am going to try to expand the API a little bit. Probably starting with the drawing canvas. Also fix any bugs that show up. If anyone wants to do some testing and submit bug reports to the github issues page, I would love you dearly with all my heart.

                    1. 4

                      Working on improving/fixing gtk drag-and-drop for Windows.

                      1. 4

                        For fun, I started working on an ssh chat server in Go. Basically clients will ssh chat.whatever.com and boom, you’re in an IRC-style chat room with everyone else connected. Proof of concept is nearly ready, hopefully post it in an upcoming week.

                        No real great reason for why I’m doing this, mostly because I wanted to use the Go crypto/ssh module and learn more about the ssh protocol. Let me know if you’ve seen this done before.

                        One cool feature I hope to have from this is that all identity/auth will be done implicitly by the pubkeys, but not sure why this is actually useful, open to ideas. :)

                        1. 2

                          Why not implement the IRC protocol? Might be an interesting exercise too!

                          1. 3

                            Implement IRC on top of SSH? I am considering doing a subset of it, at least for client-side commands. The goal is to have a no-dependencies no-registration chat room experience. I like the idea of repurposing ssh clients (which are actually very powerful and versatile) for something silly like this. :)

                            1. 2

                              Or a MUD

                              1. 1

                                That is definitely on the list of ideas, but probably more work than I’m willing to sign up for this project.

                                I’d like to release a library to make these kinds of things super easy, though. Stay tuned!

                            2. 1

                              I think using SSH as the base is an excellent idea. IRC encryption is a pain. PubKey FTW.

                            3. 3

                              I’ve been learning Go to support some client work. There are plenty of things I don’t like about the language already, but a few that I do and it’s been an interesting enough challenge so far.

                              As part of the challenge I’ve been looking at interesting libraries written in Go, so far it’s just been this raft implementation but it’s already proving quite interesting. I’m on the lookout for more if anyone has recommendations then please let me know.

                              1. 3

                                Last week I stated some goals here for progress on my [http://uniphil.github.io/expression-ui/](math expression visualizer), and met none of them, which is ok, I’m working on this slowly. It’s a long-term project. I spent time instead thinking about and working the front-end architecture. I also worked on the parser, which I got to a state I’m comfortable calling v1.0 after mashing it with a stupid-simple fuzzer over the weekend and fixing the resulting bugs.

                                This week I hope to get back to the UI and add features. First, I’ll be wrapping up my ad-hoc view/component class into a tiny library, and the transitioning the code to that. It’s kind of like react, without the cool parts – no virtual dom diffing, no jsx, just an attempt to push state out of the component code as much as possible, re-rendering without fear. Browsers are actually pretty fast at doing a lot of DOM manipulations, and the UI for this is tiny. React is just too huge and fast-moving – I want to work on this project over a long time, so I’m avoiding dependencies, especially large ones. The javascript code ecosystem is nuts.

                                Then, new features for the visualizer! Animations, graphs, and dynamic scaling of the graph are the next steps.

                                1. 3

                                  Up in the office this week, so mostly socialising rather than tinkering outside of work.

                                  I did get my shelves up with my server & consoles next to the TV last week which I was pretty happy about though. Next step is to tidy the cabling up and put some shelves the other side of the TV too. All in good time.

                                  1. 3
                                    • Writing an article about ES6 class syntax
                                    • Putting together an update of my book on the Jasmine testing framework
                                    1. 3


                                      1. 2

                                        I’m working on taking a break from my RSS reader project, http://idoru.io. Turns out there is such a thing as coding too much.

                                        1. 2

                                          This is the first time I answer this question. Nice to be here.


                                          • Working on earth modeling, a really interesting topic algorithms wise.


                                          • Tomorrow a permanent location for the local makerspace is going to be opened, I have worked quite a while on that.
                                          • If my kids let me get enough sleep to have some extra energy, I will continue on the compiler in 24 easy steps tutorial. I am quite stuck on calling tail call closures, because my stack gets messed up. I will have to abstract the stack properly to see the error.
                                          1. 2

                                            Almost done writing an MQTT implementation in Rust. Can’t wait to throw it out onto crates.io

                                            1. 2

                                              Learning haskell and working on Haksell-fischbot

                                              1. 1

                                                My Saturday project, first program with Löve2D: https://github.com/flyingfisch/love-lines-and-circles