1. 1

    (last week: https://lobste.rs/s/qbjfe7/what_are_you_doing_this_week#c_277whb)

    $WORK: Managed to get a lot done on the paper during the week and then almost none during the weekend. I think I needed a break from working on it because I kept finding myself getting distracted on things that aren’t important (e.g. I tried to write my own mapping library to work around problems I found in Leaflet, but now I’m going to throw that code out because it’s probably got more problems of its own).

    I start my new internship today and have a lot of on-boarding stuff to do (training, paperwork, etc). I’m hoping that I can start working on some of the work I’ll be doing, if I can get onto all of their systems I’ll need. So this week I’m just adjusting to all the new things and trying not to look too bad.

    $HOME: Re-made that salad dressing from last week and it was even better. Sometime this week, we’ll make it another time but writing down measurements we use. I think it’s also possible we’ll finish watching Bones and can switch to another series. We’re missing the final/most recent seasons of 4 shows now. Some friends and I just finished our playthrough of Divinity: Original Sin 2 and we loved it. We’re looking to find another game like it to play.

    1. 1

      I’ve spent a long time finalizing my home directory. I use a variation of the FHS for all my local files, though it took a while to really appreciate and make the most out of it.

      Every time I reinstall my OS, I go through the same process of removing all the Documents, Pictures, Downloads, etc directories and create the ones I prefer. Most of them stay gone, but Desktop and Downloads often come back. The biggest perpetrators are Gnome and Chrome, respectively, but this is solved with a few settings that I always have to look up.

      ~/bin/ - for any scripts I write and use, and especially for wrapper scripts to fix things I don't like
      ~/mnt/ - for `sudo mount /dev/sdb ~/mnt/`
      ~/opt/ - for software and tools that might need compiled (like ~/opt/dwm, ~/opt/Write, ~/opt/yEd)
      ~/share/ - for writings or drawings that I create (like ~/share/documents/*.svg, produced by Write)
      ~/src/ - for any project I work on (every directory here is a git repo)
      ~/src/*_paper/ - for research papers I'm working on
      ~/src/tmp/ - for any projects that I don't intend to commit to git (like re-clones of my work projects for trying new things)
      ~/tmp/ - for any files I download
      ~/tmp/*/ - for any completely throwaway projects (e.g. ffmpeg scripts for making hour long sleep videos)
      ~/etc/ - for any configuration files for tools I use
      

      I want to use the $XDG_CONFIG_HOME and $XDG_DATA_HOME directories but I never spend enough time making sure it all works, so I don’t really trust them to work right. I also just don’t like the idea of hiding config files in a hidden directory.


      One thing I used to do that I no longer do is to keep a very organized ~/src/ directory. I had a script to clone every project into an exact path and then update symlinks to be easier to use. The trouble I ran into is that it was a little too regimented and didn’t make it easy to write throwaway code because I always had to create a GitHub repository when I wanted to work on a project.

      ~/src/github.com/$owner/$repo - for any GitHub projects cloned
      ~/src/bitbucket.org/$owner/$repo - for any BitBucket projects cloned
      ~/src/$repo -> ~/src/github.com/$owner/$repo - symlinks for easier access to the full path
      

      I also try to have a small home directory as most of my work is on limited drives, so I need a solution to managing large datasets. The trick I use there is to make heavy use of symlinks to a data drive. For example, a project ~/src/foo would have ~/src/foo/data pointing to /mnt/mylargedrive/foo/data and ~/src/foo/gen would point to /mnt/mylargedrive/foo/gen. Then I can document the data source and formats in a /mnt/mylargedrive/foo/README and everything stays nice and clean.

      1. 2

        (last week: https://lobste.rs/s/obwsyn/what_are_you_doing_this_week#c_vjp4di)

        $WORK: I got a ton of work done this past weekend on the code for a paper we’re writing. I got to learn and practice a lot of OpenGL stuff and made a ton of progress.

        I’m hoping to get a couple more features done and continue the writing process so it can be done before I start my internship next week.

        I’m also very excited about the direction our work is going and think that it’s going to be a great foundation for my thesis. For the past few years, I haven’t really known what I wanted to do for my thesis, so this is the first time I’ve really felt like I get it and that has been nice.

        $HOME: I made more of those coffee bean style cookies and this batch turned out more like I was wanting. They’re a little dryer and crunchier which is what I was trying for. My wife and I also made some Asian salad dressing like we used to get from one of our favorite restaurants. We had been trying to make it for a while, and this batch turned out the best so far, so I’d like to write the recipe down. I didn’t start the #100DaysToOffload writing like I wanted, but that’s okay, maybe this week.

        1. 1

          (last week: https://lobste.rs/s/vcx5vu/what_are_you_working_on_this_week#c_ilxscv)

          $WORK: Finished the paper! I’m very pleased with how it turned out, especially that it marks the end of an 18 month dry spell of writing and working. A lot of my moodiness with being unmotivated was resolved by having consistent work to do.

          Now onto the next one, and then taking a writing break to focus on code by working with something entirely different. Today is about collecting some baseline results to compare against and writing a short form of the paper for a class. The rest of the week, I’ll be continuing to get enough data together to write the full paper.

          $HOME: Now that that paper is done, I’m feeling really motivated to start Kev’s #100DaysToOffload challenge. I think I’ll be writing some about software and cooking mostly. This weekend, I made little coffee bean shaped cookies but I had to tweak the recipe a lot, so I want to consolidate my changes and also start making large batches to share with family/friends.

          1. 2

            (8 weeks ago… a lot longer than I remembered https://lobste.rs/s/epx9km/what_are_you_working_on_this_week#c_bnj6ad)

            $WORK: It’s paper deadline time again! We’re submitting one paper on Thursday, so this week is all about wrapping that up. Then the next day, I have a final project presentation for a class before doing the last sprint on another paper due early May. After that, I start my virtual summer internship.

            Quarantine has been getting to me more lately, so I’ve been resolving to try to have more of a schedule and get more time outside in the sun. I’m finding it pretty hard to stay motivated sometimes, but having this work schedule with the papers helps a lot, surprisingly.

            $HOME: I had a lovely anniversary weekend with my wife, and I really enjoyed having time completely away from work, so I think I’ll keep that up. That said, I’ve been reading a professor’s blog and am feeling very motivated to do more writing on my blog and I’d love to start that up again. I felt very accomplished after finishing the last post I wrote up.

            Other than that, it’s just going to be more crime drama bingeathons and relaxing.

            1. 1

              I try to write a few blog posts here and there at https://mediocreatbest.xyz . I tend to follow the style of “let the code do the talking” without much exposition. For example, I just finished on the creation of compute-heavy scientific microservices which summarizes a lot of the things I’ve learned about embedding C code into Python servers, mostly in terms of how the code is written. My old blog includes a few more posts in that style.

              1. 2

                I have a special “.PHONY: phony” rule, that allows me to write:

                clean: phony
                    rm -rf ./output
                

                Instead of the usual:

                .PHONY: clean
                clean:
                    rm -rf ./output
                

                Note that this trick can slow down huge Makefiles.

                I didn’t know that phony tags are inherited, or how does this work?

                Also, if you’re already using GNU extensions, you might like to replace

                FIGURES = $(shell find . -name '*.svg')
                

                with

                FIGURES != find . -name '*.svg'
                
                1. 3

                  My understanding is that PHONY rules are like any other rule, it just skips the check for whether the file exists. You can already depend on a file that doesn’t and will never exist, for example:

                  clean:
                          rm -rf ./output
                  

                  Now make clean will run the rule like you might expect. The catch is that someone could create a file called “clean” and now your script won’t run. This is what PHONY solves: even if a file “clean” exists, it’ll pretend like it doesn’t.

                  From there, you can also depend on a rule that depends on a file that will never exist. For example, a clean-all rule could reuse the clean rule as follows:

                  clean:
                          rm -rf ./output
                  
                  clean-all: clean
                          rm -rf ./other
                  

                  This is all that .PHONY: phony rule is doing. It almost acts as if it’s inheriting the phony status, but that’s just a consequence of how Make handles transitive rules (if a sub-dependency doesn’t exist, it’ll re-run the whole chain of rules after that one).

                  The part I find interesting is that they say it slows down larger Makefiles, which I wouldn’t expect to be the case, at least not significantly.

                  Cheers for the != thing! I hadn’t seen that one before but it seems very useful.

                1. 2

                  (3 weeks ago: https://lobste.rs/s/2qzmtr/what_are_you_doing_this_week#c_cijuow)

                  $WORK: I’ve got a lot of stuff going on this week. I have a small presentation on containers and their history on Thursday which I have to throw together. In 3 weeks, I have my conference presentation, so I hope to start on that today and get it moving along so that I have enough time to practice and prepare. I also need to work on open sourcing the code that the conference paper/presentation is about, which I haven’t really started on yet.

                  I think I’m going to need to punt on a project I’m excited about for now, so that I’ll have enough time to get everything else done. Because everything is happening all at once this month, I’m going to have to get really good about managing my time. I’ve started journaling via jrnl.sh to keep track of that time better and I’m hoping to do some nightly reviews of the journal to see where I’ve lost time. I tend to treat myself poorly during busy months, which I’d like to improve on by making sure to give myself time to decompress and relax. After last year’s busy March month, I needed several months just to decompress, during which I didn’t really do anything, and I’m trying not to let that happen again.

                  $HOME: I’ve been playing with my 3D printer again. I finally have a copy of SolidWorks so I can start 3D modeling stuff. So far, I haven’t printed many useful things, but it’s been really nice to be able to do this again. There’s something really relaxing about taking measurements of things and recreating them in SolidWorks; it’s very systematic and the end result is always nice. Right now, I’m designing a little faux sink for my cat to play in so we don’t have to feel bad about wasting water (it’ll get reused and re-pumped through the system).

                  I want to get my personal server in use again. I didn’t get into blogging again like I’d hoped, and I think that’s because I made the system a little too DIY. I’d like to throw in someone else’s server that supports MicroPub that way I can blog from my phone, instead of having to get out my laptop. At the end of the day, it probably still won’t get much use, but it’s still fun to play around with.

                  I bought a laptop a week or two ago, a ThinkPad T420. I used to own one of those but ended up selling it to a friend, and I’ve been missing it. Unfortunately, the one I have doesn’t have all the nice specs the old one had (an i7, an SSD, maxed out RAM), but it works well enough once it gets going. It’s my main SolidWorks machine, from above. It also has a DVD drive, so I’m thinking about ripping some of the DVDs I own and setting up a plex server, perhaps on my gaming PC attached to the TV.

                  Lastly, a good friend is leaving for Australia for a few weeks, so we’re hanging out tonight before he goes. We’ve been playing through the game Divinity, which has a map/campaign editor that we’re hoping to play with and maybe port some simple One-Off D&D campaigns to, which should be fun.

                  1. 2

                    (2 weeks ago: https://lobste.rs/s/gmbx5t/what_are_you_doing_this_week#c_s0pk5o)

                    $WORK: I finished revising my paper and submitted it and it’s completely done! I now have about 6 or 7 weeks to make and prepare a presentation for the conference, and also polish up the code for release.

                    I’m getting some more work done on my other paper about graph rendering. For this week, my focus is to get an E2E MVP built and start evaluating it.

                    $FUN: My website is passably working now: personal page and blog, all with appropriate tags to each other that can be automatically parsed.

                    I spent most of the weekend playing around with IndieWeb concepts: MicroPub and MicroSub, specifically. I’m excited for them because I’m hoping to build a “personal indexer” of sorts. I read lots of articles online and I always forget what I’ve read and where. It’d be nice if my browser automatically saved the contents of pages I visit, saving them in either a plain text or microformat way. Further, if someone is interested in the things I read about (or more likely, if I’m interested in what others wrote), they could subscribe to my personal archive and query it too. I suspect that it’d be possible to replace a lot of my Google searches with this, without sending ever more data to Big Google all the time.

                    1. 2

                      (last week: https://lobste.rs/s/8uitwq/what_are_you_working_on_this_week#c_kez6sx)

                      $WORK: Over the weekend, I got some work done on the paper like I wanted, both coding and writing. With the initial draft out of the way, we should be able to start iterating on it and getting some work done. I also finished handing off that other project, so that’s off my plate.

                      One of my other papers got conditionally accepted with some minor revisions, so that’s my main focus this week: fixing the things our reviewers asked for and polishing for publication, plus starting on the presentation part of it so that I’m prepared for March. I will also need to get the code running again and make sure nothing has bitrotted.

                      $FUN: I didn’t get around to adding IndieWeb stuff to my website, but maybe I’ll find a few minutes here or there this week to at least get IndieAuth working. I solved my problem of “hard to access my self-hosted apps if they’re running from my network” the easy way: just run it on another network.

                      For my website/blog posts, I’m currently trying to decide between using lots of HTML things like microformats or just using plain text files. On the one hand: if I marked everything up, I could make good use of things like the recipe microformat and keep my recipes machine readable, and also have nice semantic links to other blogs or posts. However, then I have to give up the super easy “just throw text files on the internet” approach that I’ve been liking. The approach I’m leaning towards is to have things like recipes on their own standalone HTML pages and just link to them from my posts.

                      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. 1

                          A command-line productivity boost I recently added was a commit script to my zsh config:

                          commit() {
                            git add -A :/ && git commit -m "$1" && git push
                          }
                          

                          Being able to simple type commit 'Summary of changes' instead of

                          • typing git a
                          • tapping the up arrow to autocomplete the entire contents of commit script
                          • tapping the left arrow and then backspace/delete to replace the previous git message with an updated message

                          has made my life so much easier.

                          1. 3

                            git commit -a more or less does the same, although you’ll still need to add new files with git add (arguably a feature or annoyance). The downside of your approach is that it’s harder to write “good” commit messages with more context, since everything will always be on a single line.

                            1. 3

                              The downside of your approach is that it’s harder to write “good” commit messages with more context, since everything will always be on a single line.

                              Agree. Two useful bits of git to share:

                              1. if you do git commit -m "message" you can append as many more -m’s as you want to add lines to the commit message.

                              2. additionally (I only learned this recently), you can append -e to open the commit message in your editor. So, git commit -m "commit message" -e will open your editor with “commit message” at the start. It makes it easy to start a commit on the commandline and bail out to your editor to write more.

                              FWIW, here are similar aliases I use:

                              c = commit
                              cm = c -m
                              ca = c -a
                              cam = c -am
                              cmp  = "!f() { git cm \"$@\" && git p; }; f"
                              camp = "!f() { git cam \"$@\" && git p; }; f"
                              

                              So, my git camp (commit all with message and push) is similar to u/netopwibby’s commit function, but it’s composable, and additional arguments to git can be provided.

                              (p is an alias that pushes, automatically setting the upstream if necessary.)

                            2. 3

                              A nice, tiny improvement to scripts like this is to use the ${var:?error message} pattern. I use that a lot where I write a script that has to have an argument that I might forget, and forgetting would break the whole thing, but also where doing the full if [ -z "$var" ]; then printf $'bad\n'; fi pattern is overly verbose.

                              commit() {
                                git add -A :/ && git commit -m "${1:?need commit message}" && git push
                              }
                              
                              $ commit 'Summary of changes'
                              $ commit
                              -bash: 1: need commit message
                              

                              You can also improve the interface just a little bit if you use "$*" instead of just "$*" (at the cost of weird characters sometimes messing things up if you don’t use quotes, like asterisks).

                              commit() {
                                git add -A :/ && git commit -m "${*:?need commit message}" && git push
                              }
                              
                              $ commit 'Summary of changes'  # works like normal
                              $ commit Summary of changes  # also works
                              $ commit
                              -bash: *: need commit message
                              $ ls
                              bar  foo
                              $ commit Use * instead of 1  # same as commit 'Use bar foo instead of 1'
                              
                              1. 1

                                Oh that’s nice, I’ll try it.

                            1. 12

                              My favourite awk oneliner I have memorized, is for extracting contents between some specific begin and end patterns/fences in muliple files:

                              awk '/begin-regex/{p=1}; p; /end-regex/{p=0}'
                              

                              (I think you don’t need curly braces, but not sure now) For example, contents of all init functions in all Go files:

                              awk '/^func init/{p=1}; p; /^}/{p=0}' *.go
                              

                              By swapping the expressions between semicolons, you can make it include or exclude the fence lines in the output.

                              Explanation: variable p is 0 (i.e. false) by default. Default action for a condition with no action is to print current line, so the sole p in the middle expands to equivalent of: p!=0 {print}.

                              1. 3

                                I think you don’t need curly braces, but not sure now

                                Since assignment is an Action, you would have to use the curly brackets to change the value of p.

                                Unless you want this to go over files, you could also just do

                                /begin-regex/, /end-regex/
                                

                                which uses “Pattern Ranges”, and don’t require the extra auxiliary variable. If you still would want it to match patterns between multiple files, you’d probably have to use a pipe and concatenate the files beforehand.

                                1. 2

                                  Note that you can also achieve this very concisely with sed, including across multiple files:

                                  $ sed -n '/begin-regex/,/end-regex/p' file1 file2 ...
                                  
                                  1. 1

                                    Can this let me exclude the begin and/or end fence line from the output? Given that the sed language is Turing-complete, I suppose there is some way, question is how easy? In “my” awk expression, this is a matter of changing the order of the sub-expressions.

                                    1. 1

                                      I haven’t looked this up recently, but I believe the canonical sed version is:

                                      sed -ne '/start/,/end/ { /start\|end/ !p }'

                                      I thought there was another solution by abusing labels and gotos but I can’t seem to get one written.

                                2. 3

                                  Thanks, this tip led me to refactor some of my awk code :) I like that pattern too, but I forgot that the booleans can go on the left too. I think always think of Awk as “patterns and actions” but it’s really “predicates and actions”.

                                  Context: as part of hollowing out the Python interpreter, I use this Awk snippet to extract the C struct initializers in the CPython codebase.

                                  https://github.com/oilshell/oil/blob/master/build/cpython-defs.sh#L75

                                  Then I parse that very limited language of {"string", var1, var2, ...} with a small recursive descent parser.


                                  Overall I’ve found good use for awk in 5-10 places over the last couple years, i.e. NOT the typical “field extraction” use case of { print $5 }.

                                  Now that I know awk more, I like it more than I used to. On the other hand, I’ve also written a few hundred lines of Make from scratch in the last couple years, and I think less of it than I used to :-/ Make always seem to give me half-working and slow solutions, whereas Awk gives you a precise and fast solution.

                                  style patch: https://github.com/oilshell/oil/commit/eee1ee13feca3e6de31f34b778fdc3bdb0b520fd

                                  (I also didn’t know about the implicit { print } but that seems way to obscure for me :) )

                                  1. 2

                                    (I think you don’t need curly braces, but not sure now)

                                    you can do this without any explicit action statements:

                                    awk -- '/start-reg/ && (p = 1) && 0; p; /end-reg/ && p = 0;'

                                    only because assignment is an expression that returns the lvalue value that gets assigned to the rvalue. but mind order of operations.

                                  1. 3

                                    Although it certainly wasn’t anywhere near the specs of that computer, this post brings back good memories of using my Eee PC netbook (is that really the correct capitalization, Wikipedia?) to run DF while waiting to tutor people in high school. I didn’t have to kill off any extraneous processes to even run it, thankfully, but I did have to live with low framerates. Also, with not being good at the game.

                                    One of my favorite tricks with that netbook was that I installed a utility that gave me an expanded desktop, so I could have larger windows open and by pushing my mouse along the edges of the screen, I could move to different areas of the screen. Looking it up just now, I think I found the exact tool I used: “Infinite Screen.” This way I could keep my DF window larger than my screen size and still be able to see everything (though not all at once).

                                    1. 1

                                      One of my favorite tricks with that netbook was that I installed a utility that gave me an expanded desktop, so I could have larger windows open and by pushing my mouse along the edges of the screen

                                      When I first installed Linux in the late 1990s it came with FVWM (or maybe this was a feature of XFree86?) with a “virtual desktop” exactly like you described. Of course being used to Windows 95/98 at the time it was the first thing I disabled.

                                      1. 1

                                        I’ll have to look that utility up. I think I accidentally triggered similar behaviour in Xorg many years back, but I’ve never been able to recreate it.

                                        My laptop screen is 1366x768, which can sometimes be annoying if I want to screenshot things taller than this. My favourite workaround:

                                        xrandr --output yourscreenname --scale 2x2
                                        

                                        2732x1536 is where it’s at, take that 1920x1080.

                                        1. 2

                                          Oh, to be clear, that’s a Windows-only utility. I should have said that originally.

                                          The only place I’ve seen that resolution is a Thinkpad T420 with the larger screen mod. Any chance that’s the same for you? I’m lucky in that, when I had that laptop and needed to take large screenshots, I either had a big external monitor or a friend with a retina display.

                                          That xrandr trick is neat! I just tried it out and visually it works well, but my mouse didn’t want to move into the bottom right corner of the screen, interestingly enough.

                                          1. 1

                                            Ooh, I might have to try this on Windows.

                                            My favourite Windows change is to install bb4win, so I get proper virtual desktops. I have not tried it on Win10, but presumably it’s a reliable way of keeping cortana away as well. I used to use Asuite for a program-launching menu, because the one built into BB is pretty crappy.

                                            The only place I’ve seen that resolution is a Thinkpad T420 with the larger screen mod.

                                            1366x768? It’s the standard for almost all cheap laptops these days. Mine is an 11.6” (small) so it not’s a bad option here, but sadly it’s also used for bigger screened laptops.

                                            my mouse didn’t want to move into the bottom right corner of the screen

                                            Eep, that’s a bug.

                                            Are you on Nvidia by any chance? If so: you probably have to stick to using Nvidia’s utilitiy for screen management, not xrandr. I remember having this problem in my days of ATI Catalyst.

                                          2. 1

                                            I may be wrong, but wasn’t this the default behaviour on X11 (maybe XFree86 before Xorg took it’s place) at some point?

                                            I recall often accidentally running into this problem many times when my graphics card drivers weren’t properly installed yet, and my card only reported basic 640x480 or 800x600 support through the BIOS.

                                        1. 2

                                          I’ve got a busy weekend ahead of me. I have 10 papers to read and summarize, and then 2 more papers to read and review. Tonight there’s a game night with friends and then tomorrow can be dedicated to finishing up all of these papers.

                                          On the bright side, I’ve been playing with terminal-based programs without ncurses like with http://xn--rpa.cc/essays/term and I’ve got a demo of a Sam/Acme-like scrolling (right click to go down, left to go back up, and dependent on how far down your mouse is on the scroll margin). Now that I understand the logic, I’m thinking about hacking Vim to have that feature, which I suspect will have to be done in the C code rather than in a Vim extension.

                                          1. 3

                                            I’m a big fan of this style but with a couple of additions. In particular, I like to have variables that, when set, pass their values to the flags, and when not set, just don’t exist in the command line arguments. An example:

                                            #!/bin/bash
                                            # File: foo.sh
                                            
                                            type=${type:-f}
                                            dir=${1?:need a directory}
                                            
                                            find "$dir" ${type:+-type "$type"} "$@"
                                            
                                            # Usage:
                                            #   ./foo.sh mydir  # find files in mydir
                                            #   type=d ./foo.sh mydir # find directories in mydir
                                            #   ./foo.sh mydir -exec wc -l +  # count lines in files in mydir
                                            #   ./foo.sh  # error: need a directory
                                            

                                            The trick is using ${variable:+--flag "$variable"} which, if $variable is unset, expands to nothing, but if set, it expands --flag "$variable". Another example for docker is:

                                            #!/bin/bash
                                            # File: docker.sh
                                            
                                            data=/mnt/data
                                            
                                            docker run -it --rm ${data:+-v "$data:$data"} "$@"
                                            
                                            # Usage: ./docker.sh hello-world
                                            

                                            This will run whatever container interactively and with the /mnt/data directory (but if you edit the file to remove the data= then it will not mount it).

                                            (I talked about the Docker approach more at https://mediocreatbest.xyz/1/ if you’re interested)

                                            1. 3

                                              This is a neat trick; I didn’t know about :+ substitution. It’s even a POSIX feature! I updated the article to include it. Thanks!

                                            1. 3

                                              The academic semester is ending which means I finally have time to focus on my actual research after a month long hiatus (more due to lack of motivation than lack of time). This week is for getting back up to speed with a paper we’re writing and testing lots of things. One of the main things we’re pushing to say is that we’ve built a performant system, but I want to be able to feel confident about that result. To me, that means that I need to reimplement in the most straightforward way and build layers on it until we get to the current version we have, measuring performance along the way.

                                              To be more specific: we wrote a distributed system in Python (multi-python). There’s a straightforward single-process, multi-threaded version that can be written in C (single-C). Then we could just add a distributed layer on top so it’s multi-process, multi-threaded (multi-C). Ideally, we’ll see that multi-C is faster than single-C, and that multi-C is within an order of magnitude of multi-Python. If either one of those doesn’t hold, then it means another week of trying to speed up the system.

                                              Besides that, I hope to spend some more time writing for my blog. I’m still trying to find my voice and how I want to write posts. So far, it’s been just discussing my own projects I’ve put online, but I hope to move towards talking about other things that aren’t so “product-based.”

                                              1. 3

                                                I often go from hobby to hobby. In the past, I’ve tinkered with electronics, reading lots of programming topics (especially language theory), and more gaming than I care to admit. Lately, I’ve been:

                                                Brewing both beer and now wine/cider. I started with a kit, then faked my way through a couple of recipes. Now I’ve got 2 beers conditioning in bottles and just finished reading my third book about the hobby. Hoping to finally get to the point where I can make something drinkable and dial in my consistency. I’ve also got a muscadine wine from some grapes we picked, a Welches concentrate wine (with $6 in it in total), and an apple cider from some leftover apple juice.

                                                Reading is something I’m trying to get into. I used to read a lot (of technical books) when I was younger, but I find myself sticking to digital media more often, which I’d like to cut down on. With the brewing hobby and books I’ve read, I’m beginning to really like reading physical books again. I just need to find a library nearby so that this hobby doesn’t get so expensive.

                                                Kitten care is a new one for me. We’ve had a kitten before, but my fiancee took care of him mostly. With our new kitten, I’ve been trying to take more of a role in taking care of her. Still learning, but so far it’s been fun.

                                                1. 2

                                                  Good luck with the Welch’s wine. Have you made it before? I did a batch and while it was a “success” in that it “produced alcohol”, it also tasted like… well, grape juice. (Also, I hope you didn’t add any acid: my second batch I tried a bit, and it ended up tasting like stomach juice. Yuck).

                                                  Now, if you haven’t tried EdWort’s Apfelwein - THAT is a cheap and tasty treat. I need to make 10 gallons of that next time I get a chance. I love that stuff.

                                                  1. 1

                                                    Thanks! I’ve never made it before but the little bit I’ve tasted as it’s been fermenting has been good, albeit very sweet still. I didn’t add acid to this one, but that’s good to know that it becomes overwhelming very quickly. How much did you add to yours / how many gallons?

                                                    I think that my cider that’s fermenting is pretty close to apfelwine, at least based on the homebrewtalk post I just found (which only said apple juice, sugar, and yeast for the ingredients). Definitely excited to give that one a try!