Task</strong> </span></th>	Time</strong> </span></th>	Description</strong> </span></th> </thead>
Proposal Writing (Due 2020-04-20)</td>	2020-03 to 2020-04</td>	Write research proposal.</td> </tr>
Literature Review</td>	2020-04 to 2020-06</td>	Investigate efficient coherent search methods</td> </tr>
Analyse Existing Codebase</td>	2020-04 to 2020-07</td>	Determine expected inputs and outputs of coherent search methods and determine per-thread computational cost</td> </tr>
Determine valid unit tests</td>	2020-05</td>	Determine tests that can be used to determine the correctness of coherent search algorithms</td> </tr>
Oral Progress Report (Due 2020-05-22)</td>	2020-05</td>	Give report detailing progress on research</td> </tr>
Refactor Existing Codebase</td>	2020-06 to 2020-08</td>	Perform changes on pipeline</td> </tr>
Validate New Pipeline</td>	2020-08</td>	Compare outputs from changed pipeline to the previous version to ensure there is not a regression of results</td> </tr>
Measure Performance Differences</td>	2020-08</td>	Determine performance cost of changes</td> </tr>
Abstract</td>	2020-08 to 2020-09</td>	Prepare and submit research abstract</td> </tr>
Seminar</td>	2020-09 to 2020-10</td>	Prepare and give seminar on research</td> </tr>
Paper Writing</td>	2020-09 to 2020-10</td>	Prepare and submit paper on research</td> </tr> </tbody> </table> ^{1</sup> Tensors are very similar to matrices of vectors and are typically used to describe mathematical geometric relationships</p> </div> ^{6</sup> Abbott, B. P., R. Abbott, T. D. Abbott, M. R. Abernathy, F. Acernese, K. Ackley, C. Adams, et al. 2016. “Observation of Gravitational Waves from a Binary Black Hole Merger.” Phys. Rev. Lett.</em> 116 (6): 061102. https://doi.org/10.1103/PhysRevLett.116.061102</a>.</p> </div> ^5</sup>“About ‘aLIGO’.” n.d. LIGO Lab: Caltech</em>. https://www.ligo.caltech.edu/page/about-aligo</a>.</p> </div> ^10</sup>Allman, Eric. 2012. “Managing Technical Debt.” Commun. ACM</em> 55 (5): 50–55. https://doi.org/10.1145/2160718.2160733</a>.</p> </div> ^{13</sup> Chu, Q. 2017. “Low-Latency Detection and Localization of Gravitational Waves from Compact Binary Coalescences.”</p> </div>}^14</sup>“GPUGems Chapter 46. Improved Gpu Sorting.” n.d. NVIDIA Developer</em>. NVIDIA. https://developer.nvidia.com/gpugems/GPUGems2/gpugems2_chapter46.html</a>.</p> </div> ^11</sup>Guo, Xiaoyang, Qi Chu, Zhihui Du, and Linqing Went. 2018. “GPU-Optimised Low-Latency Online Search for Gravitational Waves from Binary Coalescences.” In, 2018-:2638–42. EURASIP. https://ieeexplore.ieee.org/document/8553574</a>.</p> </div> ^{9</sup> Hooper, Shaun, Shin Kee Chung, Jing Luan, David Blair, Yanbei Chen, and Linqing Wen. 2012. “Summed Parallel Infinite Impulse Response Filters for Low-Latency Detection of Chirping Gravitational Waves.” Physical Review D - Particles, Fields, Gravitation and Cosmology</em> 86 (2).</p> </div>}^7</sup>“LIGO Detected Gravitational Waves from Black Holes.” n.d. Caltech</em>. https://www.ligo.caltech.edu/detection</a>.</p> </div> ^3</sup>“LIGO Lab: Caltech: MIT.” n.d. Caltech</em>. https://www.ligo.caltech.edu/</a>.</p> </div> ^8</sup>“LIGO Scientific Collaboration.” n.d. LIGO Scientific Collaboration</em>. https://ligo.org/</a>.</p> </div> ^12</sup>Murphy-Hill, E, C Parnin, and A. P Black. 2012. “How We Refactor, and How We Know It.” IEEE Transactions on Software Engineering</em> 38 (1): 5–18. https://ieeexplore.ieee.org/document/6112738</a>.</p> </div> ^15</sup>“OzStar – Supercomputing at Swinburne University of Technology.” n.d. Swinburne University of Technology</em>. https://supercomputing.swin.edu.au/</a>.</p> </div> ^4</sup>“Virgo Detector.” n.d. Virgo</em>. http://www.virgo.infn.it/</a>.</p> </div> ^2</sup>Weisberg, Joel M., Joseph H. Taylor, and Lee A. Fowler. 1981. “Gravitational Waves from an Orbiting Pulsar” 245 (4): 74–83. https://www.jstor.org/stable/24964580</a>.</p> </div> Polymorphic function mapping in C++ 2018-06-08T00:00:00+00:00 In 2016, Jonathan Blow published a video demo for his upcoming (but still unreleased) programming language Jai</a>. In it, he does a demo about how the polymorphic solver in the Jai compiler is much better than the C++ version, using a demo of trying to pass a polymorphic function to another polymorphic function without explicitly stating the type as his proof, stating that it might be possible in C++17.</p> While he is certainly correct that the Jai polymorphic solver is (from the video at least) a lot more powerful than C++'s, as well as significantly better looking (no one likes looking at templates, lets be honest), he's incorrect about not being able to implicitly pass a polymorphic function to another polymorphic function, so long as you use a C++11 compatible compiler.</p> The secret lies with the decltype</code> specifier introduced in C++11</a>. decltype</code> (and auto</code>, also introduced in C++11) allows us to get the type of an object at compile type without having to specify what the type actually is. This is great for polymorphic functions as we suddenly no longer have to specify any types at all, save that which we pass in.</p> So using the same example as Jonathan used, a transformative map, we can actually avoid using any specific type specifiers in our program. I'm going to use std::vector<></code> instead of an array, but the principle is the same.</p> Let's start by having a polymorphic function to print out our arrays, and our polymorphic incrementer. These will form the backbone which we use to solve our types.</p> template </span><</span>typename</span> T> </span>void </span>print_array</span>(std::vector<T> </span>arr</span>) { </span> std::cout </span><< </span>"{ "</span>; </span> </span>for </span>(</span>auto</span> t </span>:</span> arr) </span> std::cout </span><<</span> t </span><< </span>" "</span>; </span> std::cout </span><< </span>"}" </span><<</span> std::endl; </span>} </span> </span>template </span><</span>typename</span> T> </span>auto </span>incr</span>(T </span>x</span>) -> </span>decltype</span>(x</span>+</span>1</span>) { </span> </span>return</span> x </span>+ </span>1</span>; </span>} </span></code></pre> You will notice that while we declare the return type of our incrementer to be auto</code>, we also declare a trailing return type with decltype</code>. This is very similar to what Jonathan attempted, but he tried replacing the auto</code> with just a decltype</code>. In C++11, if you want a type deduced return value, you must state the type of the function to be auto</code> and have a trailing decltype</code> statement (This was relaxed in C++14 to no longer require the trailing decltype</code>, though having the decltype</code> still helps with template deduction on occasion).</p> template </span><</span>typename</span> T, </span>typename</span> F, </span>typename</span> R </span>= </span>typename</span> std::result_of</span><</span>F</span>&&</span>(T</span>&&</span>)>::type</span>> </span>auto </span>map</span>(std::vector<T> </span>arr</span>, F</span>&& </span>f</span>) -> </span>decltype</span>(std::</span>vector</span><R>()) { </span> std::vector<R> </span>out</span>(arr.</span>size</span>()); </span> </span>for </span>(</span>long</span> i </span>= </span>0</span>; i </span><</span> arr.</span>size</span>(); </span>++</span>i) { </span> out[i] </span>= </span>f</span>(arr[i]); </span> } </span> </span>return</span> out; </span>} </span></code></pre> Now we can see our map function. Most likely the first thing that you'd notice is the std::result_of<></code> in the middle of our template declaration. std::result_of<></code></a> is another compile time type declaration resolver. It takes a function and its arguments and evaluates what its return type is. We use F&&(T&&)</code> inside std::result_of<></code> because there are a few quirks with it that we would hit into using F(T)</code>, such as discarding cv-qualifiers and automatically adjusting arrays and function types to pointers. If you're using C++17 and above, std::result_of<></code> no longer exists due to those quirks, and so instead you can use std::invoke_result<F, T>::type</code>, which looks one hell of a lot better.</p> Finally we come to our test function.</p> int </span>main</span>() { </span> std::vector<</span>long</span>> array </span>= </span>{</span>1</span>, </span>2</span>, </span>3</span>, </span>4</span>, </span>5</span>}; </span> </span>print_array</span>(array); </span> </span>print_array</span>(</span>map</span>(array, incr)); </span>} </span></code></pre> And... it fails to compile. The reason why is that the compiler doesn't know the way in which incr</code> will be used inside of the map</code> function, so it can't infer the function type that we are actually passing. Once again, we can solve this by using a decltype</code> to avoid having to use any nasty types:</p> int </span>main</span>() { </span> std::vector<</span>long</span>> array </span>= </span>{</span>1</span>, </span>2</span>, </span>3</span>, </span>4</span>, </span>5</span>}; </span> </span>print_array</span>(array); </span> </span>print_array</span>(</span>map</span>(array, incr<</span>decltype</span>(array)::value_type>)); </span>} </span></code></pre> If that's too ugly for you, you could declare a macro that does it instead:</p> #define </span>poly_map</span>(</span>v</span>, </span>f</span>) </span>map</span>(v, f<</span>decltype</span>(v)::value_type>) </span>int </span>main</span>() { </span> std::vector<</span>long</span>> array </span>= </span>{</span>1</span>, </span>2</span>, </span>3</span>, </span>4</span>, </span>5</span>}; </span> </span>print_array</span>(array); </span> </span>print_array</span>(</span>poly_map</span>(array, incr)); </span>} </span></code></pre> But this compiles and works!</p> ></span> clang++ </span>-std</span>=</span>c++11 </span>template_poly.cpp </span>></span> ./a.out </span>{ </span>1</span> 2 3 4 5 } </span>{ </span>2</span> 3 4 5 6 } </span></code></pre> What's more, this actually works with anything that could be considered a function.</p> It works with normal functions:</p> long </span>long_incr</span>(</span>long </span>x</span>) { </span>return</span> x</span>+</span>1</span>; } </span>int </span>main</span>() { </span> std::vector<</span>long</span>> array </span>= </span>{</span>1</span>, </span>2</span>, </span>3</span>, </span>4</span>, </span>5</span>}; </span> </span>print_array</span>(array); </span> </span>print_array</span>(</span>map</span>(array, long_incr)); </span>} </span></code></pre> ></span> clang++ </span>-std</span>=</span>c++11 </span>template_poly.cpp </span>></span> ./a.out </span>{ </span>1</span> 2 3 4 5 } </span>{ </span>2</span> 3 4 5 6 } </span></code></pre> It works with lambdas:</p> int </span>main</span>() { </span> std::vector<</span>long</span>> array </span>= </span>{</span>1</span>, </span>2</span>, </span>3</span>, </span>4</span>, </span>5</span>}; </span> </span>print_array</span>(array); </span> </span>print_array</span>(</span>map</span>(array, [](</span>long</span> x) { </span>return</span> x</span>+</span>1</span>; })); </span>} </span></code></pre> ></span> clang++ </span>-std</span>=</span>c++11 </span>template_poly.cpp </span>></span> ./a.out </span>{ </span>1</span> 2 3 4 5 } </span>{ </span>2</span> 3 4 5 6 } </span></code></pre> In C++14 you can even replace the long</code> in the lambda declaration with auto</code>, or wrap the polymorphic function so you don't need the poly_map</code> wrap!</p> int </span>main</span>() { </span> std::vector<</span>long</span>> array </span>= </span>{</span>1</span>, </span>2</span>, </span>3</span>, </span>4</span>, </span>5</span>}; </span> </span>print_array</span>(array); </span> </span>print_array</span>(</span>map</span>(array, [](</span>auto</span> x) { </span>return</span> x</span>+</span>1</span>; })); </span>} </span></code></pre> ></span> clang++ </span>-std</span>=</span>c++14 </span>template_poly.cpp </span>></span> ./a.out </span>{ </span>1</span> 2 3 4 5 } </span>{ </span>2</span> 3 4 5 6 } </span></code></pre> It even works with std::bind</code>ed member functions!</p> struct </span>Incr { </span> </span>long </span>incr</span>(</span>long </span>x</span>) { </span>return</span> x</span>+</span>1</span>; } </span>}; </span>int </span>main</span>() { </span> std::vector<</span>long</span>> array </span>= </span>{</span>1</span>, </span>2</span>, </span>3</span>, </span>4</span>, </span>5</span>}; </span> Incr i; </span> </span>print_array</span>(array); </span> </span>print_array</span>(</span>map</span>(array, std::</span>bind</span>(</span>&</span>Incr::incr, </span>&</span>i, std::placeholders::_1))); </span>} </span></code></pre> ></span> clang++ </span>-std</span>=</span>c++11 </span>template_poly.cpp </span>></span> ./a.out </span>{ </span>1</span> 2 3 4 5 } </span>{ </span>2</span> 3 4 5 6 } </span></code></pre> So that's C++11. What does the C++14 or C++17 code look like?</p> // C++14 </span>template </span><</span>typename</span> T, </span>typename</span> F, </span>typename</span> R </span>= </span>typename</span> std::result_of</span><</span>F</span>&&</span>(T</span>&&</span>)>::type</span>> </span>auto </span>map</span>(std::vector<T> </span>arr</span>, F</span>&& </span>f</span>) { </span> std::vector<R> </span>out</span>(arr.</span>size</span>()); </span> </span>for </span>(</span>long</span> i </span>= </span>0</span>; i </span><</span> arr.</span>size</span>(); </span>++</span>i) { </span> out[i] </span>= </span>f</span>(arr[i]); </span> } </span> </span>return</span> out; </span>} </span>// C++17 </span>template </span><</span>typename</span> T, </span>typename</span> F, </span>typename</span> R </span>= </span>typename</span> std::invoke_result<F, T>::type> </span>auto </span>map</span>(std::vector<T> </span>arr</span>, F</span>&& </span>f</span>) { </span> std::vector<R> </span>out</span>(arr.</span>size</span>()); </span> </span>for </span>(</span>long</span> i </span>= </span>0</span>; i </span><</span> arr.</span>size</span>(); </span>++</span>i) { </span> out[i] </span>= </span>f</span>(arr[i]); </span> } </span> </span>return</span> out; </span>} </span> </span>template </span><</span>typename</span> T> </span>auto </span>incr</span>(T </span>x</span>) { </span>return</span> x </span>+ </span>1</span>; } </span> </span>// and also </span>auto</span> incr </span>= </span>[](</span>auto</span> x) { </span>return</span> x </span>+ </span>1</span>; } </span></code></pre> We've lost our trailing return types and we can now use auto</code> for lambda parameters!</p> There's also a fun quirk on g++ that allows for auto</code> to be used as a function parameter, even though you're not supposed to until C++20.</p> auto </span>incr</span>(</span>auto </span>x</span>) { </span>return</span> x </span>+ </span>1</span>; } </span></code></pre> You can find the full code of everything used here on my github</a>.</p> Never underestimate the power of a good template!</p>}}

Tom Almeida

2023 April status update

2023-04-10T00:00:00+00:00

I’ve successfully neglected touching or updating this blog for (I think) close to two years now, almost all of which I have spent working full time as a software engineer. It’s largely been an enjoyable experience, but I think that what I wrote about in “On the enjoyment of work”</a> has largely turned out to be true.

I’ve found that doing a 40-hour job that is effectively just coding has very much dulled my passion for doing anything with code outside of work. You can see this effect in the slow down of my activity on my GitHub account</a>, on the lack of repositories over on SourceHut</a>, and my lack of blogging about anything, as much of this blog’s content thus far has been coding related.

Instead of having coding as a hobby, a number of other activities have effectively replaced it; singing, cycling and rock climbing (more specifically bouldering). I currently cycle around 3-4 hours a week, sing three times a week for a total of around 8 hours a week, and boulder probably around 10 hours a week. These generally function as nice hobbies to have, that generally work my brain to some extent as well (with the arguable exception of cycling), and all improve parts of my health and well-being in various respects.

Since the last time I wrote a post, I’ve also entirely moved cities!

I moved from Perth (my hometown, though not where I was born), to Sydney. My work is based in Sydney, so although it was difficult to leave my family behind it made sense to move - especially with Sydney being a state with day-light savings, which always did my head in when I was in Perth as we did not have day light savings.

I was originally planning to move a few years ago once I got my job, but, as with many other things, the COVID-19 pandemic effectively put a stop to it for two years. It was a relief to finally move and put an end to the limbo-type situation that had occurred whilst I was in Perth, and although Sydney has only been my home for a few months it has certainly started to feel like home.

A few months ago I started on a project to create a cross-platform podcasting application. I made it all the way through to being able to go through feeds, download and play individual episodes before very much slowing down development. For the most part working on this has been good fun - although as noted above I don’t tend to code in my spare time very much anymore, which is of course quite limiting in terms of what I’m able to do. My main motivation was to have a cross-platform RSS/Atom reader and podcast player that I could keep synced and use between all of my devices. Due to my move to Sydney and thinning down of usable devices some of the motivation for this issue has been assuaged, however I think it may still be something useful to have around as an open source project.

An interesting project that is on a similar trajectory is termusic</code></a>.

I started on it in Rust</a>, as that tends to be my preferred language for coding at the moment. A major issue that I’ve run into is trying to integrate it into the “Now Playing” centre that most platforms have (on Apple platforms this is literally called Now Playing</code></a>) - especially on Apple platforms. iOS (and macOS to some extent) require that integration with Apple frameworks is done using Swift, which is a fine language, just one that I’m not at all familiar with. There is a crate called swift-bridge</code></a> which attempts to solve this issue which I’ve had some limited success with (mostly due to my terrible Swift code), but I think I may still be some way off of getting this working reliably.

As I write this, however, I’ve just discovered a Rust crate called Souvlaki</code></a> which handles this for you, so hopefully there will be much quicker progress on this front soon.


I don’t think I’ve previously mentioned my faith on this blog at all, partly because I’m always a little bit leery of saying the wrong thing or misrepresenting a view and alienating people.
This is particularly complicated by the fact that my particular faith (evangelical Christianity) has a tendency to be particularly maligned these days, particularly as the issue of sexual identity has come into such focus in the last few decades.</p>
I mention this for two reasons; one that is coding related, one that is related to this blog.
First, I have been looking into good methods of electronically studying the bible and extra-biblical resources (such as Greek dictionaries, commentaries, historical writings and the like).
This is something that is technically available as an existing application, Logos Bible Software</a>, which actually provides a good value offering for what is being delivered.
I would - however, like a Linux version (despite not currently having a Linux computer), as well as the have the core of the software be free software.
Perhaps there is a system that I could use with something like Calibre</a>, but I’m not familiar enough with it at the moment.
Regardless, its something that has been ticking over in the back of my mind.</p>
Second, I would like to start trying to write down some of my opinions on religious things on this blog, perhaps through doing something like an exegetical study of particular passages.
I’m likely to try to keep away from any controversial or contested issues as I simply do not have the expertise to wade in, but perhaps pointing to people or books that I found helpful on similar subjects may be useful.
This is quite a turn around from my previous position on this (which was effectively “don’t mention or hint it at all), but I think that even if I get things wrong it will be helpful to be able to track how my opinions on these things change over time as I mature as a Christian into the future.
Who knows - it may even be a useful resource to someone else in the future.</p>



Adding dark mode to my blog
2021-03-17T00:00:00+00:00
Being the typical zoomer that I am, dark mode has become an essential component of my digital experience.
Over the many years of late-night gaming and the early onset of myopia from staring at too many screens, the blinding effect of the white backgrounds eventually pushed me into more and more dark-themed applications.
I'm writing this blog post on a dark-themed computer, running a dark-themed terminal emulator running a dark-themed neovim instance.
Even once this post is finished, I'll double check it on my dark-themed browser, before swapping to my dark-themed phone and making sure that things look fine on there.</p>
My love of dark modes has extended into other applications as well.
GitHub has its dark-mode set on by default for me, as does Sourcehut and YouTube.
DuckDuckGo because my primary search engine partly because it gave me easy access to a dark-mode that I could never get working on Google.
I stopped using the Gmail web client last year in favour of terminal-based alternatives partly because I could never get dark-mode to work properly on it.</p>
All of this, and until a little over a week ago, I only had a light theme on my blog.
Scandalous</em>.</p>
The theme that I use for this site (which when I finally publish it will be able to be found here</a>) is based on insipx's Ergo theme</a>, which is in turn based on svbtle</a>.
It's a lovely minimal theme, but unfortunately it only has a light theme.</p>
As mentioned above, there are a number of websites which I use with dark-mode enabled, and surely I could just pick one and do what they do?
Well unfortunately for me (but not unfortunately for this post), most of them require local storage of some form in order to retain your mode between sessions.
Changed computers or browsers?
That's a revision back to the realm of light-mode for you.
Opened up a private browsing window?
Better hope they've somehow tracked you through there before your eyes begin to burn.</p>
Even some of my favourite blogs (such as fasterthanlime</a>) which have a dark-mode use local storage to activate it, and it can extremely</em> temperamental between sessions.</p>
Fortunately I can continue to avoid JavaScript on my website thanks to the @media(prefers-color-scheme)</code></a> feature.
As stated on the MSDN, the prefers-color-scheme</code> media feature can be used to detect if the user has requested a light or dark colour scheme, and allows you to override CSS variables accordingly.</p>
This is actually what Sourcehut does</a> to set its colour scheme, and as such I've based my dark theme on theirs.
I think the blue accent is much more suited to a dark background than red, and vice-versa for a light background.</p>
So, if you are currently seeing this in what looks like dark-mode and would like to see what it looks like in light-mode or vice-versa, it should change to the other dynamically when you change your device theme.
As for me, I'm going to never look at the light theme of my website again, and pray that it never breaks.</p>


On the experience of good audio
2020-12-23T00:00:00+00:00
I recently started listening to music with my Sennheiser 6XXs after around six months of using nothing but earbuds (Sennheiser Momentums and Momentum True Wirelesses).</p>
Now, I love the sound on my earbuds, especially compared to the many other earbuds that I've tried, something about Sennheiser's audio engineering just works particularly well for my musical tastes.
I had found, however, that as time went on I used my earbuds less and less, and was generally more happy to listen to music and podcasts using nothing but the speakers of the device they're playing on.
Part of the reason for this is that my Pixel 5 doesn't have a headphone jack (although I do have wireless earbuds) and my experience of bluetooth audio on my desktop and laptop (regardless of operating system) has left a lot to be desired, so the easiest common ground was just the speakers.</p>
Since I've restarted my use of my Sennheiser 6XXs, I've spent the days doing nothing but listening to music for the sake of the audio experience, which I never really did with the various earbuds.
The songs I'm listening to I have heard before, but with the better audio quality and dynamic range comes a whole new range of experience that I simply didn't have access to before - and its hard to quantify how much better it is.</p>
I think that's part of the reason that "audio quality" is so difficult to sell - it's an almost unquantifiable metric that is both incredibly subjective and extremely expensive.
High quality audio gear sells for thousands of dollars, and the curve of how much more needs to be invested for a substantial difference is such that gear that is "good enough" sells for less than a hundred dollars.
How on earth could you convince anyone that hasn't already invested into audio gear that it is worth it?</p>
I'm certainly going to try to start using my headphones more, and that's also going to involve a level of investment and care from me.
My house gets extremely dusty (especially in the summer) - which is part of the reason that I put my headphones away in the first place - and so I'll have to figure out a way to make using them both easy and largely dust proof.</p>


Moving to zsh
2020-12-06T00:00:00+00:00
I recently transitioned away</a> from the ion</code> shell</a> to zsh</code></a>, and I figured it might be a good idea to float some of the advantages and disadvantages that I've found during this time.</p>
Advantages</h2>

Mostly POSIX compliant.

I'll touch on this more later, but in general the ability have portable scripts that work across systems and shells has been incredibly useful - especially as I expand the number of machines I use and prepare to start working after finishing my masters.
For those wondering, ion</code> is explicitly not POSIX compliant</a>.</li>
I can reclaim the @</code> symbol and not worry as much about quoting ssh</code>.

This is a part of ion</code>'s lack of POSIX compliance, and it claims the @</code> sigil for use in array specific functions and variables</a>.
I've generally found throughout my use of ion</code> that I use array variables much less than I do the @</code> sigil, and getting it back for ssh</code>, git</code> and the like has been a major boon.

(It isn't so much that I'm against arrays per say, just that I'd prefer that it somehow reused a symbol that's already typically used by shells instead of nomming another character)</li>
Its much easier to get setup on new computers.

I've just put Alpine Linux</a> on a Raspberry Pi 2B, and have begun migrating some recurring tasks to its crontab.
Last time I checked, ion</code> still had some issues building on arm-based platforms, so unfortunately I can't quite port my dotfiles</a> to it.
I've also recently completed my masters and will begin working in the middle of January.
Knowing the company that I'm working for, there's a chance that I might be getting one of the new-fangled Apple Silicon Macs, and at the time of writing this post, there are still issues with porting even just the Rust compiler to the new platform.</li>
Completion.

Oh boy this is a big one.
ion</code> "has" completion, in that you can tab complete files and commands.
What it doesn't have - however - is the ability to tab-complete arguments (which can be an absolute life-saver) nor other more specific completions such as man pages.</li>
</ol>
Disadvantages</h2>

Slower start times.

I open a lot</em> of shell prompts - anyone who basically lives in the terminal and incessantly uses tmux</code> does.
Something that I've definitely noticed is that the time it takes to open a new window or prompt is much lower with ion</code> than it is with zsh</code> - and indeed hyperfine backs this up.
An invocation of hyperfine 'zsh -i -c ". ~/.zshrc; exit"'</code> takes around 70ms (with approximately half of that being completion pre-processing), whilst running hyperfine 'ion -i -c "source ~/.config/ion/initrc; exit"'</code> only takes around 20ms.
And that's despite my ion</code> config doing more than zsh</code>'s as well as not being as well optimised.</li>
Visible history completion.

One of my favourite features of ion</code> is that (similar to fish</code>) it shows you the most recent matching command in your prompt.
As of yet, I haven't been able to figure out a way enable a similar behaviour in zsh</code> without loading an extension module, which has me weary due to the potential additional startup latency I might end up with.</li>
</ol>
Conclusions</h2>
I think I'm probably going to stick with zsh</code> until I find a better shell to move to.
Something like mrsh</code></a> seems like a great idea of something to move to eventually, especially as dash</code> will likely never implement any form of completion, whilst imrsh</code> names good completion as one of its goals.</p>
Interestingly, one of ion</code>'s major advertised features - its inbuilt data structures - are actually something that I've found myself rarely using, especially whilst actually at the shell.
I usually find that should a hashmap or the like be required, then that script should probably be converted to a language like Python, even if only for clarity and the rich inbuilt libraries.</p>


Seminar talk
2020-10-07T00:00:00+00:00
Hello, I’m Tom Almeida, and I’m going to be presenting on code
optimization of a gravitational wave detection pipeline a project that
I’ve been working on for the last six months.</p>
But before we actually get into the content of my research, we should
have a quick look at how this report is going to be structured.</p>
I’m going to walk through each of the major areas that my research has
focused on. These are and I promise to expand on what these words
actually mean once I get to them:</p>

N-detector implementation; and</li>
Post-processing complexity analysis</li>
</ul>
Finally, we’ll finish by looking at the platform that this project gives
for future research.</p>
N-detector</h2>
Gravitational Waves</h3>
So let’s begin by looking at some background information what are
gravitational waves?</p>
You may have heard of a little thing called the “general theory of
relativity”, which Albert Einstein published in 1916 as a way to
integrate gravity into the concept of space-time. Gravitational waves
are ‘ripples’ in the fabric of space-time caused by some of the most
powerful processes in the universe - things like colliding black holes,
exploding stars and the birth of the universe are all things that emit
gravitational waves. Their existence was predicted in 1916 as a
derivation of Einstein’s theory of general relativity, which showed that
massive accelerating objects such as orbiting neutron stars or black
holes would disrupt space-time in such a way that waves of distorted
space would radiate from the source.</p>
Detection of gravitational waves is done using interferometers, using
the timing difference between massive lasers to determine if space-time
has been distorted. Now the way that these detectors actually work and
the physics behind all of this isn’t really relevant to my research, so
the most important thing to know about these detectors is that they emit
a lot of data.</p>
Processing Pipelines</h3>
To deal with all this data, processing pipelines were created to sift
through the noise and find the gravitational waves.</p>
One of these is the Summed Parallel Infinite Impulse Response pipeline
(which I’m going to call SPIIR), which uses a combination of IIR filters
(known as a “template”) to approximate gravitational waves. It’s
currently thought to be one of the lowest latency pipelines of those
existing, and is almost fast enough to enable prompt follow-up
observation on gravitational wave events with traditional telescopes.</p>
A major problem with the SPIIR pipeline (and all the other existing
pipelines as well) is that only supports a fixed number of detectors,
and the process of adding extra detectors to be processed is an
incredibly time consuming process. A number of new detectors are coming
online in the next few years, so figuring out a way to do this better is
vital to ensuring that the pipeline can continue to operate.</p>
This is the first part of my project, to allow the pipeline to run with
any number of detectors with minimal change to the codebase.</p>
The power of powers of 2</h3>
Internally, the pipeline uses an array to keep track of which detectors
it is processing, and this array is called the IFOComboMap (which you
can see on the screen). We can think of this map (in its current state)
as being ordered as the following:</p>


All single detectors</p>
</li>

All combinations of two detectors</p>
</li>

All combinations of three detectors</p>
</li>

So on</p>
</li>
</ul>
This gives us a problem when adding new detectors, because let’s say we
add one more detector, then suddenly the indexing would change for more
than half of the combinations!</p>
To solve this problem, we can think about how detectors are used in a
slightly different way. Detectors (as you might be able to tell from the
combination map) are either used or unused and critically the ordering
doesn’t matter. We’re talking about combinations here, and not
permutations. One way to count the number of combinations with \(N\)
objects is to count every number of to \(2^N\).</p>
Let’s use an example. Say we have 5 elements, and we want to represent
every combination of those elements, we can represent it with a binary
number with 5 bits. If I want to have only the first element selected in
my combination, then I can simply flip it from 0 to 1. I can do the same
if I want my combination to be the first and third elements, as well as
the first, third and fifth elements.</p>
We can use this information to make a table that doesn’t change indexing
at all when we add extra elements, by having each index be the number
that would represent that combination if it were a power of two. It
looks like this. And this is what it looks like now that we add
detectors. Much better!</p>
There’s a few extra fun properties that we get from representing our
combination like this. First, we can always tell how many detectors are
being used by checking the number of flipped bits in our combination. We
can do this super efficiently by using the x86 instruction “popcount”,
which should be even faster than a comparison (which you’d have to have
done before). We can also check to see whether a particular detector is
being used by checking to see if the bit corresponding to it has been
flipped.</p>
Making this change was actually relatively modest, with about 400 lines
of code modified. Unfortunately, that’s not quite the end of the game
for letting the pipeline handle any number of detectors!</p>
The hunt for hardcoded detectors</h3>
The pipeline passes around data structures with hardcoded names to each
of its components. Fortunately, because C allows for fixed size arrays
in data structures, this is quite a simple change, but unfortunately
means that everything</em> that references any of these tables needs to
change in order to work with any number of detectors. So all in all,
this ended up being around 1000 lines of code changed.</p>
Unfortunately we don’t have the time to dive into some of the technical
things here about how this change interacts with the pipeline’s Python
or some of the other things, but feel free to come back to it in
question time.</p>
Complexity analysis</h2>
Now we’re going to take a dive into a complexity analysis I did on one
of the components of the pipeline.</p>
We’re going to start with some background information, and then I’ll
talk a bit about why this needed to be done before we get to the
actually juicy things.</p>
Complexity Analysis</h3>
Alright, so now let’s actually have a look at what a complexity analysis
is.</p>
Complexity (or asymptotic) analysis is an analytical approach to
understanding how the performance of an algorithm or data structure
scales (or grows) with the size of its input. As UWA’s very own CITS2200
(which this slide is ripped from) puts it, it allows us to compare
algorithms and observe performance barriers. Complexity analysis of
parallel algorithms is a little different to the sequential algorithms
you may be used to, and so we need to define some terms.</p>
First of all, we can consider a parallel algorithm to be a directed
acyclic graph of sequential work, which we eventually combine to create
some final answer. As our example up there, we have up there the
“mergesort” algorithm and the work to complete each node up to the
final combining node.</p>
The “work” of a parallel algorithm is the same as though we attempted to
execute the entire computation sequentially. So for this example, that
would be \(O(N log N)\) (assuming we drew back enough nodes). We can
find the “work” by summing up all the individual nodes together. A
useful way to think about work is that it is equivalent to running the
entire algorithm with just one processor and thus it would be
sequential.</p>
The “span” of a parallel algorithm is the maximum time taken to complete
any path in the DAG. So for this example, if we follow the path of the
top edge, we can find that the “span” of mergesort would be
\(O(2N) = O(N)\).</p>
Finally, we need to have some way of seeing practically what this means
for us for runtimes. Brent’s theorem is a handy way to combine our work
and span with an actual number of \(P\) processors to turn it into an
actual runtime. I’ve used it in my analysis, but we won’t actually see
it in action, just see the end result.</p>
So why do we care about this complexity analysis?</h3>
Well now that we’ve successfully made it so we can have the SPIIR
pipeline run any number of detectors, we need to figure out what that
means for the speed of SPIIR. Remember that SPIIR is designed to be
low-latency, so if adding too many more detectors slows things down,
then it’ll cause problems later on down the line.</p>
We can see the components that we need to check for problems with extra
detectors by taking another look at this data flow graph, which we can
simplify further to this. Only the components after all the data flow
combines need to be checked to make sure they’ll deal with the extra
detectors fine.</p>
But before we get into the analysis, we need to look at CUDA, and how it
plays with analysing parallel programs.</p>
CUDA</h3>
The SPIIR pipeline uses NVIDIA’s CUDA, a parallel programming interface
for GPU acceleration, and the section of code that I’ll be analysing
today will be using CUDA so its worth taking a quick look at how it
works so we can understand what’s going on.</p>
GPUs lend themselves really well to parallel code, as whilst they have
very little memory per-processing core, they have orders of magnitude
more processing cores than traditional CPUs. This heavy focus on
parallel code results in a slightly different computational model.</p>
In CUDA, each individual sequence of instructions being executed is
called a thread. These threads are partitioned into warps, which are a
group of 32 threads. Warps are the smallest unit of threads that a GPU
can run, and all threads within a warp must execute the same
instructions. Warps are then further organised into thread blocks, which
are run on simultaneous multiprocessors and contain a small amount of
fast memory that can be shared between the threads in the block. The
region of data that is being processed can be further split by
organising blocks into ‘grids’, although grids have no actual relation
to a physical computation unit.</p>
Conceptually speaking, every thread is a node that goes to every block,
that goes to every grid. As such, we can “parallelise” things by
splitting the work into many nodes by using threads, blocks or grids as
our splitting mechanism.</p>
Analysis</h3>
My first job was to figure out how and when all the functions were
called, and by who. To do this, I wrote my own C/C++/CUDA compiler
wrapper to generate a callgraph of which function calls what.</p>
Now that I had my callgraph, I could use the techniques that I used
above to determine what the total asymptotic complexity analysis was.</p>
And this is what I ended up with. I’m sure that we can all stare at
those final results all day and try to make heads and tails of it, but
here’s the important part it turns out that SPIIR’s post-processing
deals with additional detectors kind of badly.</p>
Because we currently use three detectors, the cubic term here means that
we could potentially end up with around a 2.4x slow down of this
component just for adding a detector.</p>
This segues nicely into the future work that can be done to build on
this research.</p>
Future work</h2>
There are several future directions for this research to explore. One
way to counter the potential slow down of adding new detectors is to
simply have extra detectors skip the post-processing step.</p>
This would change the structure of the pipeline from this, to this. So
long as the pipeline is still able to detect gravitational waves with
the remaining detectors, we can use these skipping detectors for
localization that is figuring out where the gravitational wave comes
from. This is already being worked on, and should be ready to go in a
few months time.</p>
Another option is to take a further look at algorithms used in the
post-processing. It may be possible that parallelisation around the
number of detectors may be possible, which could potentially cause a
large speedup, as even dropping from \(D^3\) to \(D^2\) brings the
slowdown from extra detectors down significantly.</p>
Et fin.</h2>
Anyway, that’s about it from me, are there any questions?</p>


The different approaches between `emacs` and `vim` packages
2020-09-30T00:00:00+00:00
I recently tried using emacs</code></a> for the first time in many years (the last time I used emacs</code> was back in early 2017, and I moved to using vim</code> later that year).
Many of my colleagues at my last internship use emacs</code> - there was even an internal minor mode for editing and using many of the internal tools - and a number of friends at university are also emacs</code> evangelists, so I thought that it'd be a good idea to re-acquaint myself with the editor that I left behind.</p>
Long story short - I've decided to stick with neovim</code>.
There's actually a bunch of reasons why (which I can probably go into at a later date), but my brief foray back into the world of emacs</code> showed me an interesting difference in philosophy between emacs</code> and vim</code> packages.</p>
As someone who (of course) wants to use vim</code> bindings in every text editor that I use, I of course installed evil-mode</code>, the vim</code> compatibility layer for emacs</code>.
This went along quite swimmingly until I had to install other packages, all because they all automatically overrode keybinds.</p>
This was a pattern that tended to find throughout my emacs</code> experience.
Packages create their own major or minor mode, and then provide a number of key-binds within that mode to interface with its functionality - which can cause a lot of problems for me when I've remapped a good number of the keys because I don't use a QWERTY keyboard.</p>
It's become like a game for me.
See how many plugins I can find that all try to override the same key-bind.</p>
In my experience, vim</code> packages have the exact opposite approach - although I will fully admit to not using very many packages.
coc.nvim</code></a>, for example, doesn't set any keybinds and instead requires the user to assign their own binds to the functions that it provides.
FZF</a> does exactly the same thing, as does vista.vim</code></a>.</p>
This has actually been really surprising to me, as I would have likely expected the exact opposite.
I often hear emacs</code> talked about as being an "elisp interpreter with an editor attached" - which to me suggests that the primary focus of emacs</code> would be on elisp functions - whereas vim</code>'s major selling point is its excellent keybindings.</p>
I think that if emacs</code> packages had taken a similar approach to what vim</code> packages seem to - that I'd have expected them to take - then I'd almost certainly switch to emacs</code> for the additional flexibility of having the power of lisp at my fingertips.
As it is, however, it would take far too much work every time I install a package for me to want to move.</p>


Tracking myself
2020-09-20T00:00:00+00:00
Partly inspired by Julian Lehr</a>'s quantified self</a>, I'm planning on trying to track myself.
I don't expect that I'll actually start on this for a while, as there are a number of tools I have to figure out before I can properly get into the swing of things, but I figured that it'd be worth writing down my reasons why I want to do this.
In future weeks, I'll cover how I'm building the tools to let me track myself.</p>
I'm generally a pretty privacy-focused person.
Any applications that I use always have telemetry turned off, my social media is basically whisper quiet unless its via private messages, and I even borrowed a laptop from the university so I wouldn't have to use exam software that required root privileges on my own hardware.

Tracking myself - and posting it on this blog like Julian Lehr does - seems to run pretty contrary to all sorts of privacy principles.
So why on earth would I want to do it?</p>
I've always sort of considered myself a numbers guy.
In primary school (in Australia, that's ages 4-12), I was the</em> "math guy" in the class, and had by far the best marks in maths in my school (although I don't think I even made the top quartile in high school), and have always found maths that I can apply to be fun and interesting.
It's part of the reason that I got into programming in the first place.</p>
I'm also generally well convinced by numbers that are put before me in order to inspire some continued positive action.
Watching the numbers on the weights at the gym go up, how good I felt as I ran 5km slightly faster than before, and my weight go down (even if only a bit) has encouraged me to regularly exercise far more than the nebulas "it's good for you" that my parents always told me throughout my teenage years.</p>
As such, I am somewhat convinced that tracking myself - and watching trends for various metrics of how my time is spent - will help me be able to narrow down and improve things that in my life.
Perhaps I can see if I've spent too long on a particular weight at the gym, and should go to the next weight up.
Maybe I can spot transport routes that would be slightly more efficient than what I currently have.
I could even find that I spend half my time doing nothing useful at all, and thus need to come up with strategies to improve productivity.</p>
There's an extent to which doing this is good for my privacy as well.
By tracking myself, I will be able to get a better understanding of what sort of data companies have on me.
My smart-watch (a Garmin VivoActive 4) will probably be used for most of the data, and frankly the amount of data that it can/does have on me is slightly terrifying - especially now that I've gone through what I can get from Garmin's API.
I'll be able to go digging to see what Amazon has on me (Kindle/Audible), what Google has figured out (Android/Google Assistant), and how Spotify could figure me out.
In the process of tracking myself, I'll become more aware of how others can track me too.</p>
In addition, as long as my data isn't too</em> fine-grained, privacy shouldn't be too much of an issue.
I don't plan on writing detailed logs of exactly where I've been - if my house shows up anywhere, then you know that my data collection has gone too far.
I don't even plan on sharing any GPS-type metrics at all, save what city I'm in.</p>
I imagine that it might take me some time to be able to even get the right sort of data for any useful analysis, and whilst I don't really know what I might find out, but I'm excited to see!</p>


The changing scope of my research
2020-09-13T00:00:00+00:00
I started on my Masters research project</a> back in March, and the progress of both the project itself and how I've felt about it since that time has been somewhat interesting.</p>
For some context, the codebase that I've been contributing to as a part of my research is approximately 50 thousand lines of code long, and the PhD thesis that much of my work is based on is 204 pages long (as I've previously mentioned</a>), so even getting a grasp on what</em> exactly research project entailed took quite a long time.</p>
Whilst students do pick their own research projects (and I selected the research team that I joined), the projects themselves are selected by the supervisors and then advertised.
This unfortunately meant that whilst my supervisor had somewhat of a grasp on the project that I had selected, I myself had basically no clue.
I have no background in physics (the most that I've done is high school physics, and definitely nothing to do with gravitational waves), so even understanding how everything fit together to do what it was intended to do was incredibly difficult - and it was made worse by the fact that the codebase has very few comments.</p>
As such, a large part of my time up until now was simply me trying to get up to speed.
I did a complexity analysis of a part of the codebase</a>, with the sole purpose of attempting to understand the small section which that analysis encompassed.
It definitely worked, but as time has continued and I've gotten a better idea of how everything fits together, it turned out that the section of code I analysed actually has little to do with my main part of my research - so all that work was for nothing.</p>
To me, it always felt like the scope of my project was changing, even though in actually that scope never changed.
More files moved into what felt like the scope of my project at exactly the same time other files were suddenly discounted.
I went from expecting my entire project to be in C and CUDA to it being in only Python, and then back again.
Most of this change was because of my understanding of what exactly my project entailed didn't fully mature until I had a full understanding of how everything was put together, and that understanding was vital to figuring out how</em> exactly I was meant to go about solving the problem I was given.</p>
I think that this is likely the case for lots of people in more theoretical research than my more implementation-focused research.
As your understanding of the thing you are researching increases, the more likely it is that things that you may have previously thought important suddenly become irrelevant, and ideas that only seemed to be tangential are suddenly vital - and this seems to be the pattern of any complex long-term project.</p>
I think that this is part of the reason why senior (or at least experienced) software engineers are so coveted.
Whilst they may not be burning many story points</a> for their own managers to see, they have enough experience with the codebase and exposure to different ways to solve problems to be able to make the scope for other people much smaller, and their entire team more efficient because of it.
It's also why there's always an "on-boarding" period for new employees, so they are able to have a rudimentary understanding of the potential scopes of any problems they encounter.</p>
With this in mind, I think there's a few items that I think massively help with preventing the sort of scope creep that I've experienced.
In many ways these are probably just some more common sense general guidelines, and can probably be found in any "programming processes" textbook, but will still be helpful to list here.</p>
Have useful comments and documentation</h3>
The codebase I've been working on has very very</em> few comments, and those that it does have are generally just commenting out old versions of the code.
This means that almost all the sources for how things work need to come from outside the codebase itself, and are usually one of two things - people or papers (as in peer-reviewed papers).</p>
The massive downside to this is that if you want to find out how one very specific part of the codebase works, you either need to have someone who hasn't worked on that part of the code for potentially many years sit down and work through it with you, or you need to trawl one of 50 research papers in the hope that it mentions the specific function that you're looking for (and spoiler alert, chances are that none of them do).
Having no useful comments and no useful documentation means that the process of on-boarding is incredibly time consuming and takes valuable work hours away from people that know the codebase well in order to explain the minutia of the code to the newcomers.</p>
This is something that I've attempted to rectify with my research project - every addition has been commented on in its function and sometimes how/why it works.
My hope is that the next person that needs to work on the same area of code would be able to make use of the work I've already done and not need to retrace my steps, but unfortunately the entire codebase is so massive in comparison to the scope of my work that the chance of any overlap is minute.</p>
Have useful commit messages</h3>
This is another area that definitely needed improving.
Before I began on this research project, commit messages often looked like this:</p>
postcoh.c: fix a bug for output trigger->ifos when the ifos are LV
</span></code></pre>
or</p>
generic_init.sh: change Virgo quality bits with latest suggestion
</span></code></pre>
For the first one, what was the bug?
How does this change fix it?
Or for the second one, what's the "latest suggestion"?
What problem does it solve?</p>
The commit messages that are in the repository are as useful documentation as the comments in the code themselves in many cases.
If you can clearly articulate the reasoning behind changes, the problems that they solve and perhaps possible alternatives, then it makes understanding the progression of the codebase significantly easier - and running git blame</code> actually would return useful information.</p>
When it comes to writing commit messages, I try to follow this excellent blog post on commit messages</a>, which suggests that you should try to use a text body of a commit message whenever possible to explain "what" and "why" the change has been made.
There's also been a push from some of the other members of the research team to follow similar guidelines.
The project goes under an external code review every 1.5 years or so, and being able to clearly show the reasoning for changes is something that helps with the efficiency of that review in addition to helping new team members understand what they're looking at.</p>
Provide early and timely feedback to direct efforts</h3>
One of the reasons why the area of code that I did a complexity analysis on ended up being irrelevant for my project is because I had absolutely no idea what I was being asked to do in my project.
I'd written a project proposal, had talked to my supervisors about doing a complexity analysis, did the complexity analysis, and the only feedback that I got the entire time was "no one has done a complexity analysis for this type of project before, I look forward to the results!".
Whilst this was nice to hear, and the complexity analysis was fun to do, it felt all for naught when I realised that it wasn't really under the purview of my project.
The many hours that I spent pouring over that part of the code, trying to understand every part and running some of my own benchmarks and performance analysis ended up being for something entirely irrelevant.</p>
I don't think that this is entirely the fault of my supervisors - a large part of it also falls on to me for not clarifying what exactly was being asked of me, especially as I didn't really understand how the whole project fit together at the time - but some early feedback to properly direct my efforts into something that was actually relevant would have allowed me to finish my project significantly earlier than it was, and possibly even have time to extend the project.</p>
Conclusion</h3>
I know I've spent the last thousand or so words complaining about things in my research project, but I have genuinely enjoyed my time doing research this year.
The value of good comments and documentation, commit messages and the role of feedback in directing efforts are lessons that I will take onto my future projects and work to ensure that the feeling of massively changing scope in a static project does not happen again to me, nor anyone else.</p>


Rescheduling when I do blog posts
2020-09-01T00:00:00+00:00
It's been almost a full week since my last blog post, and I should probably discuss why.</p>
When I originally restarted this blog, I intended to write one blog post per day</a>.
Barely three weeks later and it seems like I've given up all hope of trying for that trend.</p>
I found, not long after I started, that when I wrote about things that I'd given some thought to, I wrote a lot more words than I thought I would</a>.
Unfortunately, I am limited by my ability to type fast and get my words onto my computer.
This often means that even if I have a fully-formed and planned out idea, it can easily take me 45 minutes to an hour to write.</p>
I'm almost the entire way through my Masters, and the semester truly has gotten back into the swing of things.
I have mid-semester tests coming up, and assignment are beginning to become due.
In addition, my thesis will soon need to be submitted, which means that for me, my time is at a premium.</p>
As such, I'm instead going to move to writing one blog post a week, starting next week on Sunday.
I think this should give me the time to be able to spend on my other assignments and allow me to properly spend the time on these posts.</p>
I should probably say that this one blog post a week isn't due to a lack of ideas - I almost have more ideas written down than I have taken days off writing!
Unfortunately, I just need to put more time into my university work for the moment.</p>


My ideal computer at the moment
2020-08-26T00:00:00+00:00
Chris Siebenmann recently wrote about how is ideal machine isn't in an existing category</a>.
Interestingly, I find myself in the same sort of situation, however with an almost entirely different conclusion.</p>
As I have previously mentioned</a>, I am of the opinion that as the number of machines you try to do work on increases, the ease of synchronization between those machines increases exponentially.
This means that for me, an ideal machine would be easily portable so that it can be used anywhere with minimal effort to transport.
This effectively pushes me into a being left with the options of either a laptop (as in an ultrabook) or a tablet.</p>
Tablets are in an interesting position right now where they are continuously increasing in power and ability, but still lack many of the features that I'd require in a daily driver machine, namely the ability to easily compile code locally, easy access to the terminal and a keyboard-driven UI (tiling window managers truly have gotten the better of me).
Thus, I am left with the sole choice of a laptop.</p>
Now the nitpicking starts, what sort of specs do I want in a laptop?
Well, as you may have picked up from my rant about why esports will never be mainstream</a>, I play CS:GO on a regular basis, and also enjoy casually playing a number of other single-player games such as BioShock and Civilization.
As such, I would quite like to be able to continue playing these games as I use them as my primary source of leisure.</p>
Say what you will about their power, but gaming laptops are both (generally speaking) incredibly heavy and immobile, and very difficult to upgrade.
I have no intention of needing to update my laptop every 1-2 years just so I can upgrade my GPU.
So for me, the option that makes the most sense is a laptop with an external GPU enclosure, so the GPU can be upgraded independently of the rest of the machine.
This would also allow me to dock my machine when I get home and be able to get use out of the high refresh rate monitors that I own - something that would be extremely valuable for gaming.
External GPU enclosures do exist on the market (although they are not widely used), however they are almost all based on Thunderbolt 3.
This leads me to my next problem.</p>
I'd much rather use an AMD-based than an Intel-based CPU, as the current generation of Ryzen-based laptop CPUs run circles around their Intel equivalents.
With the addition of their extra cores, both compiling and gaming would be significantly better on an AMD-based laptop than Intel-based laptop.
This comes with the issue of USB 4 (the equivalent Thunderbolt 3 standard which can be used for external GPU enclosures) only being supported on the next-generation of AMD chips.</p>
Thus my ideal machine doesn't yet exist, but I fully expect that in a year or two it might.</p>


Turns out you can get in contact with me
2020-08-25T00:00:00+00:00
Today's update will be a fair bit shorter than my usual fair (thank goodness!).</p>
I mentioned in this post</a> that there would be no way to contact me easily for feedback and comments.
My belief at the time of writing was that if I wanted to receive emails from an email address related to this domain (e.g. something@tommoa.me</code>), I'd have to purchase a domain email service.</p>
It turns out, I'm wrong about that.
I've been able to setup tom@tommoa.me</a> to send me email, but unfortunately there's been no way (as far as I can tell) for me to be able to send mail back using that address unless I pay for email.
From my hosting provider, it only costs about $2 AUD per month for email (compared to GSuite at $8.50 AUD per month), but I don't want to waste even $2 if it turns out that the email address isn't going to be used.</p>
If I start getting enough email through the address above that it becomes worth it to me to buy purchase the domain, I will, but as my current audience (as far as I'm aware) is a grand total of zero people, it's definitely not worth my money right now.</p>


Automatically updating git submodules using GitHub Actions
2020-08-24T00:00:00+00:00
I know that the mono-repository is in style at the moment, but git</code> submodules are a fantastic (and probably over complicated) tool for being able to store components of a git repository that may need to be kept used, but separate.
For example, you may need to track a specific upstream version of another repository that isn't controlled by you or your organization for use in your repository, or you might want to mix repository visibility or share some code between different repositories that need to be separated.</p>
I personally use submodules in the repositories for a wide variety of uses.
For example, my research project</a> uses a submodule to track the latest version of the codebase that I am modifying so I can write patches to match against those versions.
Another example is my site</a>, which has a bunch of submodules to track various things which get published there, from my resume</a> and my research project, to the theme that I use for both my site and this blog.</p>
I only recently moved to using the same codebase for the theme of my site and blog, which has both made my life easier and caused me a great deal of heartache - and almost all of the heartache came from git</code> submodules.
You see, submodules are tied to a specific commit, and running a command like git submodule update</code> (which you'd think updates a submodule to the latest version) only checks out the submodule to the same commit as what your local repository already has stored.
This makes life a little more difficult - how can I easily update submodules without having to specifically know the remotes, branches or location of all of my submodules?</p>
First, all of the submodules have their remotes and locations (and optionally branches) stored in the .gitmodules</code> file, which can be used to iterate through the submodules and pull down the latest versions.
Another option is using the git submodule foreach</code> command to update the submodules by fetching the remotes and then checking out latest commit, which has the disadvantage submodules not (by default) being checked out branches, and instead is checked out to commits.
Both of these options are obviously not particularly ergonomic to work with, and so git</code> introduced the --remote</code> flag to git submodule update</code> to tell it to update to the branch tracked on the remote instead of the local repository.</p>
Great, so now we know update our submodules to the latest remote commit (huzzah!), but I want to push to one repository and watch the other repositories automatically update to track that commit (instead of requiring me to run a command).
How can we do that?</p>
GitHub Actions to the rescue!
(although unfortunately it won't quite get us all the way there)</p>
GitHub Actions allows you to trigger commands on arbitrary events using the repository_dispatch</code></a> event.
The first step is to create a GitHub Action in our repository that updates submodules for us.</p>
Of course, the simplest way to do this would simply be to recursively clone the repository using GitHub's checkout</code> action, to run git submodule update --remote</code> and then git push</code> the changes back into the repository.
Unfortunately, this doesn't quite work out for two reasons; we won't have write access to the repository and we won't be able to clone private repositories.
We can get around this by passing a personal access token</a> to GitHub's checkout</code> action and telling it that we need to pull submodules recursively.
An example of this action can be found below, and is actually what I use in my site's repo.</p>
name</span>: </span>Update module
</span>on</span>:
</span>  </span>repository_dispatch</span>:
</span>    </span>types</span>: </span>update
</span>jobs</span>:
</span>  </span>update</span>:
</span>    </span>runs-on</span>: </span>ubuntu-latest
</span>    </span>steps</span>:
</span>      - </span>uses</span>: </span>actions/checkout@v2
</span>        </span>with</span>:
</span>          </span>token</span>: </span>${{ secrets.PAT }}
</span>          </span>submodules</span>: </span>recursive
</span>      - </span>name</span>: </span>Update module
</span>        </span>run</span>: </span>|
</span>          git submodule update --init --recursive --checkout -f --remote -- "${{github.event.client_payload.module}}"
</span>          git config --global user.name "GitHub Action"
</span>          git config --global user.email "noreply@github.com"
</span>          git commit -am "deploy: ${{github.event.client_payload.module}} - ${{github.event.client_payload.sha}}"
</span>          git push
</span></code></pre>
The second step is to create the trigger for the repository_dispatch</code> in the submodule repositories themselves.
This can be done using the excellent repository-dispatch action</a> to send the event.
An example of this can be shown below.</p>
name</span>: </span>Dispatch to repo
</span>on</span>: [</span>push</span>, </span>workflow_dispatch</span>]
</span>jobs</span>:
</span>  </span>dispatch</span>:
</span>    </span>runs-on</span>: </span>ubuntu-latest
</span>    </span>strategy</span>:
</span>      </span>matrix</span>:
</span>        </span>repo</span>: [</span>"owner/repo"</span>]
</span>    </span>steps</span>:
</span>      - </span>name</span>: </span>Push to repo
</span>        </span>uses</span>: </span>peter-evans/repository-dispatch@v1
</span>        </span>with</span>:
</span>          </span>token</span>: </span>${{ secrets.PAT }}
</span>          </span>repository</span>: </span>${{ matrix.repo }}
</span>          </span>event-type</span>: </span>update
</span>          </span>client-payload</span>: </span>'{"ref": "${{ github.ref }}", "sha": "${{ github.sha }}", "module": "owner/submodule", "branch": "master"}'
</span></code></pre>
This of course works with submodules that you control, but what about for submodules that you don't control?
Unfortunately there's no way to start an action based on a push in a different repository, nor is there a way to create a webhook that you could use to trigger another action from a repository that you don't control.
As such you are left with two options; to simply run the update action at a frequent interval or to hack together a way to do it with activity email notification and a repository_dispatch</code>.
I know which of the two I'd rather implement in a hurry!</p>


On the enjoyment of work
2020-08-23T00:00:00+00:00
I'm of the opinion that in society, the general attitude towards jobs is that you should "do something that you're passionate about".
If medicine takes your fancy, then take up your stethoscope and get to it.
Does the thought of court put you in a tizzy?
Find a briefcase and start practicing law.
Is graphic design your passion (yes)?
Then grab your wacom tablet and get ready to draw.</p>
This is an attitude that gets taught to kids and is especially pushed throughout high school as teenagers get closer to the end of the secondary education and begin thinking about their adult life.
I remember being told to "picture what I want to be doing in thirty years" and to start taking steps towards doing that when I leave high school.
For me, I this was not exactly great advice - I had no clue what I wanted to pick between music or computer science!
Whilst I eventually decided on doing computer science, I definitely understand the reason why there's so many people doing music, arts or history degrees - its what they've been told to do!
And if there was a high demand for professions in those areas, they would be able to spend their lives doing a job that they loved.
Unfortunately, given the number of people taking the courses and the general lack of capital-creating potential, its unrealistic that all of them would be able to get gainful employment, especially as the expected age of retirement seems to increase.
I don't think that this is necessarily a point against doing the arts as a degree (again, I almost picked music, and my brother is actually studying French Horn), but I think that the wish to be entirely fulfilled by your full-time employment is both dangerous and misinformed.</p>
I've heard of engineering processes being like a four-sided piston several times - you need to have a balancing act between quality, cost, time and scope, and as each of them is moved, the others also need to be readjusted.
I think life is much the same way, there's things that need balancing and we can't have them all going at full steam.
I can't be all in on my work and spending massive amounts of overtime whilst also trying to manage a family, stay in touch with older friends and keep a hobby.
It's entirely unrealistic.</p>
Most workplaces recognise this (or are forced to in Australia by the government) and have a maximum set of hours that you are paid to work - everything else is overtime.
So long as you aren't taking an enormous amount of time to commute to work and aren't continuing to work past your hours, that leaves roughly a third (or a quarter when factoring in eating) of the weekday - plus the weekend - to spend on things which aren't</em> work - family, friends and hobbies.
All of those are great things with which to be fulfilled.</p>
My maternal Grandfather spent working years as a clinical biochemist.
He has long since retired and his "hobby" is now his employment; gardening.
He's become so proficient at caring for plants and identifying native flora that he's become an invaluable member of several parks in helping with botanical management.
Whilst I know that he enjoyed his time as a clinical biochemist, it was not his "be all and end all" to the point where it was where he gained his fulfilment from, instead he got fulfilment from his family, friends and hobbies.</p>
This is much of the same approach that I've taken to music.
My gainful employment will be coming from software development, something that, yes, I enjoy, but that doesn't mean that I'll stop playing music.
Over the course of my time at university, I've continued my involvement in music, and by my own estimation am a significantly better musician now than I was then.
Whilst I am certain that the total improvement is likely not as great as if I had formally studied music, having music as a hobby that I enjoy and can gain fulfilment from without relying on it for my finances is both freeing and adds to my enjoyment of it.</p>
I think that this is the right balance of things.
Even in jobs in which you would be theoretically fulfilled, you can still have things go wrong.
Sudden deadlines, a difficult workmate or an overbearing boss can all make jobs significantly less enjoyable.
If your previously fulfilling work is no longer enjoyable, then what are you enjoying?</p>
Thus my charge to you is this; don't put all your eggs in one basket.
In the end, work is work and should be approached as such.
It is a means to an end, to give you an opportunity to live the other parts of your life and shouldn't be what your entire life is about.
So take up a hobby, spend more time with your family and friends, or start a job that you know you won't enjoy but can use to further one of them.
I'd bet it'd make life more rewarding.</p>
(disclaimer: author is an university student who hasn't ever had to apply this advice in practice and is writing at about 1AM. Take it with ten grains of salt)</p>


Imposter syndrome and improvement
2020-08-22T00:00:00+00:00
I've recently been watching a lot of Daniel Kapadia's</a> (a.k.a. ddk) videos.
For those that don't know, ddk is an ex-Quake professional, who's moved into esports casting with a primary focus on FPS games.
In a (somewhat) recent video of his</a>, he says the following:</p>

...one limiting factor I had was - and I still suffer from this a great deal - and its part of the reason why, in some respects, I've achieved anything in some of the realms that I've worked in is impostor symdrome.
It's been an issue for me.</p>
It's the thing that really makes me work really hard sometimes, but it also is the thing that makes me discount myself from feeling like I'm worth anything or good at what I do in any remote sense.
So that can be a really big issue for me, and it was an issue when I was a player...</p>
</blockquote>
This phrase reminded me of a rule from the "Digital Age" addition of Dale Carnegie's "How to Win Friends and Influence People"; Give Others a Fine Reputation to Live Up To.
In many senses, I think that impostor syndrome is the other side of the coin for "giving others a fine reputation to live up to".</p>
The definition of impostor syndrome is to doubt your accomplishments or talents and to fear being exposed as a fraud.
If you are given a "fine reputation to live up to", especially if its not for something that you've actually done yet (as "How to Win Friends and Influence People in the Digital Age" suggests), then of course you'll have impostor syndrome.
You're being expected to live up to some ideal which you haven't achieved yet, and whilst being treated as though you've already achieved that ideal may be nice, you are - in the literal sense - an impostor.</p>
"How to Win Friends and Influence People in the Digital Age" suggests the following:</p>

Coaches, mentors, leaders, and parents often find that people live up to our expectations of them, no matter how diminished those expectations are.
If a man feels unimportant or disrespected, he will have little motivation for improving himself.
So why not create a vision of him that embodies everything you know he is capable of achieving, as well as everything you don't know about his possibilities?
You will rarely be disappointed...</p>
To change somebody's behaviour, change the level of respect she receives by giving her a fine reputation to live up to.
Act as though the trait you are trying to influence is already one of the person's outstanding characteristics.</p>
</blockquote>
If this isn't a call to the bettering influence of impostor syndrome, I don't know what is!</p>
We must also keep in mind the other component of the quote I've taken from ddk.
Impostor syndrome can cause people to "discount themselves from feeling like they're worth anything or good at what they do in any remote sense." - in other words, it can cause low self-esteem.
So there's certainly some skill to the balancing act of trying to make people live up to the expectation of their better self without massively impacting self-esteem.</p>


Honey, I shrunk the blog!
2020-08-21T00:00:00+00:00
At the time of writing this post, loading the front page of this blog without anything cached takes around 1MB of data.
Compared to the average website page (according to the http archive</a>), this is actually pretty good.
The median page apparently ranks in at around 2MB of data, with about 1MB of that being images, and another half a megabyte of JavaScript.
Even worse, according to the http archive's 2019 page weight reports</a>, 10% of website pages are over 6MB, resulting in requiring at least</em> a second to load the page on many internet connections around the world.</p>
Obviously this blog is no where near as bad, so why have I taken this entry to talk about page size and how I've made this blog smaller?
(Yes that's the topic if you haven't picked it up already.)
Well this blog is almost entirely text, with one image that is used for the header/footer, and some custom fonts.
There is no JavaScript, no videos, some CSS (although not that much locally, only 9KB is CSS that is hosted here), so why on earth is this website checking in at even half of what the "normal" website would be?</p>
Well the answer, as it turns out, is entirely that one image that is used for the header and footer of the website.
The profile image (which I use as my profile picture in most places) is a 2320x2314 JPEG image that takes up 747.8 KB of space.
That's an absolutely whopping three quarters of my entire page, for one image that arguably isn't even needed.
Fortunately, there's ways around this.</p>
The container that my image sits in at the top of my page is a square with a side length of 125 pixels, so this image only actually has to be 125x125 for there to be no noticable change in quality from the original.
The container at the bottom of the page is also a square with a side length of 30 pixel, and as 30 is not a divisor of 125 it makes sense to create an image for that separately so that the image doesn't sub-sample oddly.</p>
The static site generator that I use is called Zola</a>, and has a number of inbuilt functions in its templating.
One such function is the (very handy) resize_image</code> function, which (as you'd expect) resizes an image to be of some particular dimensions.
The function processes an image for you and returns its path, allowing you to keep almost everything unchanged save the loaded image url.</p>
-      <a href="{{config.base_url}}" style="background-image: url({{config.base_url}}/img/{{config.extra.profile}}"></a>
</span>+      <a href="{{config.base_url}}" style="background-image: url({{resize_image(path='../static/img/' ~ config.extra.profile, height=125, width=125, op='fill')}}"></a>
</span></code></pre>
By applying this function, I ended up with images of sizes 4.15KB and 1.21KB for the 125x125 and 30x30 images respectively, a total reduction of 742.4KB.
That's basically a saving of the size of the entire original image, with no discernible change in image quality!</p>
Of course, after this change I was greedy for more gains, and thus began my fight for fonts.</p>
I use a number of fonts on this blog (and on my main website), which are generally downloaded from Google Fonts on demand via CSS.
Raleway is used for the text of front matter (the information for each blog post such as the publishing date, total words and tags), whilst the excellent Montserrat is used for the rest of the text elsewhere.
Whilst I have replaced my Raleway with a combination of Verdana and Geneva</a>, Montserrat will be sticking around as (in my opinion) one of the best looking variable weight sans-serif fonts available.
Thus, my savings with actual fonts was only around 20KB, relatively paltry gains.</p>
 html, body {
</span>     background-color: $background;
</span>-    font-family: 'Montserrat', 'Raleway', sans-serif;
</span>+    font-family: 'Montserrat', 'Verdana', 'Geneva', sans-serif;
</span>     font-weight: 400;
</span> }
</span></code></pre>
 .frontmatter {
</span>     color: $title;
</span>     font-style: bold;
</span>     list-style-type: none;
</span>     font-size: 14px;
</span>-    font-weight: 700;
</span>-    font-family: 'Raleway', sans-serif;
</span>+    font-weight: 500;
</span>+    font-family: 'Verdana', 'Geneva', sans-serif;
</span></code></pre>
My major gains in the fonts department actually came from another place entirely... FontAwesome.
FontAwesome is a fantastic font for using company logos instead of images, which does indeed save a lot of data compared to the size that even one image of a logo would be.
The only problem is that the entire stack of FontAwesome icons that I'd need to get for my little symbols next to my website, GitHub and Atom feeds is around 130KB, which (now that we've shrunk a large portion of the website) accounts for about half of the remaining website.
Fortunately for me, FontAwesome provides SVGs of their icons, which allows me to download them all individually and use them instead in <img></code> tags.
The total size for the three icons individually is a little under 5KB, around 25 times smaller than the entire font.</p>
-  <li><a href="https://{{extra.website}}" target="_blank">website <i class="fab fa-firefox" ></i></a></li>
</span>+  <li><a href="https://{{extra.website}}" target="_blank">website <img class="symbol" src="/symbols/firefox-browser-brands.svg"></img></a></li>
</span></code></pre>
According to Firefox's network tools, I'm now down to 128.2KB, of which my remaining font of Montserrat makes up a solid 70%, so there's clearly still some room for improvement.
Perhaps I'll continue to look for an alternative font to use instead.</p>


The curious case of the disappearing ideas
2020-08-20T00:00:00+00:00
I've taken to setting aside time in evenings to write these entries (and very late in the evenings - its currently 11:40 PM).
This has mostly been fine in terms of my schedule.
I have university during the day, and I also often have other activities such as choir in the early evenings, so the late evening is pretty much the only time that I can write my entries without having it potentially disturbing the rest of my day.</p>
But this has also lead to another thing which has arguably already negatively impacted this blog - I've forgotten almost every idea of what to write by the time I reach my allotted writing time.</p>
Sometimes, I have a good idea in the middle of the day, or something to discuss that I've just done, and either of these would be a good idea to type up as an entry.
But by the time its the evening, after the vast majority of the day has gone and my focus begins to turn to the next day, I find it incredibly difficult to remember the details of my thoughts, the minutia of my activities or the ideas that came to me throughout the day.
Admittedly, this isn't a particularly promising thing to admit at what is effectively the restarting of this blog, but in my opinion it is better that I am aware of this problem (especially as it would be likely to persist if never recognised) and am now able to think of methods to combat it.</p>
One potential idea for me to do away with my structured day and instead to write whenever the ideas come to me.
This is somewhat tempting, because starting to put down ideas when they are fresh often means that the ideas will all be left semi-formed for me to come back to later to fill in.
I could quite easily see (however unlikely) my drafts folder reaching peak capacity, with too many half-formed (and likely duplicated) ideas left strewn around that I am left with the paralysis of too many choices.
The main reason why I wouldn't necessarily want to do this approach, however, is because of the structure that I need for the rest of my life.
I'm currently in the final semester of my Masters, and as I have previously mentioned</a>, I am in the process of writing my thesis.
Writing a thesis is a time consuming process, but I am also taking a full course-load in addition to my thesis, resulting in even more time being dedicated to university.
Thus, I require a large amount of rigid structuring of my day in order to ensure that I am able to get all the work of the semester done (and its arguable that I still don't have enough structure to comfortably make it to the end of semester with full marks).</p>
Another idea is to note down ideas in a journal of sorts, with none of the ideas as fleshed out as they would be (this is arguably just a variation on the above).
I already keep a small Moleskine journal on me to keep track of my tasks for the day, which has often proved invaluable in ensuring I don't forget assessments.
Without modifying my day much, I could quite easily take short notes of my day and my ideas for this blog.
The disadvantage of this approach is simply that I would likely need to provide myself some context for each thought in order for my previous thoughts for each topic to be able to be recanted as I had originally thought.
Even of the topics I have already covered, if I had just written the title in my journal, I doubt that I would have been able to restate all of the points that I have.</p>
Even as I struggle with this, I am lead to be incredibly impressed with the various YouTubers that I see uploading new content on a regular basis.
Whilst it is arguable that some topics practically write themselves (product reviews or political news come to mind), the variety work between those topics needs to be interesting for their existing audience to continue to want to watch it.
I think an example of this is LinusTechTips, who upload six videos a week on their main channel (and even more on their other channels).
Whilst the majority of their content is product reviews or based on technology news, in the last two weeks alone they've included videos about a Chinese x86 chip, a budget build from the jankiest origins, run a "tech support" challenge, done a video on the custom air conditioning in Linus' home, discussed a pyramid-shaped case that was requested and looked at the remaining players in the (arguably dead) sector of mp3 players.
That's an incredibly wide range of topics, all of which appeal to their audience and all of which have an incredibly large number of views, but all entirely original content ideas.
That they have been able to keep up with the insane schedule of new videos, all whilst keeping fresh and original ideas coming over a matter of years is incredibly impressive to me.</p>
I suppose I should hope that I can do the same.</p>


The word count of essays that aren't essays
2020-08-19T00:00:00+00:00
As you (probably) know, I've just restarted this blog, and this is my fifth total entry.
One of my goals for this blog is to try to write one entry every day for as long as I can, with the purpose of creating a habit for me to keep.
My hope is that I am able to turn this blog into somewhat of a diary, a record of things that I've thought about and things that I've done, and as I continue to write, the time that is put aside for writing entries will allow me to think through and articulate ideas and concepts that I have throughout the day.</p>
One of the interesting observations that I have already (especially considering that this is only the fifth day of doing this!) is that I've already written 3270 words (not including this entry) for this blog.
That's almost as much as my research proposal for my Masters' thesis</a> (which clocks in at 3429 words), and about half as many as my final thesis is expected to be.</p>
3270 words in five days seems insane to me, especially considering that a good two-thirds of that was in the last two days alone, and none of these entries has taken me more than perhaps 45 minutes to write.
I've certainly never before had an easy time writing a lot of words, especially in one sitting - regardless of the topic.
My proposal took me close to four weeks to finish, and the complexity analysis that I wrote not long after took me nearly two weeks of straight writing (and I'm still editing it).
So what makes these so different?
I have a few theories.</p>
For one, these essays are written with comparatively little research.
I certainly have</em> done research for them (my entries on contact without social media</a> and esports probably never being mainstream</a> both had some rudimentary research done for them), but compared to a university essay?
It's not even close.
The amount of time that I sank into researching my research proposal does indeed show, whilst I only have 15 references - which seems relatively paltry for a research paper - its proposal on a topic which I had no experience in.
Both papers on gravitational waves and the literature on refactoring are not usually part of my daily reading.
My unfamiliarity with the topics only exacerbates the issue of actually needing to read the papers.
One of my references in my research proposal is a 204 page PhD thesis, upon which my research builds.
Reading 204 pages takes enough time, but considering the mathematics and physics behind gravitational waves was not something I'd seen before, it took even longer for any of the content to actually make sense.
So certainly, the amount of research plays a role.</p>
Another potentially contributing factor is the style of writing.
Most of my university essays are written in a very formal style, and it is important (at least to me) to be as concise as possible whilst wording any given sentence.
Why spend paragraphs trying to explain something that could be explained in a sentence?
(although sometimes you want to spend the paragraphs if the topic being explained may be obscure)
In contrast, the writing in the blog (so far) has been mostly prose.
I sit down in front of my computer with an idea, and I leave 45 minutes later with the equivalent of my thought pattern put into words.
My sentences and word choices aren't as carefully chosen, and my tone is far more casual.
This means that the amount of time that it takes for me to construct any given sentence is scarcely more than the amount of time it takes me to think it, and although I do edit a little before publishing and do roughly plan the order of what will be said, my typing speed whilst writing these posts is almost always approaching full speed.</p>
Regardless of the reasons why (there may be even more that I haven't immediately thought of), I do hope that some of the apparent efficiency with which I've been able to type these words can be translated to my university work.
I have a large number of essays due this semester, with each unit having on average at a little over one essay each and my thesis being due by the end of the semester.
If I could somehow take some of this speed to add to my more formal essays, the coming semester will be significantly easier.</p>


Esports will probably never "go mainstream"
2020-08-18T00:00:00+00:00
This is a topic that has sat on my heart for a very long time.</p>
When I was in my first year of university (2016), the game Overwatch, by Activision Blizzard, was released.
As someone who plays a lot of games, mostly CounterStrike, and enjoyed playing Starcraft II whilst I was in high-school, I immediately hopped on board and played a lot</em> of Overwatch.
When the Overwatch League was announced in November at Blizzcon 2016, I was very hyped.
Finally, esports would have a league that could go mainstream.
Teams would be based out of cities, giving the chance for lots of local fans to arrive.
There was a plan for creating a second and third tier leagues to make sure there was a space for new talent to develop and be discovered, and finally</em> there would be a way to ensure that all the players had enough money to go full time.
And it seemed like a real possibility.</p>
Both traditional sport and esport organisations clearly bought into the hype as well, with the Kraft Group and Stan Kroenke, as well as Cloud9 and Envy purchasing slots in the league for $20 million USD.
Top broadcast talent was moving into Overwatch as well, as Montecristo and Doa (previously best known for League of Legends commentary) and Semmler (from CounterStrike) jumped over to the Overwatch League.
The start of the first season of the Overwatch League in 2018 seemed to be a success as well, with enough viewers to rival CounterStrike's majors, and plenty of exciting games to watch.
But everything seemed to come crashing down over the next few years.</p>
The commissioner of the league, Nate Nanzer, left Blizzard early into season 2</a>, leaving the league without its (arguably) most publicly-facing figure.
This was followed by a large number of other Overwatch League staff leaving as well</a>, as well as a meta (short for "meta-game") known as GOATS, which was so dull that player and viewing numbers dwindled.
There's been a number of reports that teams are all "operating in the red"</a>, and much of the broadcast talent that went to Overwatch left at the start of season 3</a>.</p>
So what went so wrong?</p>

I went back to playing CounterStrike in mid-2018, and have barely looked back since.
There was a brief period in time where I played both Overwatch and CounterStrike at the same, but after the GOATS meta came into full force I lost almost all interest in playing.
I have, on occasion, tried to watch the Overwatch League since then, but have found it increasingly difficult as new characters and mechanics were introduced.
Sigma, Ashe, Baptiste and Echo were all introduced as characters in the short months after I stopped playing, and each time I was bewildered when I saw them.
How did their abilities work, what made them unique, how did they interplay with other characters?
The components of the game that I could only properly understand by playing were slowly falling away with each patch, and every time I tried to watch I'd find it difficult to tell what was going on.</p>
I've found that I have much of the same problem with League of Legends and DOTA, both of which I don't play.
They both have a massive roster of characters (especially in relation to Overwatch), all with at least four unique abilities and interplay with other characters that cannot really be understood unless you have personal experience from playing.
In this sense, I can't be amazed by some element of skill which I can't even grasp.
Was this particular combination of abilities really hard to pull off in tandem?
I have no clue, I don't play this game.
Was the interplay between these two characters such that someone who won really should have lost on paper?
I have no clue, I don't play this game.
Was this particular tactic a mastermind choice that completely ruined any chance that the other team had to win?
I have no clue, I don't play this game.</p>
Traditional sports don't really have this problem - in comparison it's easy to tell if something is difficult.
Watching a player in AFL jump over four other extremely muscular players to snatch a ball out of the air is impressive purely off of the fact that I am human, and I know that I'd have no chance.
Watching soccer players curl shots into the top corner of a goal is impressive purely based on it looking amazing and being a clearly difficult task.
Impressive saves in by goalkeepers boggle the mind with their quick reactions and fast movement, and I would (I think) be able to tell that even if I had never played a game of soccer in my life.
I wouldn't be able to discuss tactics much without either playing myself or watching an inordinate number of games (much like esports), but the barrier to enjoyment and watching apparently spectacular plays is much, much</em> lower.</p>
In addition, the ruleset by which interactions occur between players is much simpler in traditional sports.
I think that the simpleness of a ruleset can be modelled by how easy it to describe the objectives of the game.
Most traditional sports are, at their core, relatively simple: Do some objective more times than someone else.
Soccer - put the ball into the opponent's goal more times than the other team without the ball touching your arms; Basketball - put the ball into the opponent's hoop more times than the other team; NFL - run the ball into the opponent's area more times than they do to you.
These simple end objectives may have some complicating factors - different point systems depending on where you shoot from for basketball or the offside rule in soccer - but even these are simple and intuitive.
Esports, on the other hand, is another beast entirely - try explaining how to win a game of League of Legends to someone without any context.
The lanes and towers and inhibitors before even getting to the base add a layer complexity which is only made worse by the Baron and Dragon (especially now that there are different Dragon types).
This is even further compounded by the skill system, the levels of the characters, the abilities and the concept of a "build".
I can intuitively tell that destroying a tower in one of the lanes gets you closer to winning League, the reason behind Baron or any of the Dragons is a different matter entirely.</p>
Even the (arguably) simplest esport, CounterStrike, suffers this problem to some extent.
It's much more difficult to explain the roles of the Terrorists and Counter-terrorists and the "phases" of the game (pre-plant and post-plant) than it is to explain the basic premise of soccer, even though it is inherently impressive to watch someone land three one-deags, and easy to tell why winning a round with pistols against rifles is impressive.
Whilst it is easy to see the skill in CounterStrike, understanding goals of the game is much more difficult than in traditional sports.</p>
This is a problem that is inherent in video games.
It is difficult to make massively replayable games without some form of guaranteed variation, which in video games comes from additional complexity to the goals of the game.
Would it be nearly as fun to play League of Legends if there were no items and a much smaller roster of characters?
For me, at least, the answer is no (although fans Heroes of the Storm might argue that the answer is yes).
Would it be as fun to play Overwatch if there were no abilities and no characters?
I certainly don't think so, the difference and interplay between the different characters are part of the core reason why the game is fun.
The complexities of the interplay between characters and build selection is part of the reason why these games are so successful, even if it means to a casual audience that any high-level play is unintelligible.</p>
And it's to that casual audience that esports has to appeal if there's any chance of esports "going mainstream".
There will always be more people that don't play a game than those that do play it, and it's that audience that needs to be captured.
How many people do you know that watch some sport and follow their favourite team and yet hardly play that sport?
I'm a rabid Tottenham Hotspurs fan, and I haven't played soccer for years, and there's many others like me.
Of my friends who watch lots of sports, hardly any of them play the actual sport, instead the watching of a sport is a past time to enjoy with friends, whilst at a bar, or eating dinner.
It's a break from real life, and can be followed from afar instead of requiring continual re-learning as new content is introduced.</p>
To this end, I say that esports will never "go mainstream".
The things that make the games fun are contrary to the things that make the games easy to watch casually, and if the game is easy to watch casually but not fun to play, no one will play it anyway.</p>


It's hard to sync more than one machine
2020-08-17T00:00:00+00:00
I've long seen it reported that the sales of desktop machines is decreasing (although workstations are keeping steady or growing), whilst the sales of laptops, tablets (although almost entirely the iPad) and phones have shot through the roof.
Most of the reporting that I've seen has claimed that this is likely due to people not requiring more powerful machines for work or daily tasks - indeed most professions don't require a powerful computer for most work, and with the ubiquity of high performance build servers, even some engineers and programmers don't require the use of a powerful computer.</p>
I think that this is probably part of the reason why, but there's also a bit more to it.</p>
It feels like almost everybody has some form of cloud-based storage these days.
From the previous standard-like Dropbox or Google Drive to the pre-installed iCloud or OneDrive, almost every person that I know has or uses some form of cloud storage - I even have three of them!
My university provides us OneDrive, which I use for storing university-related documents, I have a Google account, which I use for storing lots of personal documents, and I also use Google Photos for storing photos from my phone (and good luck trying to tell me its the same as Google Drive</a>).</p>
All of this feeds into one of the major gripes I have with any primarily cloud-based solution, such as the storage solutions above - synchronization is really really</em> really</strong></em> hard.
I've definitely run out of fingers to count the number of times that I've tried to work locally on a synced document, only to later be told that it had caused a "conflict" with the document because I'd also tried editing it on another machine whilst I was somewhere else.
Countless hours have been spent manually figuring out which of the two or three versions was actually the right one and combining them in various ways, only to figure out days later that I'd chosen the wrong document to keep.</p>
My quest (and probably everyone else's quest as well) to try solve this issue has been long and storied.
I originally started out with a Dropbox account and a dream, before moving to Google Drive after I found out that it had an additional few gigabytes of free storage space.
After moving to Linux (and thus losing access to a native Google Drive client), I began using Syncthing</a> to try to synchronize all my devices.
Unfortunately, none of these ever quite felt right to me whilst I was using both a desktop computer and a laptop, as I'd typically find that the synchronization time would be long enough that (if I'd done enough work recently or left a computer unsynchronized for a few weeks) I could make myself a cup of tea or coffee with time to spare.</p>
This eventually pushed me to my current setup, which is to use git</code> for files that I plan on keeping locally on any machines (with separate private repositories in GitHub for each area of my life) in addition to a Google Drive account that is for strictly online content.
Even this, I've found hard to maintain.</p>
git</code> is fantastic at version control and making sure that multiple people are able to work on different parts of the same project at the same time, but its strength is certainly not in synchronization of documents.
Life using git</code> has been made even more difficult of my own volition, by the fact that a large number of my private repositories automatically deploy to somewhere, such as this blog, or my main site</a> (even my Masters' research</a> and resume</a> are repositories that are automatically built and deployed).
This means that I typically want changes to be somewhat atomic, such that anybody else that sees them would be able to see a coherent document at any point on the commit tree.
This habit has copied over even into repositories that are entirely private (such as my repository for university), resulting in there usually being uncommitted changes at the end of the day, which I refuse to push simply because I don't want to later have to force push.</p>
This means that it is hard for me to do work across my multiple machines at the same time, and I can almost always guarantee that one of them is out of sync, especially as the number of repositories that I have grows.
The major result of this difficulty is that I've spent less and less time on all of my machines, and more and more of it on a single machine that I can do all my work on - my laptop.
After all, even if my desktop computer runs much faster, has a high refresh rate monitor attached and a significantly better keyboard, its far easier for me to just sit at a desk with my laptop and do work instead of trying to spend the time making sure that my desktop is entirely up-to-date - even if I am using git</code> and Google Drive.
Further, the entire problem of synchronization is entirely masked if I only use one machine, as opposed to the Herculean effort that I'd need to put in otherwise.</p>
Now this leads us back to the my statement at the start of this entry that there's more to the "death" of the desktop than the non-requirement of powerful hardware - why have I picked my laptop to do all my work on, especially considering my desktop is technically superior in every way?
The major reason for me is mobility.
Perth is largely out of the COVID-19 pandemic (we haven't had a community infection since around May), and university has started up again, which means that I spend a significant proportion of my time at the university campus taking labs and workshops.
I simply can't take my entire desktop setup with me (as much as I would love to), so I instead spend the majority of my day doing work on my laptop, and once I get home at the end of the day I don't want to spend additional effort making sure that my desktop is up to date so I can do some work on it - and I imagine there's a significant proportion of people in a similar position.
People are often expected to continue doing some form of work out of the office (although I can't necessarily comment on the likelihood of this outside of the programming world, where you're only really called in when something goes horribly wrong in my experience), and as such their single device needs to be portable and thus a laptop, tablet or phone.</p>
So, why is the desktop dying?
Because of requirement of mobility and the difficulty of syncing more than one machine.</p>
(This entry also basically lays out the reasoning for why I think that "cloud storage" such as Google Drive is actually closer to an automated backup system than a synchronization system)</p>


Getting in contact without social media
2020-08-16T00:00:00+00:00
Now that I've restarted (and somewhat revamped - I redid some of the templating) this blog, I'm left pondering a few things about how I set things up and what they actually mean for my own usage.</p>
If you run the very excellent uMatrix</a> or perhaps NoScript</a> in order to prevent JavaScript or media from running without your knowledge, you will have noticed that I have (at the time of writing this) no JavaScript running at all.
There's a fair bit of CSS (mostly fonts and symbols), but nowhere is there any JavaScript.</p>
Another thing which you may (if you're particularly nosy) have noticed is that this blog is hosted on GitHub Pages</a>.
This is great in that I am able to very easily make changes without having to worry too much about deployment (I just write a markdown file and call it a day) as well as in that everything is in source control, but also not great in two very specific ways.</p>

The first of these is that I have no clue how many people will/would/are visiting the blog (or indeed my main site</a>), with very few options as to how to find it out.
One option would be to do the old trick that is used for determining if someone has opened an email -- include an image or css file that is actually a webhook and just increases a counter.
This would actually be achievable using IFTTT</a> and a its "Webhook" connection, and is possibly a project for another day.
Another option would be to introduce something like Google's Analytics (shiver</em>) to track people as they visit.
I'm loathe to voluntarily subject people to more tracking by my own volition, so arguably that's out of the question.</p>
The second problem that I have is that there's no method for interactivity - by which I mean comments.
How can I get feedback on topics on a site in which I have the only ability to add anything and there's no contact details?
Blogs like Chris Siebenmann's</a> or Chris Wellons'</a> have easy methods for feedback, and regularly include responses to comments on previous topics as new entries.
An easy methodology to contact me would also mean that if I should get anything wrong or have issues with understanding some topic, it would be easy for any readers to immediately correct me using that contact method.
This problem is a little more complex than the previous in that I both have methods to solving it and do not wish to use those methods, which is further compounded by the fact that there is no</em> way to get in contact to give me additional suggestions that I might use instead.</p>
One potential solution is to include an email address somewhere for people to send mail to.
My issue with this solution is threefold.
First, I don't know what provider I should put any new mail on, or indeed what the email address should be.
It would be possible to set up a Gmail (or equivalent) account, but I already have what feels like far too many Google accounts.
I could potentially use/pay for mail hosting from a service provider and use this domain to receive email, however that runs into the issue of needing to pay</em>, which the frugal university student in me cannot allow.
Second, I like staying on top of all my email.
I've seen many people with thousands of unread emails, and even the thought of such a scenario occurring fills me with dread.
As this blog (hopefully) becomes more popular, then equally so the amount of engagement would continue, and my paltry attempts to stay on top of all my emails and reply to all those that need replying to become much more difficult.</p>
Another potential solution to this problem would be to direct people to something like Twitter or Facebook, of which Twitter is arguably the better choice for quick feedback.
I do indeed have a Twitter account that has sat dormant for as many days as I have had it, and I firmly intend to keep it that way.
I've seen Twitter and other social media accounts take over people's lives to such a degree that I'm not enthused about dipping my toes in more than I need to (even though this self-imposed limitation probably means that this blog is highly unlikely to ever grow).
Similarly, whilst I do have a Facebook account (which could probably be found with some rudimentary searching), I don't see messages from people that I'm not friends with, and I don't add people as friends on Facebook (or LinkedIn for that matter) that I haven't met in some capacity.
All of this means that to me, at the very least, there's very little opportunity for interaction on any social media platform.</p>
Perhaps there are other solutions that I haven't thought of to these problems, but unfortunately, at least for the time being there is no way of getting any of those solutions to me.
Ah well, a problem for future me to deal with at some point.</p>


Starting this blog again
2020-08-15T00:00:00+00:00
It's been some time since I've actually updated my blog.
Despite trying several times to write more content, the last post I published was from mid-2018, and was written as a 30 minutes commentary on some code that I wrote</a>, so clearly it hasn't been working too well for me.</p>
But things will be (hopefully) changing today.
I'm going to stop trying to write fully-formed content and ideas on my "blog" (which to be honest, no-one actually reads, or at least I don't have any stats on it), and instead start trying to write daily updates on things that I'm doing.
Instead, my main site</a> will be for fully formed ideas.</p>
By necessity, this means that my blog will not be entirely tech-focussed as I had intended many years ago, and instead will just be simply whatever I feel like talking about.
This may mean that this blog could turn into (basically) the equivalent of a Twitter account for me, with random daily thoughts and ideas popping in and out, or it may become a platform for me to practice a more casual style of writing after having written many formal papers throughout university.</p>
Regardless, please do wish me luck as I try to embark on this journey.
I look forward to seeing where (if anywhere) this goes!</p>


OzGrav 2020 Research Proposal
2020-04-20T00:00:00+00:00
Introduction</h1>
Background</h2>
In 1687, Isaac Newton published his book, “Philosophiæ Naturalis
Principia Mathematica</em>”, containing his law of universal gravitation:</p>
\[F = G\dfrac{m_1m_2}{r^2},\]

where \(F\) is the resultant gravitational force, \(G\) is the universal
gravitational constant, \(m\) is the mass of the objects and \(r\) is
the distance between the objects.</p>
It has since been taught in high-schools across the world in
introductory physics classes, due in part to its simplicity and general
accuracy for predicting movement. Despite its general applicability, one
major issue of the theory is that it infers that gravitational is
instantaneously applied, without any apparent method through which it
could be transmitted.</p>
Roughly two centuries later, in 1905, Albert Einstein presented the
theory of special relativity in his paper “Zur Elektrodynamik bewegter
Kö</span>rper</em>” (English: “On the Electrodynamics of Moving
Bodies”</em>). The theory introduced the concept of spacetime</strong> to
describe inertial reference frames as a four-dimensional coordinate
system, \((t, x, y, z)\), where \(t\) is time and \((x, y, z)\) are the
three spatial dimensions. He further stated two important axioms; that
the speed of light in a vacuum is the same for all observers regardless
of motion and that the laws of physics are invariant in all inertial
frames of reference. About ten years later, Albert Einstein incorporated
the effect of gravity with special relativity, forming the general
theory of relativity.</p>
The general theory of relativity postulates that the effect of gravity
can be characterised as each gravitational potential source changing the
curvature of spacetime. The relationship of gravitational mass-energy
and the shape of spacetime is given by Einstein’s field equations:</p>
\[G_{\mu{}v} + \Lambda{}g_{\mu{}v} = \dfrac{8\pi{}G}{c^4}T_{\mu{}v},\]

where \(T_{\mu{}v}\) is the stress-energy tensor1</a></sup>, \(G_{\mu{}v}\) is
the Einstein tensor, \(g_{\mu{}v}\) is the spacetime metric, \(\Lambda\)
is the cosmological constant, \(G\) is the universal gravitational
constant and \(c\) is the speed of light.</p>
An implication of gravity curving spacetime is that massive accelerating
objects would cause ‘ripples’ in fabric of spacetime called
gravitational waves. The existence of gravitational waves remained a
theory until 1974, when Russell Hulse and Joseph Taylor discovered a
binary pair of neutron stars that were orbiting each other. After
several years of measurement, they found that the speed at which the
stars were orbiting each other was slowing in a manner consistent with
the predictions of the general theory of relativity, showing that
gravitational waves did indeed exist 2</a></sup>.</p>
There were several experiments performed in the 1960s and 1970s to
determine methods to detect gravitaional waves, resulting in several
large laser interferometric detectors (that is, detectors that use
interferometry the phenomena by which waves superpose on each other to
create a resultant wave for detection) being built throughout the early
2000s, including the American Laser Interferometric Gravitational-Wave
Observatory (LIGO) 3</a></sup>, the Italian Virgo detector 4</a></sup>, and the German GEO600 detector. The
initial observation runs between 2002 and 2011 by the various detectors
failed to directly detect any gravitational waves, and as such, the
majority of the detectors began work to increase their sensitivity
throughout the 2010s 5</a></sup>. The increase in detector
sensitivity has brought success in the search for gravitational waves,
with the first direct detection occurring on the 14th of September, 2015
6</a></sup>7</a></sup>.</p>
Due to their design, the detectors have a significant amount of noise
from sources that are not gravitational waves, in addition to the
gravitational waves themselves having very weak signals. As such, a
large amount of data processing needs to be done to the outputs produced
by the detectors in order to filter and extract any possible
gravitational waves. These data processors are known as ‘pipelines</em>’,
and are mostly created by research groups that are a part of the LIGO
Scientific Collaboration 8</a></sup>. These
pipelines are used throughout observation runs for real-time data
analysis.</p>
One such pipeline is the Summed Parallel Infinite Impulse Response
(SPIIR) pipeline, created by Shaun Hooper in 2012 9</a></sup>.
The pipeline uses a number of IIR filters which are commonly used in
signal processing for bandpass filtering to approximate possible
gravitational wave signals for detection. The pipeline was further
developed by Qi Chu in 2017, by using GPU acceleration techniques to
increase the speed of analysis, as well implementing a method to use a
frequentist coherent search 10</a></sup>. The pipeline is currently the
fastest of all existing pipelines, and has participated in every
observation run since November 2015, successfully detecting all events
that were seen in more than one detector.</p>
The SPIIR pipeline uses GStreamer, a library for composing, filtering
and moving around signals, in addition to the GStreamer LIGO Algorithm
Library (gstlal</code>). After receiving data from the detectors, the
pipeline performs data conditioning and data whitening, followed by the
usage of the IIR filters. The data is then combined for post-processing,
where events are given sky localization and then inserted into the LIGO
event database 11</a></sup>.</p>
Problem Description & Goal</h2>
As of 2020-04-20, the SPIIR pipeline supports the use of two or three detectors for
gravitational wave searching the two American LIGO detectors and the
Virgo detector. There are several issues with the current pipeline
design that this research project aims to address.</p>
Further detectors are likely to be coming online in the near future,
with old detectors occasionally being removed from detection for
maintainance. For example, the Japanese KAGRA detector is undergoing
testing with the goal of being used in the next observation run, and
LIGO India is currently being installed. With the current design of the
pipeline, adding and removing detectors is a significant undertaking
that takes a substantial amount of development time.</p>
In addition, if a detector is indeed added to SPIIR, the detector
must</strong></em> be used for the coherent post-processing, and can’t be used
just for synchronization purposes. This presents an issue as additional
detectors are added, as each detector has its own sensitivity, reading
variations and range of observable gravitational wave frequencies,
resulting in some detectors being suitable for searching specific
frequency ranges whilst showing no discernable change in output for
other detectors, causing many false negatives.</p>
An ideal architecture for the pipeline would be significantly more
composable, able to add and remove the usage of different detectors for
post-processing with minimal effort.

As such, this research project aims to complete a subsection of this
idealised architecture. The project aims to remove the requirement for
all detectors to be used for coherent post-processing with sky
localization, and instead aims to provide a generic interface that would
allow for any number of detectors to be used for coherent
post-processing, whilst still allowing the unused detectors to undergo
all other parts of the pipeline and remain synchronized with the used
detectors. The project shall explore a number of different possible
codebase refactorings as well as exploring new techniques for
efficiently combining \(N\) data sources for coherent search, and shall
measure the performance impact of the changes using a number of
benchmarks.</p>
Literature Review</h1>
This research project aims to refactor the SPIIR pipeline codebase and
explore techniques for combining some unknown \(N\) number of data
sources for coherent search. Whilst the refactoring part of the project
is somewhat tangential to the aims of the project, looking at the
literature for refactoring will help with the development of the
research methodology. The literature for both refactoring and coherent
search are developing and varied.

Refactoring is defined by Murphy-Hill as the
process of changing the structure of software without changing its
behaviour 12</a></sup>. Of course, this isn’t the only way to modify source code to
address known issues. George Fairbanks offers the options of ignoring,
refactoring or rewriting code as potential methods to deal with problems
in (Fairbanks 2019), and makes several distinctions between the options.
According to Fairbanks, the major difference between refactoring and
rewriting is the process by which the code is modified. When
refactoring, incremental changes are made to the odebase, with the major
goal being to keep the newly written code integrated with the existing
codebase and tests, as the outputs of a module given some inputs should
still remain identical. In contrast, when rewriting, the new code is
written using none of the existing codebase, possibly resulting in
majorly different outputs and possibly even data flow architecture.
Unlike with refactoring, existing tests might not be able to be
leveraged, but it becomes much easier to make sweeping architectural
changes to the codebase.</p>
This still leaves the third option ignoring the issues. Fairbanks points
out that ignoring issues simply means that they will have to be dealt
with at a later date, and contribute to ‘techinical debt</em>’ a term
coined by Ward Cunningham in (Cunningham 1992) to help explain why
otherwise working code may need to be refactored or rewritten, and has
since turned into its own area of academic research, as well as a major
focus of industry. Some examples of activities that “accrue” technical
debt are; a lack of documentation, implementing sub-optimal algorithms
and a lack of testing. Allman notes that technical debt has a
number of similarities to financial debt, in that there can be advantages
and disadvantages to accruing the debt 10</a></sup>. One such advantage, is that
the codebase can be shipped without being entirely complete, and
may indeed reach functional completeness in a shorter time than if the
technical debt was not accrued. Some potential disadvantages, however,
include faults in the system, increased maintainance and extensibility
effort, as well as increased time onboarding new members of staff.</p>
Technical debt, then, is clearly an area that needs to be managed over
the course of a programming project, even when rewriting or refactoring.
(Fairley and Willshire 2017) notes that whilst rewriting or reworking an
existing codebase can reduce or eliminate technical debt, the project
also risks accumulating additional debt if not correctly managed. To
help with management, (Fairley and Willshire 2017) suggests adopting a
development process that includes regularly reviewing expected and
actual progress, whilst Allman encourages regular internal and
external documentation, as well as maintaining an index of prioritised
debts 10</a></sup>.
The SPIIR pipeline uses a group of IIR (infinite impulse response)
filters with time delays to approximate a matched filter. Xiaoyang Guo states
in a 2018 paper that the output of the (i)th IIR filter can be expressed
with the equation:</p>
\[y^i_k = a^i_1y^i_{k-1} + b^i_0x_{k-d_i},\]

where \(a^i_1\) and \(b^i_0\) are coefficients, \(k\) is time in a
discrete form and \(x_{k-d_i}\) denotes input with some time delay
\(d_i\) 11</a></sup>. After summing the output of the filters, the resulting signal
undergoes coherent post-processing to determine the likelihood of an
event having occurred.</p>
Coherent post-processing was introducted in Qi Chu's thesis as an alternative
to coincidence post-processing13</a></sup>. Qi Chu states that the
multi-detector maximum log likelihood ratio to be equal to the coherent
signal to noise ratio \(\rho{}^2_c\), which can be expressed as:</p>
\[\rho^2_c = \underset{max{A_{jk},\theta,t_{c},\alpha,\delta}}{\ln \mathcal{L}_{NW}},\]

where \(A_{jk}\) describes the relative inclination of the detector to
the source, \(\theta\) is the mass of the source, \(\alpha\) and
\(\beta\) are the sky directions of the source and \(\mathcal{L}_{NW}\)
is the network log likelihood network.</p>
Whilst SPIIR’s coherent search currently only supports the use of two or
three detectors, Qi Chu estimates the computational cost of the
coherent search to be:</p>
\[O(2N^3_dN_mN_p),\]

where \(N_d\) is the number of detectors, \(N_m\) is the number of sets
of IIR filters, and \(N_p\) is the number of sky locations13</a></sup>. Xiaoyang Guo
discusses a number of optimizations made to the pipeline,
including in sections of the coherent post-processing, but only reduced
constant factors and not the computational cost of the overall process 11</a></sup>.
As such, as more detectors are introduced, the computational time for
coherent search increases cubically.</p>
An interesting parallel can, however, be made to sorting, a very widely
studied area of computer science. Comparison sorts are known to have a
lower bound of \(\Omega{}(n\log{n})\) number of comparison operations
(Cormen et al., n.d.) which can be increased depending on the
algorithmic inputs, however when implemented on a distributed network,
the number of comparators per thread can be reduced to \(O(\log^2{n})\)
using a sorting network, which uses a fixed set of comparisons on the
order of \(O(n\log^2{n})\) 14</a></sup>. By measuring the total number of
comparitors, it would appear that the distributed algorithm is less efficient,
however GPUGems (14</a></sup>) notes that the distributed algorithm can sort more keys
per second than an optimal \(O(n\log{n})\) algorithm running on a single
thread.</p>
The SPIIR coherent search is distributed on a number of GPUs using CUDA
11</a></sup>, however the computational cost in Qi Chu's thesis is
computed as being on the order of the number of computations, not the
number of computation per thread 13</a></sup>. It is therefore possible that the
computational cost per thread is different to the overall computational
cost, and thus as detectors are added using the existing algorithm, the
growth of the computational runtime may not be cubic.</p>
Methods</h1>
The process for development will follow the suggested method in (Fairley
and Willshire 2017) to minimize technical debt. The gravitational wave
research group at the University of Western Australia meets once a week
to present progress reports and submit the planned progress for the next
week. By tracking the difference between planned progress and the actual
progress each week, the level of technical debt that the project is
incurring can be roughly determined. Another method by which technical
debt can be minimized is through correct testing10</a></sup>. Unit
tests will be created for the coherent search function to determine the
correct outputs using the existing algorithm, and as components are
refactored, the tests will be used to ensure that there are no
regressions. Internal and external documentation shall also be created
and maintained throughout the project as per Allman's paper10</a></sup>, with
internal documentation being comments on the function of code, and
external documentation being the methods stated in the final report.</p>
Development for the new pipeline will be performed on the OzStar cluster
at Swinburne University of Technology 15</a></sup>. The OzStar cluster already
contains a set of sample data to run the pipeline on, as well as the
tools for running the pipeline. As such, all testing will be performed
on the cluster using the existing sample data.</p>
Validation of the correctness of the eventual coherent search algorithm
will be an important factor to show that there are no behavioural
regressions in the course of the project. Validation will be performed
using a copy of the existing codebase and comparing the outputs of the
coherent search function for equivalent inputs. If the new algorithm
raises any false positives or false negatives that were not also seen in
the existing codebase, then it can be stated that the new algorithm is
not correct.</p>
This project will also measure the performance and computational cost
difference between the 2-3 detector specific coherent search function
and the generalised coherent search function. The difference in
computational cost will be measured by an analysis of the average case
of the resulting algorithm and comparing it to the average case of the
original coherent search function. The performance cost will be measured
by determining the runtime of coherent search and comparing it across
equivalent inputs for different sized inputs.</p>
Expected Findings</h1>
There are a number of expected findings from this research. First, it
would be expected that the new coherent search algorithm would replicate
the outputs of the existing search algorithm for the same inputs (i.e.
it is valid as per section 3</a>). Second, it is expected
that no new coherent search algorithm is found, and that the
generalisation of the existing algorithm results in a regression of less
than 5% of the current coherent search runtime.</p>
Proposed timeline</h1>


 Task</strong> </span></th>
 Time</strong> </span></th>
 Description</strong> </span></th>
</thead>


Proposal Writing (Due 2020-04-20)</td>
2020-03 to 2020-04</td>
Write research proposal.</td>
</tr>

Literature Review</td>
2020-04 to 2020-06</td>
Investigate efficient coherent search methods</td>
</tr>

Analyse Existing Codebase</td>
2020-04 to 2020-07</td>
Determine expected inputs and outputs of coherent search methods and determine per-thread computational cost</td>
</tr>

Determine valid unit tests</td>
2020-05</td>
Determine tests that can be used to determine the correctness of coherent search algorithms</td>
</tr>

Oral Progress Report (Due 2020-05-22)</td>
2020-05</td>
Give report detailing progress on research</td>
</tr>

Refactor Existing Codebase</td>
2020-06 to 2020-08</td>
Perform changes on pipeline</td>
</tr>

Validate New Pipeline</td>
2020-08</td>
Compare outputs from changed pipeline to the previous version to ensure there is not a regression of results</td>
</tr>

Measure Performance Differences</td>
2020-08</td>
Determine performance cost of changes</td>
</tr>

Abstract</td>
2020-08 to 2020-09</td>
Prepare and submit research abstract</td>
</tr>

Seminar</td>
2020-09 to 2020-10</td>
Prepare and give seminar on research</td>
</tr>

Paper Writing</td>
2020-09 to 2020-10</td>
Prepare and submit paper on research</td>
</tr>
</tbody>
</table>
^{1</sup>
Tensors are very similar to matrices of vectors and are typically
used to describe mathematical geometric relationships</p>
</div>
^{6</sup>
Abbott, B. P., R. Abbott, T. D. Abbott, M. R. Abernathy, F. Acernese, K.
Ackley, C. Adams, et al. 2016. “Observation of Gravitational Waves from
a Binary Black Hole Merger.” Phys. Rev. Lett.</em> 116 (6): 061102.
https://doi.org/10.1103/PhysRevLett.116.061102</a>.</p>
</div>
^5</sup>“About ‘aLIGO’.” n.d. LIGO Lab: Caltech</em>.
https://www.ligo.caltech.edu/page/about-aligo</a>.</p>
</div>
^10</sup>Allman, Eric. 2012. “Managing Technical Debt.” Commun. ACM</em> 55 (5):
50–55. https://doi.org/10.1145/2160718.2160733</a>.</p>
</div>
^{13</sup>
Chu, Q. 2017. “Low-Latency Detection and Localization of Gravitational
Waves from Compact Binary Coalescences.”</p>
</div>}^14</sup>“GPUGems Chapter 46. Improved Gpu Sorting.” n.d. NVIDIA Developer</em>.
NVIDIA.  https://developer.nvidia.com/gpugems/GPUGems2/gpugems2_chapter46.html</a>.</p>
</div>
^11</sup>Guo, Xiaoyang, Qi Chu, Zhihui Du, and Linqing Went. 2018. “GPU-Optimised
Low-Latency Online Search for Gravitational Waves from Binary
Coalescences.” In, 2018-:2638–42. EURASIP.
https://ieeexplore.ieee.org/document/8553574</a>.</p>
</div>
^{9</sup>
Hooper, Shaun, Shin Kee Chung, Jing Luan, David Blair, Yanbei Chen, and
Linqing Wen. 2012. “Summed Parallel Infinite Impulse Response Filters
for Low-Latency Detection of Chirping Gravitational Waves.” Physical
Review D - Particles, Fields, Gravitation and Cosmology</em> 86 (2).</p>
</div>}^7</sup>“LIGO Detected Gravitational Waves from Black Holes.” n.d. Caltech</em>.
https://www.ligo.caltech.edu/detection</a>.</p>
</div>
^3</sup>“LIGO Lab: Caltech: MIT.” n.d. Caltech</em>. https://www.ligo.caltech.edu/</a>.</p>
</div>
^8</sup>“LIGO Scientific Collaboration.” n.d. LIGO Scientific Collaboration</em>.
https://ligo.org/</a>.</p>
</div>
^12</sup>Murphy-Hill, E, C Parnin, and A. P Black. 2012. “How We Refactor, and
How We Know It.” IEEE Transactions on Software Engineering</em> 38 (1):
5–18. https://ieeexplore.ieee.org/document/6112738</a>.</p>
</div>
^15</sup>“OzStar – Supercomputing at Swinburne University of Technology.” n.d.
Swinburne University of Technology</em>. https://supercomputing.swin.edu.au/</a>.</p>
</div>
^4</sup>“Virgo Detector.” n.d. Virgo</em>. http://www.virgo.infn.it/</a>.</p>
</div>
^2</sup>Weisberg, Joel M., Joseph H. Taylor, and Lee A. Fowler. 1981.
“Gravitational Waves from an Orbiting Pulsar” 245 (4): 74–83.
https://www.jstor.org/stable/24964580</a>.</p>
</div>


Polymorphic function mapping in C++
2018-06-08T00:00:00+00:00
In 2016, Jonathan Blow published a video demo for his upcoming (but still unreleased) programming language Jai</a>. In it, he does a demo about how the polymorphic solver in the Jai compiler is much better than the C++ version, using a demo of trying to pass a polymorphic function to another polymorphic function without explicitly stating the type as his proof, stating that it might be possible in C++17.</p>
While he is certainly correct that the Jai polymorphic solver is (from the video at least) a lot more powerful than C++'s, as well as significantly better looking (no one likes looking at templates, lets be honest), he's incorrect about not being able to implicitly pass a polymorphic function to another polymorphic function, so long as you use a C++11 compatible compiler.</p>
The secret lies with the decltype</code> specifier introduced in C++11</a>. decltype</code> (and auto</code>, also introduced in C++11) allows us to get the type of an object at compile type without having to specify what the type actually is. This is great for polymorphic functions as we suddenly no longer have to specify any types at all, save that which we pass in.</p>
So using the same example as Jonathan used, a transformative map, we can actually avoid using any specific type specifiers in our program. I'm going to use std::vector<></code> instead of an array, but the principle is the same.</p>
Let's start by having a polymorphic function to print out our arrays, and our polymorphic incrementer. These will form the backbone which we use to solve our types.</p>
template </span><</span>typename</span> T>
</span>void </span>print_array</span>(std::vector<T> </span>arr</span>) {
</span>    std::cout </span><< </span>"{ "</span>;
</span>    </span>for </span>(</span>auto</span> t </span>:</span> arr)
</span>        std::cout </span><<</span> t </span><< </span>" "</span>;
</span>    std::cout </span><< </span>"}" </span><<</span> std::endl;
</span>}
</span>
</span>template </span><</span>typename</span> T>
</span>auto </span>incr</span>(T </span>x</span>) -> </span>decltype</span>(x</span>+</span>1</span>) {
</span>    </span>return</span> x </span>+ </span>1</span>;
</span>}
</span></code></pre>
You will notice that while we declare the return type of our incrementer to be auto</code>, we also declare a trailing return type with decltype</code>. This is very similar to what Jonathan attempted, but he tried replacing the auto</code> with just a decltype</code>. In C++11, if you want a type deduced return value, you must state the type of the function to be auto</code> and have a trailing decltype</code> statement (This was relaxed in C++14 to no longer require the trailing decltype</code>, though having the decltype</code> still helps with template deduction on occasion).</p>
template </span><</span>typename</span> T, </span>typename</span> F, </span>typename</span> R </span>= </span>typename</span> std::result_of</span><</span>F</span>&&</span>(T</span>&&</span>)>::type</span>>
</span>auto </span>map</span>(std::vector<T> </span>arr</span>, F</span>&& </span>f</span>) -> </span>decltype</span>(std::</span>vector</span><R>()) {
</span>    std::vector<R> </span>out</span>(arr.</span>size</span>());
</span>    </span>for </span>(</span>long</span> i </span>= </span>0</span>; i </span><</span> arr.</span>size</span>(); </span>++</span>i) {
</span>            out[i] </span>= </span>f</span>(arr[i]);
</span>    }
</span>    </span>return</span> out;
</span>}
</span></code></pre>
Now we can see our map function. Most likely the first thing that you'd notice is the std::result_of<></code> in the middle of our template declaration. std::result_of<></code></a> is another compile time type declaration resolver. It takes a function and its arguments and evaluates what its return type is. We use F&&(T&&)</code> inside std::result_of<></code> because there are a few quirks with it that we would hit into using F(T)</code>, such as discarding cv-qualifiers and automatically adjusting arrays and function types to pointers. If you're using C++17 and above, std::result_of<></code> no longer exists due to those quirks, and so instead you can use std::invoke_result<F, T>::type</code>, which looks one hell of a lot better.</p>
Finally we come to our test function.</p>
int </span>main</span>() {
</span>    std::vector<</span>long</span>> array </span>= </span>{</span>1</span>, </span>2</span>, </span>3</span>, </span>4</span>, </span>5</span>};
</span>    </span>print_array</span>(array);
</span>    </span>print_array</span>(</span>map</span>(array, incr));
</span>}
</span></code></pre>
And... it fails to compile. The reason why is that the compiler doesn't know the way in which incr</code> will be used inside of the map</code> function, so it can't infer the function type that we are actually passing. Once again, we can solve this by using a decltype</code> to avoid having to use any nasty types:</p>
int </span>main</span>() {
</span>    std::vector<</span>long</span>> array </span>= </span>{</span>1</span>, </span>2</span>, </span>3</span>, </span>4</span>, </span>5</span>};
</span>    </span>print_array</span>(array);
</span>    </span>print_array</span>(</span>map</span>(array, incr<</span>decltype</span>(array)::value_type>));
</span>}
</span></code></pre>
If that's too ugly for you, you could declare a macro that does it instead:</p>
#define </span>poly_map</span>(</span>v</span>, </span>f</span>) </span>map</span>(v, f<</span>decltype</span>(v)::value_type>)
</span>int </span>main</span>() {
</span>    std::vector<</span>long</span>> array </span>= </span>{</span>1</span>, </span>2</span>, </span>3</span>, </span>4</span>, </span>5</span>};
</span>    </span>print_array</span>(array);
</span>    </span>print_array</span>(</span>poly_map</span>(array, incr));
</span>}
</span></code></pre>
But this compiles and works!</p>
></span> clang++ </span>-std</span>=</span>c++11 </span>template_poly.cpp
</span>></span> ./a.out
</span>{ </span>1</span> 2 3 4 5 }
</span>{ </span>2</span> 3 4 5 6 }
</span></code></pre>
What's more, this actually works with anything that could be considered a function.</p>
It works with normal functions:</p>
long </span>long_incr</span>(</span>long </span>x</span>) { </span>return</span> x</span>+</span>1</span>; }
</span>int </span>main</span>() {
</span>    std::vector<</span>long</span>> array </span>= </span>{</span>1</span>, </span>2</span>, </span>3</span>, </span>4</span>, </span>5</span>};
</span>    </span>print_array</span>(array);
</span>    </span>print_array</span>(</span>map</span>(array, long_incr));
</span>}
</span></code></pre>
></span> clang++ </span>-std</span>=</span>c++11 </span>template_poly.cpp
</span>></span> ./a.out
</span>{ </span>1</span> 2 3 4 5 }
</span>{ </span>2</span> 3 4 5 6 }
</span></code></pre>
It works with lambdas:</p>
int </span>main</span>() {
</span>    std::vector<</span>long</span>> array </span>= </span>{</span>1</span>, </span>2</span>, </span>3</span>, </span>4</span>, </span>5</span>};
</span>    </span>print_array</span>(array);
</span>    </span>print_array</span>(</span>map</span>(array, [](</span>long</span> x) { </span>return</span> x</span>+</span>1</span>; }));
</span>}
</span></code></pre>
></span> clang++ </span>-std</span>=</span>c++11 </span>template_poly.cpp
</span>></span> ./a.out
</span>{ </span>1</span> 2 3 4 5 }
</span>{ </span>2</span> 3 4 5 6 }
</span></code></pre>
In C++14 you can even replace the long</code> in the lambda declaration with auto</code>, or wrap the polymorphic function so you don't need the poly_map</code> wrap!</p>
int </span>main</span>() {
</span>    std::vector<</span>long</span>> array </span>= </span>{</span>1</span>, </span>2</span>, </span>3</span>, </span>4</span>, </span>5</span>};
</span>    </span>print_array</span>(array);
</span>    </span>print_array</span>(</span>map</span>(array, [](</span>auto</span> x) { </span>return</span> x</span>+</span>1</span>; }));
</span>}
</span></code></pre>
></span> clang++ </span>-std</span>=</span>c++14 </span>template_poly.cpp
</span>></span> ./a.out
</span>{ </span>1</span> 2 3 4 5 }
</span>{ </span>2</span> 3 4 5 6 }
</span></code></pre>
It even works with std::bind</code>ed member functions!</p>
struct </span>Incr {
</span>    </span>long </span>incr</span>(</span>long </span>x</span>) { </span>return</span> x</span>+</span>1</span>; }
</span>};
</span>int </span>main</span>() {
</span>    std::vector<</span>long</span>> array </span>= </span>{</span>1</span>, </span>2</span>, </span>3</span>, </span>4</span>, </span>5</span>};
</span>    Incr i;
</span>    </span>print_array</span>(array);
</span>    </span>print_array</span>(</span>map</span>(array, std::</span>bind</span>(</span>&</span>Incr::incr, </span>&</span>i, std::placeholders::_1)));
</span>}
</span></code></pre>
></span> clang++ </span>-std</span>=</span>c++11 </span>template_poly.cpp
</span>></span> ./a.out
</span>{ </span>1</span> 2 3 4 5 }
</span>{ </span>2</span> 3 4 5 6 }
</span></code></pre>
So that's C++11. What does the C++14 or C++17 code look like?</p>
// C++14
</span>template </span><</span>typename</span> T, </span>typename</span> F, </span>typename</span> R </span>= </span>typename</span> std::result_of</span><</span>F</span>&&</span>(T</span>&&</span>)>::type</span>>
</span>auto </span>map</span>(std::vector<T> </span>arr</span>, F</span>&& </span>f</span>) {
</span>    std::vector<R> </span>out</span>(arr.</span>size</span>());
</span>    </span>for </span>(</span>long</span> i </span>= </span>0</span>; i </span><</span> arr.</span>size</span>(); </span>++</span>i) {
</span>            out[i] </span>= </span>f</span>(arr[i]);
</span>    }
</span>    </span>return</span> out;
</span>}
</span>// C++17
</span>template </span><</span>typename</span> T, </span>typename</span> F, </span>typename</span> R </span>= </span>typename</span> std::invoke_result<F, T>::type>
</span>auto </span>map</span>(std::vector<T> </span>arr</span>, F</span>&& </span>f</span>) {
</span>    std::vector<R> </span>out</span>(arr.</span>size</span>());
</span>    </span>for </span>(</span>long</span> i </span>= </span>0</span>; i </span><</span> arr.</span>size</span>(); </span>++</span>i) {
</span>            out[i] </span>= </span>f</span>(arr[i]);
</span>    }
</span>    </span>return</span> out;
</span>}
</span>
</span>template </span><</span>typename</span> T>
</span>auto </span>incr</span>(T </span>x</span>) { </span>return</span> x </span>+ </span>1</span>; }
</span>
</span>// and also
</span>auto</span> incr </span>= </span>[](</span>auto</span> x) { </span>return</span> x </span>+ </span>1</span>; }
</span></code></pre>
We've lost our trailing return types and we can now use auto</code> for lambda parameters!</p>
There's also a fun quirk on g++ that allows for auto</code> to be used as a function parameter, even though you're not supposed to until C++20.</p>
auto </span>incr</span>(</span>auto </span>x</span>) { </span>return</span> x </span>+ </span>1</span>; }
</span></code></pre>
You can find the full code of everything used here on my github</a>.</p>
Never underestimate the power of a good template!</p>}}

Tom Almeida

2023 April status update

Adding dark mode to my blog

On the experience of good audio

Moving to zsh

Seminar talk

N-detector</h2>

Et fin.</h2> Anyway, that’s about it from me, are there any questions?</p>

The different approaches between `emacs` and `vim` packages

Tracking myself

The changing scope of my research

Rescheduling when I do blog posts

My ideal computer at the moment

Turns out you can get in contact with me

Automatically updating git submodules using GitHub Actions

On the enjoyment of work

Imposter syndrome and improvement

Honey, I shrunk the blog!

The curious case of the disappearing ideas

The word count of essays that aren't essays

Esports will probably never "go mainstream"

It's hard to sync more than one machine

Getting in contact without social media

Starting this blog again

OzGrav 2020 Research Proposal

Introduction</h1>

Polymorphic function mapping in C++

Et fin.</h2>
Anyway, that’s about it from me, are there any questions?</p>