1. 29

What are you doing this week? Feel free to share!

Keep in mind it’s OK to do nothing at all, too.

  1.  

  2. 8

    Finally going to start “Project Alexandria” which is a highfalutin code name for a plan to insert all my books into a Postgres database and supply a simple front end (with little or no JavaScript) to query it.

    1. 3

      Bonus points for giving your personal projects code names. Way cool. :)

      1. 1

        Decided to go with some shell scripting to pull the book info and ready it for insert. Learned about jq, IFS and process substitution today :)

        if [ -z "$1" ];
        then
                echo -n "missing ISBN number!"
                exit 1
        else
                key=123
                
                # IFS == internal field separator
                # read attempts to read nbytes of data from the object referenced by
                # the descriptor fd into the buffer pointed to by buf
                # < <(process substitution)
                # feeds the output of a process (curl) into stdin
                # e.g., echo <(echo bar) creates a temp file descriptor
        
                IFS="|" read title authors published desc \
                < <(curl -s "https://www.googleapis.com/books/v1/volumes?q=isbn:$1&key=$key&maxResults=1" \
                | jq -r '.items | map([.volumeInfo.title,.volumeInfo.authors[0],.volumeInfo.publishedDate,.volumeInfo.description]| join("|")) | join("\n")')
        
                echo -n $title
                echo
                echo -n $authors
                echo
                echo -n $published
                echo
                echo -n $desc
        fi
        
        1. 1

          Metadata only, or content?

          1. 1

            Metadata only for now, but I would love to find a way to grab my underlines from the actual texts. That’s far further down the line.

        2. 7

          I am creating a webappsite for my self-tracking and lately figuring out a way to track and measure social media consumption, with the goal of finding out how much of it is truly beneficial or how much is not.

          1. 2

            Cool! I’ve often wanted this and thought about it for many years. What tech will you use? Open source?

            I think the hardest part is making it general enough. e.g. tracking steps or whatever is pretty simple, but it gets a little more complex the more metrics and shapes you add. Steps, nutrition/calories/macros, workouts, sleep, stress level, whatever else.

            What kind of stuff do you plan to track? Anything beyond social media?

            My latest conclusion is that I should just stream all my data into google sheets to avoid being locked into a single platform. My data sources are Oura, Strava, Cronometer and maybe some random apple health stuff.

            1. 1

              My site is currently static, generated from Haskell DSL (via rib). It is visible only to me, due to sensitive of the data. But if I were to do dynamic stuff, I might just use ghcjs via obelisk (basically Haskell and FRP, which is Elm on steroids).

              Things I currently track:

              • Food consumed & skin health (to identify triggers)
              • Progress in PCE contemplation and its (mental) blockers
              • Random markdown notes

              Things I want to track:

              • bazqux.com stats (how much I read, how much of the feeds are actually useful to me, how much is just fluff, etc.)
              • Calisthenics “greasing the groove” style reps and progress
              • Mood tracking (think a calendar view of color-coded days, which you can drill down to specific journal entries)
              • Work mood tracking (similar, but in work contexts)
              1. 1

                Do you input this data in any apps or do you plan to track it all manually?

                Tech sounds amazing. I’ve played with both Haskell and Elm and wish I had more opportunity to use either/both. I wouldn’t consider myself proficient at either, but understand the concepts pretty well.

                1. 1

                  I input it in my Haskell DSL which is defined using something called “free monads”. I’ve written about it here. Here’s a screenshot, showing the DSL definition on left and its use on right:

                  1. 1

                    Wow. So there’s no data store? The data is literally hardcoded and you update the code every day to add a new entry?

                    Edit: from the blog:

                    Better alternatives? What do you think, dear reader?

                    This is super interesting but I can’t imagine building this without a separate Haskell/lang/platform-agnostic data store! 😨

                    1. 2

                      Wow. So there’s no data store?

                      Yes, everything is checked in to git. I’m not a fan of using databases unless actually needed. Well-structured text files suffice for most cases.

                      The data is literally hardcoded and you update the code every day to add a new entry?

                      Yup. I just add a few lines every day to the DSL, but don’t do anything else. ghcid (which rib uses) will instantly re-compile it (giving me feedback on syntax errors if any) and run the code, publishing updated HTML to my website (via keybase pages; so no deploy needed).

                      One day I might write a blog post describing this workflow.

            2. 1

              that reminds me, I want to get some stats on myself to see how many times I use the right alt and right ctrl keys on the keyboard. I just need to get the computer to track them then forget about it for a week.

              My gut feeling is I never use them. But proving that should be easy enough. I could also perhaps just pop them out and see if I get annoyed when my fingers go there and hit nothing lol

              1. 1

                logkeys is pretty good and very simple to set up for such kind of analysis

            3. 7

              I’m working on building simulation. There’s an interesting optimization problem when you build off-grid around insulation/batteries/solar panels; what’s the ideal combination? There are a lot of rules of thumb around insulation thickness that I think are wrong, because the price of solar panels has collapsed since those rules were instituted.

              If you wanted to build a building with it’s own energy supply in the 90s, the way to do it was with massive amounts of insulation, like in the R-100 range. Builders of high efficiency houses in my area still go by that, but I think it’s wrong; the right mix in 2020 is way less insulation, way more solar panels and batteries.

              Problem being that in case you’re wrong you’ve built a really expensive freezing cold box.

              I’m using the DOEs physics simulation engine, Energy+, with a Go frontend, to simulate different scenarios of the cabin I’m building here in Missouri.

              1. 1

                This sounds cool. Out of curiosity, are you factoring in the lifetime expectation of the solar panels and batteries, or are you assuming they last the life of the cabin (however long that is)?

                I’d love to build a cabin someday, so this is relevant to my interests.

                Edit: jeez that video is terrifying. There’s reasons whole villages got together to raise the frame of a new building, I guess, more labor could have really really made it less precarious to handle. Glad you got it done safely.

                1. 1

                  I intend to, but I’m not factoring in lifetime expectation yet. Same applies to insulation; there’s another axis of which type of insulation you use, some lose a lot of their efficiency as they age, some don’t. It’s a really interesting space, but it seems super easy to make a simple mistake in the simulation and come up with totally wrong answers.

                  Yeah I’m definitely not raising giant A-frame triangles like that ever again. There’s an ongoing debate in the family of whether the ones that fell would’ve killed me if they hit me in the head; I think I would’ve lived, but it’s a bit uncomfortable that there answer isn’t clear.

              2. 4

                I started an Elm newsletter this week in an attempt to learn more about the language (in addition to building a small toy project).

                1. 4

                  Self-understanding. Not in a ‘find my purpose’ kind of way, but digging deeper into various traits which have caused me difficulty, but I have discovered might be changeable, with some work.

                  Self-hacking, then.

                  1. 3

                    I’ve got a Soekris net6501 box I’m using as my gateway device. It currently runs Arch Linux 32, but I’m working on flashing it with a custom-built Alpine ISO with WireGuard support.

                    1. 1

                      Ooo, you reminded me that I also have a Soekris box collecting dust in some box. Might use it as DNS server (pi-hole).

                      1. 1

                        I’ve got a 4501 and a PC Engines somewhere too!

                    2. 3

                      Thought about using a zero-page-based initialization approach for modules.

                      module Foo
                        let bar = "baz"
                      
                      while condition
                      do  somethingWith(Foo.bar)
                      

                      Problem: Modules are only initialized once on first access, so guarding every access to it with a null-check for the rest of the application’s run is wasteful (imagine the module is accessed from within a loop, as in the example above).

                      Idea: Instead of checking for initialization, just let the uninitialized module access the zero page, trap it, trigger the initialization and resume execution. A page fault is massively slower than a null-check, but the difference is that the page fault happens at most one, while the null check would need to be done at every access.

                      1. 1

                        IMO there really shouldn’t be all that much for a module to do at load-time, and a lot of this work could be done in a post-compile execution step (or with macros) and simply serialised.

                        As GB says, the build is always broken

                        1. 1

                          I agree, it’s basically initializing its members.

                          The motivation is that modules could also be loaded during runtime, via plugins, etc.

                          I generally despise the capricious, arbitrary and ever-expanding rules that languages invent to classify what can be (C-lang) “static” and what can’t.

                          Of course I want to allow initializing the modules of the standard library and saving that state into the interpreter executable such that it can be mmap-ed during execution, but I’m unwilling to weigh down the language with additional complexity to achieve this goal.

                          If you are interested, I expanded on the topic here.

                      2. 3

                        I’m trying for the 3rd time to learn Rust with the klabnik book and exercism.io’s exercises, and well, I really suck at it. Is it me or this language is really more difficult that it should be? My main languages are C, golang, php, python usually… I’m starting to believe I’m too old for learning.

                        1. 2

                          Is it me or this language is really more difficult that it should be?

                          More difficult that it should be is hard to answer. Some other attempts at new languages try to aim for easier to use concepts also ensuring the same safety but right now only rust can bring you both safety and performances.

                          Difficult ? Yes it is, especially if you learn rust at evenings while you spend your days on easier languages. But I think it’s worth it. If it’s any consolation: most developers found it really hard to learn until, progressively, it started to fall in place.

                          Suggestion: You should maybe start to use it without bothering learning it ? That’s what I did and I found it easier to learn by practicing and being corrected by the compiler (more usually the borrow checher).

                          1. 2

                            I had that same feeling of “Is it me or this language is really more difficult that it should be?” when I tried to learn Rust a few years ago. I see why a lot of people enjoy the language, but it wasn’t my cup of tea.

                            1. 2

                              Unfortunately it seems to take most people at least one time bouncing off of it, sometimes several as you have experienced… Rust’s type system borrows a lot of ideas from OCaml/F#, which are a pretty big change in the way of doing things from the language you’ve listed, so that might be one level of adjustment to get used to already. Then, between the type system, borrow checker, traits, iterators, generics, and so on there’s a lot of stuff going on in Rust, and most of it gets hidden by the type inference so that you don’t have to constantly bump into it. If you already know how it works.

                              What worked for me was two things: first, start by writing a program way simpler than you think you can handle; for me it was just Conway’s Life. Second, get in one of the various chat rooms of one kind or another, find the beginners channel, and ask for help as much as possible. A lot of Rust’s complexity is optional, but things like the standard library use a lot of it, so it’s common for new people to feel like they have to overdesign things.

                              1. 1

                                I also tried, and “bounced” (even though I know many languages, and was very good at C++ some time ago). I tried the “start using it and learn as I go” approach, but got overwhelmed by nuance and kinda betrayed when trying to rely on error message hints, which showed up to be occasionally not working or self-contradictory (“You are doing A; maybe try B instead?”, then after doing B: “You are doing B; maybe try A instead?”). However I hope to try revisiting it in future, maybe more than once. I can’t count how many times I bounced off learning vim, but when I finally had to, I went on to love it. So, keeping fingers crossed for you!!!

                                Also, one tutorial I found recently that I want to read, maybe you also will find it interesting, is about writing a roguelike game in Rust.

                                1. 1

                                  I’ve been learning Rust too with the main book for about a month and a half, and it is a doozy. I have been doing every example in every chapter and tweaking to make sure I understand. That has helped. I started a project In Rust but I am realizing the value of working through the whole book, so I put that on hold for now.

                                2. 3

                                  My main goal for this week is to finish this PR: https://github.com/direnv/direnv/pull/555

                                  This is a long-standing issue with direnv which prevents the user from aborting long-running .envrc. After 5 seconds, direnv says: “… is taking a while to execute. Use CTRL-C to give up.”. If the user hits Ctrl-C, direnv aborts, the next prompt shows up and direnv gets executed again, restarting the whole build process.

                                  I am this close to finish the PR but it needs a last push as the mechanism is quite complex.

                                  1. 3

                                    Finally released the first issue of my new programming magazine “Human Readable Magazine”. Was shooting for Ian 1st :/

                                    Even though our Kickstarter campaign wasn’t successful, the feedback was overwhelming positive so I couldn’t just drop it.

                                    Now I iust need to figure out step 3: profit :)

                                    1. 0

                                      Ooooh, I will read this.

                                      1. 1

                                        :D Definitely let me know what you think! Thanks for checking it out.

                                    2. 2
                                      • Still working on multi-site stuff for $CLIENT - provisioning pretty much works now, but I need to look at some of the tables that will be shared.

                                      • Digging up, and re-routing the buried ethernet (that I dug and buried) where I managed to break the conduit removing a bush over the weekend.

                                      • Reconnecting a bunch of existing (and one nw) sprinkler lines to a new feed line, so we’re able to use the full pressure capacity of the pump.

                                      1. 2

                                        At home:

                                        • Building a few gnarly plaintext accounting importers (e.g. health insurance claims, which involves scraping) so I can finalize finances for 2019
                                        • Working on getting fido2-hmac-secret to compile on BSDs (and if I can get there, next stop is Windows)

                                        At $DAYJOB:

                                        • Working on improving static analysis by automatically rewriting some code to include better type hints
                                        • Rolling out some code to do better device detection
                                        1. 2

                                          Embedding a scripting language into a C99 application for scripting program behavior (startup configuration will be done using these scripts too). I’m not entirely sure which one I’m going to use, right now I’m torn between lua, python, or just handwriting a LISP. I’m leaning towards Lua right now, but I’m sure someone here has done this before and I’m open to recommendations.

                                          1. 3

                                            Lua is definitely easier to deal with when integrating stuff, but then you’re left writing Lua (it’s fun for scripts but less fun for bigger programs I think).

                                            I don’t know your usecase, but you might be able to “invert the stack”, where your entry point is written in Python, and it calls into your application via the Python FFI. This is what stuff like Mercurial does, and lets you more easily manage the dynamic nature of a program entry point and give you a good amount of expressive power.

                                            The Python FFI with C is really straightforward, I’d recommend it.

                                            1. 1

                                              I don’t know your usecase, but you might be able to “invert the stack”, where your entry point is written in Python, and it calls into your application via the Python FFI. This is what stuff like Mercurial does, and lets you more easily manage the dynamic nature of a program entry point and give you a good amount of expressive power.

                                              This is for my game engine. There’s an engine API exposed for export as a shared library and games/demos are loaded at runtime from shared objects (or DLLs) by the engine driver (a separate executable) during development. It should be possible to easily generate Python or Lua bindings based on this engine API.

                                              File parsers (.ini, or XML or JSON data conversions) and script interpreters (C-like or LISP) in my experience become massive time sinks with poor documentation and breed many, many bugs, especially for mapping to/from JSON–“What are the keys this thing accepts?”, “Which parser version is this using and when did this key change?”. Scripts should be able to access engine behavior permitted by the security settings of their runtime environment, so they can be used for engine configuration, scripting gameplay behavior, and asset description (during development).

                                              Asset descriptions should be human-readable, diff-tool comprehendable, and text searchable until compiled into optimized formats by the asset conditioning pipeline for distribution. Asset descriptions will rely on engine functions to piece together assets for use to simplify debugging, error checking, and to make behavior easily searchable to avoid the “oh, that thing I need is actually in some descendant tree of some binary-based object in the editor!” I’ve seen this done very well with LISPs before, which is why I had been thinking that way.

                                              This creating binary dependencies–one of the next steps prior to this work is automatically creating and verifying semantic versions based on the symbols generated and function signatures of engine or game dlls. This will identify breakages automatically based on when symbols are added, removed or changed as part of CI/CD (diff can also be used to identify which C functions changed between commits) and simplifying this process is actually part of the reason I’m using C, since it generates consistent symbol names for analysis.

                                              1. 1

                                                I can’t speak to this from experience, but some years ago, I came across this page advocating for extending python with your library, rather than embedding: https://twistedmatrix.com/users/glyph/rant/extendit.html, and thought the arguments made sense. On the other hand, I have a sense Lua was made to be embeddable, and your own LISP would presumably be fine.

                                                1. 1

                                                  That’s a great link! It has a lot of ideas I hadn’t thought about. I commented on another post why I’m doing embedding since it’s doing low-level control, not high level program flow. I should have been more clear about this in my original comment.

                                              2. 1

                                                Writing your own lisp or any PL implementation is a deep rabbit hole, approach with caution :) It also taught me a lot about programming though.

                                                If the goal is actually finishing the main program: Lua; there’s also a few small lisps made with embeddability as a goal, chibi scheme to name one.

                                                1. 1

                                                  Writing your own lisp or any PL implementation is a deep rabbit hole, approach with caution :) It also taught me a lot about programming though.

                                                  Yeah, I’ve written one before, that’s definitely a problem! :)

                                                  If the goal is actually finishing the main program: Lua

                                                  This is consistent with what I’m finding else in my research.

                                                  1. 1

                                                    I’m kinda in love with Lua since I first learnt about it some 15 (or more?) years ago, so I may not be exactly objective… generally, Lua excels at being an embedded language; also, historically, it evolved in part from a configuration language, so “glorified config” usage is deeply in its DNA, should you want it for this purpose (I like it as an escape hatch from Greenspun’s Tenth Rule whenever I’m tempted to consider adding some logic/templating to JSON). The language (and its implementation) is very simple yet powerful, the API is small, simple, robust, and designed for being embedded. If you are planning to use it for a game, the added benefit is that it’s basically an industry standard for scripting in games. Other than tons of games, it’s also used in a lot of other stuff, including: LuaTeX, Wireshark (IIRC), NetBSD has support for Lua-based drivers (!), and more.

                                                    On the other hand, the elephant in the room is, that Lua has a relatively small ecosystem of third-party libraries; definitely not anywhere near Python. There’s basically LuaRocks, and sometimes some fringe stuff not in Rocks. Alternatively, you can consider embedding LuaJIT instead of vanilla (a.k.a. PUC-Rio) Lua; it has awesome LuaFFI which can make it easier for people/you to do some integrations in the future; this might also allow you to reuse some third-party libraries created by the Love 2D community, though I never tried doing that. One thing to know here, is that LuaJIT’s creator stepped down, and although kinda handed over since, the project seems to me to be slowly stagnating (though, it can also be seen as basically “feature complete”). It wasn’t upgraded to Lua 5.3 (in all fairness, on purpose), though Lua 5.1 from which it was forked is already a very mature language.

                                                    As to writing “huge apps”, I never personally did that in Lua; my assumption here is, that possible issues around that would probably boil down to Lua being dynamically typed (less protections), and an interpreted language (speed). I think one would have similar problems in JS, Python, or LISP. As to speed, all of the languages I listed try to mitigate it to some extent through JIT interpreter(s), and Lua also has one in LuaJIT.

                                                    As to writing your own LISP… yeah, can do, as long as your main goal is to write your own LISP ;) I am sure this is very educating and enlightening, however it will definitely distract you form the game itself for long (if not forever…). Also, as far as ecosystem, I claim you’ll be much, much worse than with Lua, not to even speak about Python; one more dialect of LISP in a world where even mainstream LISPs are kinda fringe…

                                              3. 2

                                                The public thing this week will probably be my terminal library. I’ve written two open source terminal components in the past: a terminal emulator suite and a terminal user library. The user library is made to be generic on any platform, but I’m thinking about offering a merge option where it will actually use my own emulator backend for more consistency and special features.

                                                I hate terminals so this would be one step toward transitioning programs to more gui features :P

                                                1. 2

                                                  At home: Converting my desktop from Arch to MX Linux. At $DAYJOB: Started working on a toolchain for a new architecture. Just reading docs for now, since there are no requirements yet (or actual hardware, for that matter).

                                                  1. 2

                                                    $HOME: Trying to finish up a Qt GUI for Circle CI (really can’t handle their web UI). PyQt has been an interesting experience so far.

                                                    $WORK: finishing up our serious move to Webpack, some Django app maintenance.

                                                    1. 2

                                                      Work: Today, I’m revisiting some code I wrote a few years ago and getting an abject lesson in 1) how much I still have to improve at writing code, and 2) the perils of inheritance.

                                                      There’s a basic algorithm that collects objects that are connected in a graph. Then there’s a second algorithm that does does the same thing, except it dynamically ignores some edges in the graph based on information about the objects. I wrote the two algorithms so that the second inherits from the first, and that inheritance makes it much harder to reason about. Also, just in general, it was extremely hard for me to write the second algorithm, and it ended up not very clear or maintainable. There’s now a bug, I’m coming back to it after about two years, and it took me about a day to fully understand what I’d written, and how it works, and to try and make a modification. So I’m trying to figure out what I can do to make it comprehensible.

                                                      Not Work: going to set up a mac mini as a build/benchmark server. The full run of benchmarks for my regex project is relatively slow, so I’d like an isolated environment where I can run them on every git commit to master, and then publish them. I’m not sure what tools I should use.

                                                      I’ve also been trying to implement inlinining for the regex to bytecode compiler (previously: https://lobste.rs/s/sjymn9/what_are_you_doing_this_week#c_yjkmxx). My first attempt actually hurt performance, so I have to go back to the drawing board. I hand wrote the code that I’d ideally like to generate, and it does improve performance, so I just have to work on how I achieve that.

                                                      1. 2

                                                        Working on killing this flu.

                                                        Other than that, having another “why waste my time on X, Y, Z…” moment…

                                                        1. 2

                                                          Working on a C documentation generator and accompanying “making-of” blog post(s). The code for part 1 is complete. The WIP blog post for part one is nearly complete and I hope to publish today or tomorrow. The rest of the week will probably be spent working on the code for part 2.

                                                          1. 2

                                                            At work it sounds like I am moving to help provide some features for the finance department (more reports, tax calculations, etc) in hopes of lightening their load a little.

                                                            At home, I am continuing to learn my way through Godot. I have decided I want to try using the Rust GDNative bindings. It has been a lot of fun so far. So I have found myself helping out with the gdnative crate slightly.

                                                            I am also continuing my work on writing a Matrix Homeserver.

                                                            1. 2
                                                              • Experiment with porting my website’s frontend to Elm ONLY for progressive web app loads (I want to see if I can progressively enhance the experience for people like PWA’s meme about)
                                                              • Experiment with having a Gopher frontend to christine.website
                                                              • Play more with Drone, see if I can have it do CD as well as CI

                                                              Elm is nice. I’ve been using elm-spa as boilerplate to help make things easier to work with, but yeah. It’s nice. I should have dug way deeper into this a long time ago.

                                                              1. 2

                                                                Recovering from being sick as heck with stomach flu, and trying to figure out what work-stuff needs to happen in the next month or so.

                                                                1. 2

                                                                  Cleaned-up my Typed SICM project over the weekend. This is an implementation of the untyped Scheme code in Sussman and Wisdom’s Structure and Interpretation of Classical Mechanics to typed F#.

                                                                  I think I can now complete chapter 1 and (if I live long enough) the whole book with F#. A lot of noisy boiler plate in the repo, the only files that matter are https://github.com/jackfoxy/TypedSicm/blob/master/src/TypedSicm/TypedSicmPrelude.fs Most of the code in this file is type Scalar and supporting code, my experiment with generic arithmetic, which is completely unnecessary for this project. (I’m entertaining suggestions for better name than “scalar”.) Sussman and Wisdom, Structure and Interpretation of Classical Mechanics (MIT, 2014), 16 n, 509.

                                                                  https://github.com/jackfoxy/TypedSicm/blob/master/src/TypedSicm/Ch1LagrangianMechanics.fs The actual typed SICM code, comparing Sussman’s Scheme to typed F#. I think F# now wins on conciseness and readability.

                                                                  https://github.com/jackfoxy/TypedSicm/blob/master/src/TypedSicmConsole/Program.fs Executes the first 2 tests (from the book).

                                                                  I put together a F# language suggestion https://github.com/fsharp/fslang-suggestions yesterday to implement generic arithmetic. That was my purpose in over-engineering the generic arithmetic in this project. I’m soliciting feedback from colleagues before I submit it .

                                                                  1. 2

                                                                    $WORK: Finally handing over a project I’ve been working on for a while so that I can work on something else. The last step is getting AWS instances to create their own Docker Swarm and connect to one another. After that’s done, I get to work on drafting a couple of papers and maybe start writing some code for them.

                                                                    $FUN: I’m hoping to work on my website and add some IndieWeb/microformats stuff to it, plus finding a publishing workflow I like. I have something that’s mostly working so I can write some blog posts already, but I’d like it to be more streamlined.

                                                                    I’m also looking into self hosting some services at home. One problem I’ve run into is: if you’re hosting your website on your local network, you can’t view your website at its domain name (easily) because it pulls up the router’s admin page. I’ve tried to fix this with a local DNS entry on my pi-hole, but I wish there was something a little easier, especially since I expect to host many services on the same device, all with different domain names. Right now I have to add an entry manually for each one.

                                                                    1. 2

                                                                      I’ve just finished the translation of Tech Workers Coalition “Workers’ Inquiry” in Italian and I’m promoting it around.

                                                                      I’ve also just finished my second PR to a Rust project called “bandwhich” to learn the basics of the language. I want to pick up another one but I don’t want to take on too many things.

                                                                      I also want to write an article about the failure of the technological liberation envisioned by hacker culture and its relationship with time and explotation.

                                                                      1. 2

                                                                        I’ve got another week before I start my new job, so I’m trying to finish a simple implementation of Timsort written in Emacs Lisp. It’s very close. Once I get it working, there are a few things I want to do:

                                                                        1. Do some benchmarking. This is going to be complicated.
                                                                        2. Additional Timsort optimizations (e.g. galloping when merging: https://svn.python.org/projects/python/trunk/Objects/listsort.txt)
                                                                        3. Additional sorting functionality. Right now, it only works for integers. It should be possible to pass a key argument to it, or a different comparator function. I’m not sure which yet – maybe both.
                                                                        4. Attempt to contribute upwards.
                                                                        5. Blog about Timsort. I haven’t found the existing writeups about Timsort to be that great.
                                                                        1. 2

                                                                          Meta: I love this thread, I’ve seen it around but I didn’t know how consistent it would be. I generally post to the Indie Hackers Daily Stand-up thread to keep myself accountable, but I’ve also signed up for YC Startup School W2020 and Pioneer.app; maybe others could find those places to be helpful too :)

                                                                          This week I’m looking at wrapping up covering “The Haskell Book” and writing up a technical blog post on a Pythonista’s review of Haskell. This in order to begin work on TinyDevCRM MVP, which I hope to release by end of next week (maybe next Friday or so), with another technical blog post.

                                                                          1. 2
                                                                            1. Getting a software engineering apprenticeship program off the ground at $WORK. We’re starting in three weeks, already have 15 applicants, and have a rough plan, but there’s still a lot of things to figure out. As a long-time IC it’s really interesting to me to be able to work on something like this!

                                                                            2. Figuring out how to keep a personal database of folk tunes in a simple text-based format and combine them into medleys. I just hacked something together using the C preprocessor and #include<…>, but I think the real answer is to use ERB.

                                                                            1. 2

                                                                              Working on my side project, a minimalistic functional-style web framework for ReasonML/OCaml. Having fun working on hardening it with some security headers. From next week planning to tackle something more difficult–integrating a GraphQL server as a middleware.

                                                                              1. 1

                                                                                ReWeb looks great! Looking forward to GraphQL support and trying it out as a replacement for graphql-cohttp!

                                                                                1. 2

                                                                                  Thank you! It’s on my todo list :-)

                                                                              2. 2

                                                                                Text classification problem

                                                                                1. 1

                                                                                  Work stuff; mostly kubernetes and salt. Got an interest for lxd so been packaging it up with all the dependencies for redistribution in the Arch Linux repositories. Bit tedious when canonical only really cares about distributing this through snaps, but managed to get it working so far :)

                                                                                  https://github.com/Foxboron/lxd-repo

                                                                                  1. 1

                                                                                    I polished up and published a small project called hashgood, a Rust tool for conveniently checking that the checksum of a downloaded file is the one you expect it to be. I’ve had it kicking around for a few months and decided it was time to put it online!

                                                                                    1. 1

                                                                                      Hey everyone !

                                                                                      As I just added my web framework Phoon to a benchmark project, I am waiting for the results in order to eventually optimize the routing system.

                                                                                      I also plan to start the API to deal read/write cookies conveniently.

                                                                                      Have a nice week !

                                                                                      1. 1

                                                                                        A custom dotfiles/profile manager, based on Git+Lua+Nim, intended to be cross-platform between Windows/Linux/Mac, with config drift detection during initial precondition checking phase. Drift shows up as git-based diffs and precludes any changes to the system until acted upon; accepting them after manual inspection is as easy as git add . ; git commit.

                                                                                        Also, thinking how to make http://userland.org useful to me.

                                                                                        1. 1

                                                                                          Focusing on waking up at a consistent time every morning and sticking to a morning routine including exercise and meditation; holidays always seem to derail me. Less TV, more reading and writing in the evenings. $DAYJOB during the day. Maybe finally tackling Hyrule Castle in Breath of the Wild, if time permits.