Amanjeev Sethi

Banality of Grief (Poem)

2024-02-09T00:00:00+00:00

Banality of Grief</h2>
Hold the opposing truths, gently
in your gaze
you may sound obvious
but it is real
for you
You may feel small
but isn’t it weighing
on you?
You must speak
cry even
The banality of your Grief
that you think, is in your mind
You may weep
even shout
but you must say
the obvious out loud</p>

Some notes on OpenWrt

2023-12-16T00:00:00+00:00

What is OpenWrt</a>?</h2>
I pronounce it as "Open Wart" but I digress and the notes haven't even begun. It is a Linux(-based), open source operating system for embedded devices but it's most use if found in your routers. If you want your router to have an open source and free operating system, this is a decent bet.</p>
To download firmware for your device/architecture go to OpenWrt Firmware download page and try to find your device</a>.</p>

Architectures and devices</h3>
OpenWrt is open to adding new devices. Check how to add new device page</a> for details. If you want to go that route, maybe check if your device is already supported by going to "Table of Hardware" support page</a>. This is also available as an archive to download and grep locally.</p>

Packages</h3>
OpenWrt also has a package ecosystem</a>. So, you can package your own application for the OS. In fact, the UI (Web based) called Luci is a package itself that you can install once you have the OS up and running. The packages are divided into many categories</a> and creating a new package means you should choose one of those categories and likely sub-categories.</p>
You can install packages using the `opkg</code> installation tool from the commandline. You will need to SSH into the router/device after installing the OS.</p>`

Rust and OpenWrt</h2>

This is new! Starting OpenWrt version 23.05 you have native Rust package support</a>. This can make life easier if you want to create a simple Rust package for OpenWrt.</p>
For me, my application was far more complex than what the OpenWrt Rust support toolchain can handle right now because we bundle some web artifacts etc. So, in my case it was easier to find the architecture and compile my binary for that using Nix</a>.</p>
You can find a few things by running these commands for your router -</p>
uname -a</code></h3>
Shows you system information in brief. For example,</p>
root@OpenWrt:~# uname -a
</span>Linux OpenWrt 5.14.171 # 21:05:12 2023 armv7l GNU/Linux
</span></code></pre>
lscpu</code></h3>
This will show you architecture in detail. For example,</p>
root@OpenWrt:~# lscpu
</span>Architecture:           armv7l
</span>  Byte Order:           Little Endian
</span>CPU(s):                 2
</span>  On-line CPU(s) list:  0,1
</span>Vendor ID:              ARM
</span>  Model name:           Cortex-A9
</span>    Model:              1
</span>    Thread(s) per core: 1
</span>    Core(s) per socket: 2
</span>    Socket(s):          1
</span></code></pre>
The important part is that you can also get the Model name (Cortex-A9) which maybe needed to choose the right architecture.</p>
ldd --version</code></h3>
This will tell you which base library your system is using. For example, the following uses musl</code>,</p>
root@OpenWrt:~# ldd --version
</span>musl libc (armhf)
</span>Version 1.2.3
</span>Dynamic Program Loader
</span>Usage: ldd [options] [--] pathname
</span></code></pre>
Create a package for OpenWrt</h2>
I should begin by saying that in this exercise, you need a lot of GNU Make knowledge. The hell of Make will be enough for you to say no to creating OpenWrt package. However, let's look at a few things I learned during this "simple" exercise.</p>
Easy way out is to build binary yourself</h3>
If you know the architectures you want to support and can publish the package yourself, you can avoid the entire drama and just host things yourself. Honestly, it was far easier to do that especially if you have a complex build process. Which brings the next point.</p>
Quick before the next point, the .ipk</code> file is just a tar.gz</code>. So, you can unpack some existing package and see what kind of files are inside. It kinda feels like debian based structure but I could be wrong.</p>
The packaging process is a nightmare</h3>
You can try and follow their tutorial for packaging on their Wiki</a>.</p>
If you want to package it using their Make stuff, you will end up having more architectural support but it is a nightmare and not even like the Halloween kind where you get the candy.</p>
No really, look at this makefile -</p>
include $(</span>TOPDIR</span>)</span>/rules.mk
</span> 
</span>PKG_NAME</span>:=</span>bridge
</span>PKG_VERSION</span>:=</span>1.0.6
</span>PKG_RELEASE</span>:=</span>1
</span> 
</span>PKG_BUILD_DIR</span>:=</span>$(</span>BUILD_DIR</span>)</span>/bridge-utils-</span>$(</span>PKG_VERSION</span>)
</span>PKG_SOURCE</span>:=</span>bridge-utils-</span>$(</span>PKG_VERSION</span>)</span>.tar.gz
</span>PKG_SOURCE_URL</span>:=</span>@SF/bridge
</span>PKG_HASH</span>:=</span>9b7dc52656f5cbec846a7ba3299f73bd
</span> 
</span>include $(</span>INCLUDE_DIR</span>)</span>/package.mk
</span> 
</span>define</span> Package/bridge
</span>  SECTION:=base
</span>  CATEGORY:=Network
</span>  TITLE:=Ethernet bridging configuration utility
</span>  #DESCRIPTION:=This variable is obsolete. use the Package/name/description define instead!
</span>  URL:=http://bridge.sourceforge.net/
</span>endef
</span> 
</span>define</span> Package/bridge/description
</span> Ethernet bridging configuration utility
</span> Manage ethernet bridging; a way to connect networks together to
</span> form a larger network.
</span>endef
</span> 
</span>define</span> Build/Configure
</span>  $(call Build/Configure/Default,--with-linux-headers=$(LINUX_DIR))
</span>endef
</span> 
</span>define</span> Package/bridge/install
</span>        $(INSTALL_DIR) $(1)/usr/sbin
</span>        $(INSTALL_BIN) $(PKG_BUILD_DIR)/brctl/brctl $(1)/usr/sbin/
</span>endef
</span> 
</span>$(</span>eval </span>$(</span>call </span>BuildPackage</span>,bridge</span>))
</span></code></pre>
This reminds me of the CMake hell of NCBI C++ Toolkit</a>. You can see there is a configuration file to configure CMake first.</p>



(In)secure C++ Training with Patricia Aas
2023-11-23T00:00:00+00:00
A few weeks ago I had the privilege of attending the security training (using C++) by Patricia Aas</a>. This was also the only training she ever did in the North American timezone and that was such a fortunate thing for me. This was such a fun experience and I want to give you a bit of detail on what you can expect from this training.</p>
Basic structure</h2>
This is an intense course, but it is also a lot of fun. As a trainer myself, I am just in sheer awe of Patricia. This was 4 (four) days of 8 (eight) hours each day. You do get an hour of break in the middle but I can tell you this is still a lot of work for the trainer. Apart from that, there is a healthy variety of theory (including history) with practical exercises.</p>
Highlights (for me)</h2>
Material</h3>
I have always wanted to get hands-on security courses from the vantage of reverse-engineering, fuzzing, shellcode, and learn about the tooling around it. All of that was covered.</p>
Slides</h3>
I give extra mention for slides because Patricia’s slide-deck is so beautiful. You can get some idea of what to expect by visiting her website</a>.</p>
Exercises</h3>
There are a plenty of exercises and hands-on work. You even get to do your own fuzzing, you learn about heartbless</del> heartbleed as an exercises! I am going to setup my own fuzzing lab at home.</p>
Is it for you?</h2>
In my group, there were seasoned security and reverse-engineering folks. There were also total beginners like me. Seldom is a course where people from both ends of the spectrum of knowledge can get so much out of. I can assure you that no matter where you are, this course will be fun and educational for you.</p>


Publications
2023-09-13T00:00:00+00:00
These are some of my writings published elsewhere. They are posted here in reverse-chronological order.</p>
Articles</h2>

A cheatsheet for some potentially confusing terms in Rust</a> - March 09, 2023</li>
The bindgen</code> project update</a> - March 06, 2023</li>
The CanDIGv2 Authentication and Authorization Stack</a> - April 13, 2021</li>
CanDIG’s input on CINECA blog post "Integration of new cohort infrastructures to the ELIXIR AAI</a>" - January 07, 2020</li>
A Gentle Introduction to Federated and Distributed Authorization</a> - March 04, 2020</li>
The Rustc Dev Guide Working Group - An Introduction</a> - October 28, 2019</li>
</ul>
Research papers</h2>

CanDIG: Federated network across Canada for multi-omic and health data discovery and analysis</a> - 10 November, 2021 (co-author)</li>
CanDIG: Secure Federated Genomic Queries and Analyses Across Jurisdictions</a> -  March 31, 2021 (co-author)</li>
ClinVar: public archive of interpretations of clinically relevant variants</a> - November 17, 2015 (contributor)</li>
</ul>


How to fail at STM32L433RC board with Embassy Rust embedded framework
2022-12-16T00:00:00+00:00
This blog post is about failures that ate two days of my time with STM32L433RC board with Rust.  I gave up many times and still not entirely back from the land of given ups</em>.</p>
The story starts when I got this beautiful board</a> to try out some Rust.  I am still learning embedded systems so even though I know some Rust, I struggle with the hardware part.  Datasheets for the hardware I use are really cool to read but they are hard for me to translate to Rust many times.</p>
</p>
Before we go further -</p>

the poopy code for this post is here</a></li>
the board is STM32L433RC</a></li>
</ul>
List of my failure modes</h1>
Not knowing where to begin with Rust embedded</h2>
This is a classic!  That is, when I am excited about tinkering with hardware and no clue where to begin.  There are a ton of frameworks!  Friends' and experts' suggestion point to the latest Rust frameworks and libraries and sometimes it gets daunting.  I was pointed to Embassy</a>.  The cool part about this framework is that it is ground up support for Rust's async/await</code> in embedded world.  This async/await</code> style of programming allows for better resource allocation when there are IO blocking and wait times.</p>
Anyway, Embassy docs explain about what is async/await</code></a> here.</p>
Dropping the framework midway and jumping to another</h2>
I made this another classic mistake.  I went down rabbit holes and lost track of how many projects</em> I had created.</p>
Not looking at the examples in the framework</h2>
Yes, I am told the best of the best also first head to the example directory to see how things are.  The only downside is that as a beginner, I do not have any prior knowledge to build upon.  Most embedded programmers can look at a new framework but they have a reference from prior experience with other frameworks etc.  I did not even remember to look at examples in at first.</p>
Anyway, Embassy has some nice example programs for my board here</a>.</p>
Not knowing what to do with the board</h2>
I have no idea what I want to with the hardware but I like blinking lights.  That's where I start and perhaps most others too.  I am told that blinking lights are the println!("Hello, world!")</code> of the embedded world.  So, I did that.</p>
Anyway, I have now started to see that some of these boards have some sensors on them.  For example, I see that there is a temperature sensor on this board I am working with.</p>
Unable to figure out the "algorithms"</h2>
Ok, I may have used the incorrect word here but by algorithms I mean correct steps to do a certain task.  For example, my task of reading the temperature sensor value continuously and print on the console.  Some of the examples of the things I had no clue about are -</p>
How does "pushing" a program I am writing on my PC, to the board work?</h3>
This is called Flashing</em>.  The amazing thing with Rust embedded work is that you do not have to worry too much about it because cargo</code> takes care of most of it.  Often you just need a file .cargo/config.toml</code> in your project root</a> with some content like this -</p>
[target.'</span>cfg(all(target_arch = "arm", target_os = "none"))</span>']
</span># replace the chip below with your chip 
</span>#  as listed in `probe-run --list-chips`
</span>runner </span>= "</span>probe-run --chip STM32L433RCTxP</span>"
</span>
</span>[build]
</span>target </span>= "</span>thumbv7em-none-eabi</span>"
</span>
</span>[env]
</span>DEFMT_LOG </span>= "</span>trace</span>"
</span></code></pre>
Here the target</code> is the architecture.  Using rustup</code> works like rustup target add thumbv7em-none-eabi</code> to add this target on your PC.</p>
How to make sure we tell Rust the right environment?</h3>
This is trickier because for STM32 boards at least you need a special file called memory.x</code> and you may have to do some magic</a> to put it in the right place during the build phase of your project.  I failed at this miserably but datasheet of your board can tell you the values you need to specify.</p>
MEMORY
</span>{
</span>  /* NOTE 1 K = 1 KiBi = 1024 bytes */
</span>  /* These values correspond to the STM32L433 */
</span>  FLASH : ORIGIN = 0x08000000, LENGTH = 256K
</span>  RAM : ORIGIN = 0x20000000, LENGTH = 64K
</span>}
</span></code></pre>
This is to tell Rust the memory regions on your board.  Rust embedded book has a page to clarify more on this memory.x stuff</a>.</p>
What are the peripherals and how do we access them?</h3>
To know your peripherals you need to look at the datasheet.  How to access them via Rust depends on your framework but with Embassy it looks like this -</p>
let</span> p = embassy_stm32::init(Default::default());
</span></code></pre>
Not knowing what the value of sensor mean?</h2>
In my case the temperature sensor just spits out a number that Embassy framework's API serves as u16</code> (if I understand any of this, that is the voltage). Usually, you have to pass it through some formula to get the actual temperature.  Datasheet for this board has the following -</p>
Temperature (in °C) = (TS_CAL2_TEMP – TS_CAL1_TEMP) / (TS_CAL2 – TS_CAL1) × (TS_DATA – TS_CAL1) + 30</code></p>
Where:</p>

TS_CAL2</code> is the temperature sensor calibration value acquired at TS_CAL2_TEMP</code>.</li>
TS_CAL1</code> is the temperature sensor calibration value acquired at TS_CAL1_TEMP</code>.</li>
TS_DATA</code> is the actual temperature sensor output value converted by ADC. Refer to the device datasheet for more information about TS_CAL1</code> and TS_CAL2</code> calibration points.</li>
</ul>
I do get some cool</em> output LOL!</p>
cargo</span> run</span> --bin</span> temp
</span>    </span>Finished</span> dev </span>[</span>unoptimized + debuginfo</span>]</span> target(s) </span>in</span> 0.07s
</span>     </span>Running </span>`</span>probe-run --chip</span> STM32L433RCTxP target/thumbv7em-none-eabi/debug/temp`
</span>(</span>HOST</span>) INFO  flashing program (60 pages / 60.00 KiB)
</span>(</span>HOST</span>) INFO  success!
</span>────────────────────────────────────────────────────────────────────────────────
</span>0.001861</span> internal is 64
</span>└─</span> temp::____embassy_main_task::{async_fn#0} @ src/bin/temp.rs:33
</span>0.005584</span> Temperature is: 57.070312
</span>└─</span> temp::____embassy_main_task::{async_fn#0} @ src/bin/temp.rs:41
</span>0.010131</span> Temperature is: 51.26953
</span>└─</span> temp::____embassy_main_task::{async_fn#0} @ src/bin/temp.rs:41
</span>0.014678</span> Temperature is: 46.757812
</span>└─</span> temp::____embassy_main_task::{async_fn#0} @ src/bin/temp.rs:41
</span>0.019226</span> Temperature is: 44.179688
</span>└─</span> temp::____embassy_main_task::{async_fn#0} @ src/bin/temp.rs:41
</span>...
</span></code></pre>
Not putting the correct board "feature" in Cargo.toml</code></h2>
Yes, when you include embassy-stm32</code> in your Cargo.toml</code> dependencies, you need to specify the correct board ID</em>. In my case it was stm32l433rc</code>.  See my Cargo.toml</code> for details</a>.</p>
Conclusion</h1>
I have failed but this was so much fun!  I will continue playing.</p>


Rust in Science and ever-changing requirements
2020-09-12T00:00:00+00:00
I have heard many times over that for a given proof-of-concept
if you have fast, changing requirements, then you are better off
with a Dynamic programming language</a>
like Python. Python gives the illusion of faster development
because you do not have to think about the rigidity</em> of the Type system</a>
as much. Hence, it makes these dynamic languages good for prototyping and creating
proofs-of-concept.</p>
However, in this essay, I am trying to dump some thoughts about
Rust</a> usage in scientific computation, its benefits,
and generic chatter in the community. I think using Rust has an advantage in an
ever-mutating environment like research and I think even for prototyping, Rust
can be much more beneficial than a language like Python.</p>
Introduction</h2>
I am very much in a love affair with Rust. This is not going to come to you as
a surprise at all if you follow me on Twitter</a>.
Part of the reason is that I work as a software writer and general yak shaver
for science-(genomics)-adjacent work and I appreciate what Rust has to offer
in terms of the ecosystem, safety, and speed. I'd argue that a lot of work that
is usually written in C/C++, Python, Perl, etc. could be replaced by Rust.</p>
Perhaps I do not need to spend a lot of effort to convince you that
Rust can replace some C/C++ codebase more easily because Rust is a
Systems programming language</a>.
But for proofs-of-concept, you ask, how can Rust be better than, say Python? Isn't it
painful to change the code, which you do in early prototyping when you have to use a
Static language[1]?</p>
The case of Python</h2>
When I started in the sciences as a programmer, reading Perl was always an issue and the choice
that I had to make was clear to me — I chose Python. Perl was slowly being displaced by Python
anyway. So, I will give you some anecdotal comparisons from my experiences.</p>
You might think that I am comparing apples to oranges and you are absolutely correct. This is
an opinion blog post! I am choosing Python also because it is touted as the language
which makes life easier to work with given ever-changing requirements.</p>
Ever-changing requirements</h2>
One issue that I always hear is the idea of “refactoring” and/or “changing course”.
Computation in sciences, they say, is a lot of trial and error. I find this to be true! I have worked in
novel projects where even the stakeholders (scientists) were learning while we were building the
projects. There is a lot of backtracking and honestly a lot of your "software engineering" breaks
down.</p>
For this article, I am going to focus on some attributes of languages that instill
confidence in making the changes so that you can iterate. I believe the following attributes are necessary
to work with constantly changing requirements —</p>

Readability</li>
Testability</li>
Feedback</li>
Toolchain</li>
</ol>
Readability</h3>
Syntax</h4>
The clear advantage of Python is its syntactic readability if you are considerate of that while writing
(but it does not always pan out!). This means that it is easier to keep the code in your head to make the model, while you
are making changes. Rust can be hard to read because it does not fit the imperative, object-oriented style
mental model we have with languages like Python. Rust’s ownership model and typing definitely have some
learning curve.</p>
I have taught Git and Python to my colleagues and in many ways, they — and I — have had to
build new mental models for these tools as well, especially if they are already familiar with C++, Perl, and SVN,
CVS. Learning new mental models is what we do all the time. Still, I agree that this requires a lot of
effort on the programmer’s part. This is especially true for an experienced programmer.</p>
As Esteban</a> says in his RustConf 2020 talk — Bending the
Curve: A Personal Tutor at Your Fingertips</a> —</p>

Rust has a curse, it has many but this one is critical — inefficient code is generally visible.
Experienced developers hate to notice that their code is inefficient.</p>
</blockquote>
Jumping around the codebase</h4>
Rust is statically typed, empowers your editor or
Integrated Development Environment (IDE)</a>
to link the symbols in your code for easy access. A function defined somewhere in a struct</code> can
be easily found from where it is called. This makes looking up code for dependencies much easier
and faster.</p>
The only tool in Python that brings us any closer to this style of working is
JetBrains PyCharm</a>. And even this IDE for Python
fails to look up symbols</em> if you mess up your
virtualenv</code></a> or fail to register it
with your PyCharm project. You can use typing</code></a>
to annotate your code with the types but as you can see that there is a warning at the top of
the typing</code> documentation</a> -</p>

Note: The Python runtime does not enforce function and variable type annotations.
They can be used by third-party tools such as type checkers, IDEs, linters, etc.</p>
</blockquote>
With Rust, you can survive with just the compiler because these types are a part of the
language. Add Rust Langauge Server (RLS)</a> to that and
you can comfortably navigate your codebase.</p>
Docs!</h4>
Since Rust is statically typed, you can see what is the expected type of each function
argument or what is the type of the value that the function returns. Its type system
becomes part of the documentation! Whereas in Python you have to use external tools and
depend on function annotations to generate documentation,
Rust brings the documentation to you via rustdoc</code></a>.</p>
For example, please compare</p>
def </span>chillin</span>(</span>name</span>, </span>place</span>):
</span>    </span>"""Informs what's the user's chillin' number
</span>
</span>    @param name: string, name of the user
</span>    @param palce: string, where the user is chillin'
</span>    @return: int, information
</span>    """
</span>    result = </span>0
</span>    </span>if </span>place == "</span>toronto</span>" {
</span>        result = </span>100
</span>    }
</span>    </span>return </span>result
</span></code></pre>
with</p>
/// Create an alias to integer type
</span>/// Now it is much clearer what the return type 
</span>///  of the function stands for
</span>type </span>ChillinNum = </span>u32</span>;
</span>
</span>/// Informs what's the user's chillin' number
</span>/// * `name`: name of the user
</span>/// * `place`: where the user is chillin'
</span>fn </span>chillin</span>(</span>name</span>: String, </span>place</span>: &</span>str</span>) -> ChillinNum {
</span>    </span>match</span> place {
</span>        "</span>toronto</span>" => </span>return </span>100</span>,
</span>        _ => </span>return </span>0</span>,
</span>    }
</span>}
</span></code></pre>
It is a tiny example and while Rust's syntax is denser, it also provides clarity on what
the elements stand for. Here, ChillinNum</code> is the type of the return value. We could have just
used u32</code> but using ChillinNum</code> is clearer. If you run cargo doc</code> in your codebase,
Rust compiler will take all these
triple-slash ///</code> comments and generate nice documentation for you. You can see the
documentation of the crate eyre</code></a> and the
source of the crate eyre</code> that generates it</a>.</p>
Testability</h3>
Python has a ton of testing frameworks and Rust is slowly catching up. A clear advantage in favor
of Python. However, the things you are testing also dictate how much confidence you have in your
codebase. With the type system in Rust, you do not have to test for certain cases that in Python
you’d have to. This means there are certain test cases that you do not need to write if you’re
building your project in Rust. To me, this makes the iteration faster with more confidence in
the code I am writing.</p>
As Esteban</a> puts it -</p>

The reduced need for tests is because of using patterns that leverage the type system
to completely eliminate the representability of an invalid state.</p>
</blockquote>
Take Rust's match</code> pattern, as an example. The following code will fail to compile because
we failed to provide a catch-all -</p>
/// Create an alias to integer type
</span>/// Now it is much clearer what the return type 
</span>///  of the function stands for
</span>type </span>ChillinNum = </span>u32</span>;
</span>
</span>/// Informs what's the user's chillin' number
</span>/// * `name`: name of the user
</span>/// * `place`: where the user is chillin'
</span>fn </span>chillin</span>(</span>name</span>: String, </span>place</span>: &</span>str</span>) -> ChillinNum {
</span>    </span>match</span> place {
</span>        "</span>toronto</span>" => </span>return </span>100</span>,
</span>    }
</span>}
</span></code></pre>
Previously, we had provided the default/catch-all case _ => return 0,</code>. Similarly, the Rust compiler
will complain if you are not covering all the variants of a Rust enum</code> in your match</code> pattern.
This helps the programmer in considering all the paths and cases. The compiler will show an error like this -</p>
error[E0004]: non-exhaustive patterns: `&_` not covered
</span>  --> src/main.rs:12:11
</span>   |
</span>12 |     match place {
</span>   |           ^^^^^ pattern `&_` not covered
</span>   |
</span>   = help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms
</span>   = note: the matched value is of type `&str`
</span></code></pre>
I do not enjoy writing tests and eating my veggies but if I could eat fewer veggies to achieve the
same level of confidence in my changes, I’d always choose that.</p>
This also brings me to the point of designing your project. Just because your project is in
alpha/beta/whateva, does not mean that you are not allowed to think about your data structures,
your types before the implementation. A little bit of thought in the structure of your codebase
goes a long way, especially when you have to change it. Once again, listen to Esteban</a> -</p>

Thinking about the API surface first and then changing the internal logic and in-memory
representation to make it faster/more efficient is much easier in type-safe languages than in
dynamic languages, and more so in Rust simply because more things are represented in the type
system than is customary in other languages. This makes "iteratively fixing the compiler errors"
a valid refactoring strategy.</p>
</blockquote>
These points, to me, sound like Rust has more advantages than Python if we count
Testing as a property of confidence in the changes we are making.</p>
Feedback</h3>
Even though Rust has its new</em> paradigm issues[2] when it comes to learning the language, I still
feel that Rust compiler emits some of the most helpful error messages and help messages. The safety
features are built right into the compiler and the team has done a fantastic job so far in making
messages ergonomic. For example, in Rust, the array out of bounds error looks like this -</p>
let</span> x: [</span>u8</span>; </span>3</span>] = [</span>10</span>; </span>3</span>];    
</span>println!("</span>{:?}</span>", x[</span>4</span>]);
</span></code></pre>
error: this operation will panic at runtime
</span>  --> src/main.rs:</span>23</span>:</span>22
</span>   |
</span>23 </span>|     println!("</span>{:?}</span>", x[</span>4</span>]);
</span>   |                      ^^^^^ index out of </span>bounds</span>: the len is 3 but the index is 4
</span>   |
</span>   = note: `#[</span>deny</span>(unconditional_panic)]` on by default
</span></code></pre>
For Python, this looks like this -</p>
x = [</span>10</span>,</span>10</span>,</span>10</span>]
</span>print</span>(x[</span>4</span>])
</span></code></pre>
    File "</span>app.py</span>", line </span>3</span>, in <module>
</span>        </span>print</span>(x[</span>4</span>])
</span>IndexError: list index out of </span>range
</span></code></pre>
We've already seen an error message above for missing catch-all but let me show that again -</p>
error[E0004]: non-exhaustive patterns: `&_` not covered
</span>  --> src/main.rs:12:11
</span>   |
</span>12 |     match place {
</span>   |           ^^^^^ pattern `&_` not covered
</span>   |
</span>   = help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms
</span>   = note: the matched value is of type `&str`
</span></code></pre>
Side note: It is amazing that languages can and do learn from each other and copy parts that seem
helpful for the users. One recent exciting case is New safety rules in C++ Core
Check</a>. I am very happy to have other
languages learn, as Rust has from what came before.</p>
I hope you can appreciate the effort being put into the compiler and its error messages. Once
again, Esteban</a>’s talk is a fantastic watch,
where he talks about the Rust compiler as a tutor</a>.</p>

When we are emitting diagnostic errors, it is the perfect place and moment to teach
people [that] they have made a mistake and we can explain to them why they made it.</p>
</blockquote>
I will embed the talk here for you —</p>

    
    </iframe>
</div>
Python, on the other hand, had me stuck for a whole day because it complained
somewhere I was scripting NoneType</code>. If you care, this is the pet peeve that started this blog post.</p>
Toolchain</h3>
In the Python world, the packaging and environment setup is still something that makes me sad. The
closest I have come to create some sanity in my life is to use direnv</code> and shell.nix</code> in my
repositories. This sucks because this is a solution that is at the OS (NixOS) level[3].
Indeed there are tools available for auto-loading environments, and I am thankful for that.
However, Python toolset feels like a moving target.
Years ago, it was just setup.py</code> and today it is setup.cfg</code>, pyproject.toml</code> as well but
the latter two do not support all the features so you end up having setup.py</code> in your codebase.
Here, let Tall, Snarky Canadian explain it to you</a>.</p>
On the Rust side though, the ease of use of cargo</code> and rustup</code> has not been beaten for me,
so far. The Rust ecosystem is young and has the advantage of learning from other platforms.</p>
Something else that made me happy about Rust is the promise of backward compatibility. Most of us
have been burnt with Python 2 to 3 move although I am in awe of the Python community that undertook
such a massive effort and made it happen.</p>
The biggest disadvantage in Python that I see is that if I move a module out of a package, it is
much harder for my editor to figure out the details of my refactoring. PyCharm has made my life
much easier but there are cases where it fails because it can do only so much with a dynamic language.
This is obvious because Python is a dynamic language. My good friend, Esteban</a>
once again nails it -</p>

The kind of dynamism that Python has, where almost everything
you write is valid code, can be a behavior you did not want, makes it harder to write a Python
interpreter that helps you get back on track. Rust leverages its rigid syntax to simultaneously
keep the language simpler than it otherwise would be and to make it easier to figure out what
the user was actually intending to do.</p>
</blockquote>
While this does allow us to write code without thinking too much about types, it does not give
us a lot of confidence when we are changing the code. This means that one can likely write much
faster in Python, but to change the code for new requirements is much harder because it is likely
to be error-prone.</p>
Not all is ready, yet</h2>
I do not think that a piece should be entirely replaced, just because it can be.
Some tools being used are more mature than Rust is at the moment. However, there
are clear benefits to be had. I am happy to report that I am not the only one who
feels</a> this way in (some of)
the</a>
community</a>.</p>
There is some way to go with the data structures and libraries etc. but I think it is a
chicken-and-egg problem and as the adoption increases there will be more libraries available. The
best part is that you can do piecemeal work by delegating parts of your codebase to Rust using
FFI</a>.
Let Luiz explain it to you how he works in his research with Rust and Python!</a></p>
Static for dynamicity</h2>
This is where I would conclude that if you are starting a journey and are sure that the things will
change many times over, you may be better off with a language that gives you</p>

a solid structure to build upon with</li>
tools to warn you when parts of that structures are moved</li>
by giving your advice on “why”, “where” and “how” to do that</li>
</ul>
I also conclude that you could leverage Rust to replace parts of your project that
require more safety and speed.</p>
I enjoy writing Python because of its syntax but I keep missing the Rust compiler's help every day.</p>
Once again, this article would not have been possible without the help and guidance of the following
friends -</p>

Ana Hobden</a></li>
Esteban Küber</a></li>
Shveta Kumar</li>
</ul>
[1] I am sorry but I am taking a generic leeway to combine Dynamic languages with Dynamically
typed languages and Static languages with Statically typed languages</p>
[2] They are rather non-mainstream because Rust borrows</em> almost everything from other languages
but you get the idea</p>
[3] If you want to know how to manage your work environment for a project using NixOS and direnv</code>, you can read
my small blog post about
Environment management with nix-shell</a>.</p>


A year in CanDIG project
2020-07-06T00:00:00+00:00
Last month, I completed a year in my current project -
CanDIG</a>. This project is about building
a platform to connect "data lakes" within Canadian institutions in a federated
manner. I was hired to mostly do federated authorization, which you can read
about in this blog post on CanDIG's blog</a>.</p>
Those who do not know, I have spent the past few years
in the Genomics area but mostly on the side of software infrastructure. Some of
the Biology and Genomics knowledge that I have is courtesy
Donna Maglott</a> at NCBI.</p>
However, I left United States for Canada, once I found a project that I
was excited about, and of course, never again have to worry about H1B Visa
or the immigration system in US. Having worked a year in the team, I have learned
a few things in general that I thought are worth sharing.</p>
Value matching with the team and project</h2>
Even though I have mostly worked solo due to the nature of AAI work,
it is a tremendous help to work in a team that matches your values.
Collaboration with other colleagues on projects that overlap with my goals makes me happy.
For example, on the "Dynamic Consents" project with an esteemed colleague that allows for
patients to give their consent, and change the consent (either granularity or revocation)
if they want while taking into account aspects like the accessibility of remote communities
in Canada. I love the fact that our team is taking into account various social issues
that hinder marginalized communities' participation, representation, and ownership of their data.</p>
Love-Hate relationship with software development in science</h2>
At the time of this writing, there has been a lot of improvement in
scientific computing and software development. There are
organizations, like RSE</a>, that are helping move
the state of the scientific software to a better place. However, there is a lot
that remains to be desired. This is also good news for people like me because
that allows us to voice the concerns and keep our job.</p>
I also believe that most of the time, as a scientific software developer
you can work on a variety of projects and tasks which keep your tech-life
less monotonous. I understand, that for some people, shaving Python yaks is
also monotonous but as long as I get leeway to learn and grow, I am happy.</p>
The part that I am most concerned about (still) is licensing. A lot of professors
in a lot of places are not happy with Copyleft licenses and I am not sure why. I
have written a blog post about this question on Copyleft licenses in scientific
software</a>. I still do not
have a good answer as to why we should avoid Copyleft licenses when they serve the Science
more than other licenses, representing the true spirit of Science.</p>
Don't roll your own crypto</h2>
A lot of work within the group was related to AAI and there are a bunch of things
that you can do by yourself. However, there are likely tools available that you can leverage
without having to write those on your own. The point is that the quote "don't roll
your own crypto" is not just for the crypto algorithms or PKI
etc. It can be for small things like releasing or signing JWT</a>s.
Yes, you read that right - JWTs! Please don't judge, we need JWTs because we use OIDC (more later).
It is super easy to slip into "build your own" for smaller things. So far, we've avoided
that by using Keycloak, Tyk, and libraries for differential privacy, etc. and hopefully will
continue on that trajectory by using products like Hashicorp Vault</a>.</p>
Federated, Distributed and other overloaded terms</h2>
I never thought I'd even look at something like OIDC</a> in my career
but here I am. I have now achieved two things in the year -</p>

Perform cross-atlantic (Europe+Canada) connection of resources (e.g. genomic services)
which allow for both sides to log into each other's instances and be authorized at different
levels just by using OIDC. This could be called federated authorization.</li>
CanDIG's first draft of authorization, which is a distributed infrastructure that connects multiple sites within Canada
to share genomic data. This authorization can also be called federated authorization.</li>
</ol>
The European infrastructure is much more centralized so the challenges in tying them with
our infrastructure are different than what we are building within CanDIG and Canada. What we
are doing within CanDIG is much more difficult because we certainly do not have the leeway
that a centralized system has, where an alias of the external user can be created to facilitate
communication. The terms are definitely</em> overloaded!</p>
But as you can see, the issue is that we need to use a protocol that -</p>

supports complex authorization and permission schemes (don't roll your eyes)</li>
can be extended with custom permissions and claims</li>
is open</li>
supported in a wide variety of cases and products</li>
is documented (enough)</li>
can be agreed upon by scientists from across the globe</li>
</ul>
Much of this work is being done in CINECA project</a>
and a lot of input to and from GA4GH</a>. There are very few
protocols that come close to what exists in the form of OIDC. Let me be clear, I hate
it. However, I do not have much say and I do not have any suggestions either. If you are
saying "Build your own" then please see the previous point. It is ridiculously hard to
come to consensus in any such scientific gathering and then there is the question of $$$.</p>
And I have</em> looked into https://oauth.xyz/ and no it is not ready yet and I do not
even know if it is going to be any better, yet. Complexity breeds issues but some of
the problems at-hand require complex solutions. Sure, OIDC is complicated as well.</p>
I appreciate you read so far what seems like a brain dump of last year. Here's to another
year with a focus on systems, Rust, privacy, and federation!</p>


My process for bibliography and notes
2020-06-24T00:00:00+00:00
For those who are starting new in research, you might want to keep running notes
and citations for the relavant research papers, journals, books etc. that you
come across. This helps maintain clarity of what is important, what has been
read already and the notes that help you revisit the material if and when you
need to.</p>
After a decade and half worth of haitus, I am starting to delve into research
once again. This means reading papers more than I am used to. During my tenure
as software engineer in various organizations, most papers I had read were
limited and I could afford to read them as many times as I wanted.</p>
Things have changed now and I need tools and new habits to help me navigate
through a ton of literature. I cannot afford to spend countless hours on one
paragraph in one paper. Above all, I cannot afford to think that all papers
and books are created equal and have the same value for my research and
eventual PoC that I have to deliver.</p>
Here are a few things I am trying to achieve</p>

Forming new habits

ability to skim papers</li>
jotting down quick notes for the papers</li>
peruse references if interesting and get those references</li>
revist the papers for deeper read if needed</li>
</ul>
</li>
A way to manage a "to-read" list of papers</li>
A way to manage "already-read" list of papers</li>
Tag papers that need revisiting for deeper read</li>
</ol>
As you can tell, I do not want a mere list of citations that I have read for
my research and projects. I want a traceable way to know what I read, as well
as why it was important. Here is an approach I am starting with -</p>
Start with a book on the research, if available. Skim it first.</h2>
A book allows easy introduction to the topic without having to figure out
which papers to read first on that topic. If a decent book is not available
for the field/topic, there might be a way to start with early review papers
or first papers.</p>
Note: At the time of writing, I am not aware of anything else to alleviate
some starting pains.</p>
Why skim</h3>
It is critical that I skim the book to break the habit of deep reading in first
pass. If I am spending too much time going deep and trying to retain everything
I am losing out on getting a broad idea of the topic at hand. I need to be have
broad knowledge as soon as possible so I can then drill down into specifics.</p>
Keep short notes</h2>
Skimming does not mean that you avoid taking notes. You aren't reading a novel
after all (although I have been known to keep notes on novels). Keeping such
notes allows you to come back to them to decide whether something was worthwhile
and requires deeper reading. I try to keep notes of the following things:</p>

Chapter names and general idea</li>
List of topics each chapter covers</li>
Mark/tag a chapter important or to revisit</li>
List of reference from each chapter that you want to fetch</li>
</ul>
These notes enhance your bibliography.</p>
Next</h2>
If you are comfortable at the end, maybe it is worthwhile to revisit the
chapters you've marked and fetching the references. I personally fetch all
the references at the end of each chapter, if I can. At this time, mark all
the papers and chapters yet again if they need revisiting. Tag them further
to make sure you can search for them later when you need them.</p>
I find keeping at most three tags just enough to have entropy under control,
at the same time not losing my sould in tagging everything.</p>

Remember, the goal is to manage the items and related notes to quickly make a
decision on important aspects of the topic at hand.</p>
</blockquote>
Another cycle of skimming, taking notes, and moving to next starts!</p>
I hope this will help me build an intuition by helping with new habits
of swimming through the giant corpus of any topic that I want to study.</p>
Tools</h2>
Save and synchronize papers</h3>
I started using Zotero</a> and it has been working fine so far. Some of the
key features that I find useful -</p>

Easy, one-click fetching and saving of papers (browser plugins available)</li>
Ability to tag them as well as create "collections" to manage files</li>
Ability to add notes to the papers</li>
Syncrhonizing your papers list, notes and everything under the Sun</li>
Works on Linux!</li>
Works with third-party apps on mobile devices and tablets</li>
Advanced search that you can save</li>
Ability to generate ciatations and reports from each item</li>
You can export your data</li>
Free for upto 300MB of storage for synchronization</li>
</ul>
On my iPad, where I do most of the reading, I use PaperShip</a> with Zotero</a>
account.</p>
Search and discover papers</h3>
A few places I go to, to search papers and to discover new papers.</p>

arXiv</a> - a preprint to find stuff sooner</li>
arXiv Sanity</a> - a self hosted private instance for my areas of interest</li>
Semantic Scholar</a> - Also allows you to create feeds for papers of interest</li>
</ul>
Notes and tags</h3>
I add quick notes in Zotero as well as use local Emacs+Markdown and push the
notes to GitHub (or SourceHut</a> if you hate GitHub because of ICE).</p>
I save papers in particular collections in Zotero and tag the papers frequently.
For example, I tag "done-reading" when I am done reading and I have a saved
search that quickly lets me see all papers I have already read. Another saved
search allows me to quickly see all "to read" papers.</p>
I have been using "Cite" feature of Zotero and Semantic Scholar to create the
title of each item in the bibliography and underneath that I jot down notes and
other relevant details like links.</p>
Feedback</h2>
I would love to hear what has worked for you. Is there something I am missing.
Reach out to me via email or twitter.</p>
Many thanks to Jonathan Dursi</a> for constantly helping me improve this process.</p>


Why on Earth are copyleft software licenses bad for scientific software?
2020-03-21T00:00:00+00:00
My quest for this blog started with the discussion about the choice of license for the software under Open Differential Privacy (OpenDP) Initiative[17]. I wanted to understand why copyleft licenses</a> are a taboo in Scientific circles. OpenDP choosing MIT license</a> prompted me to ask why wasn't something like AGPL</a> used. I got this as an answer:</p>
https://twitter.com/cbavitz/status/1260662650230505472?s=20</p>
This answer prompted a feeling I have been harboring for a while — no one explains what exactly is wrong with the copyleft licenses and why they restrict adoption and participation.</p>
I and many countless others have been involved in some kind of scientific field as software programmers. We, the research software engineers, now even have our own organizations[18]! In a lot of ways, the scientific programming community is a bit behind the commercial software world. This is certainly true for best-practices, tools, etc. but it is also true for software licensing. In this post, you will get a glimpse of the most prominent (or prominently searchable) software licensing discussion in the scientific community.</p>
Disclosure</h2>
For me, being in sciences gives the benefit of learning something new and help support scientific discovery along the way. I believe that copyleft licenses are truly aligned with the academic and scientific pursuit. I understand that commercial companies and folks who work there are vocal about not using copyleft licenses but I believe that for scientific knowledge to thrive, we need to use more copyleft licenses.</p>
Also, this blog post will focus on non-military software. The kind of software that is not under an embargo or security curtains.</p>
Types of scientific software</h2>
My experience mostly comes from genomics and adjacent areas. It is important to note that in this area, the privacy of individuals is critical and so is their data.</p>
Software accompanying research paper(s)</h3>
This is the most common piece of software associated with scientific work and is generally published somewhere. This type of software can be a library, framework or even a hosted service with its source code hosted somewhere else. Most of the time, these are repositories sitting on GitHub that have not been touched since the paper was published. Some are even with open pull requests and issues with no response from the owner of the repository. But this rant is for another day.</p>
You may think of this as a basic proof-of-concept that is not to be used in any production level work.</p>
Software accompanied by research paper(s)</h3>
These are the tools and frameworks that help run scientific research projects. Software published by NCBI or NASA that facilitates researchers in their respective fields to run computations or simulations could be seen as this type of software. Or you can think of tools like NumPy, SciPy, etc. My current work project — CanDIG[19] — is of a similar kind.</p>
Commentary on licensing in the scientific community</h2>
The most common papers and articles that I could find are from Prof. Stodden</a>. Prof. Stodden has published more about software licensing than anyone else in academia that I could personally find. Some quotes for a slide of a talk by Prof. Stodden[1]:</p>

The scientific ethos precludes directing another scientist’s creative
contribution.</p>
</blockquote>

Copyleft licenses make demands on downstream code, namely that they
use the upstream license on the entire library of new code. Two codes
under two different copyleft licenses, therefore, cannot be mixed, as
code cannot carry two licenses.</p>
</blockquote>

Science creates knowledge, our best estimate of the truth - a public
good. People are free to use and build on public goods however they see fit.</p>
</blockquote>

Copyleft creates a barrier the transmission of knowledge and scientific
progress, that is not compensated by other benefits.</p>
</blockquote>

Copyleft inhibits or prevents collaboration with industrial partners.</p>
</blockquote>
Don't scientific ethos also encourage "communism" and "disinterestedness"[20]? I fail to understand here that how is forcing companies to disclose the source is against the scientific ethos. Commercial companies have been using and continue to use software with copyleft licenses. Following is another statement by Prof. Stodden that makes my belief in copyleft licenses being more important in scientific software, actually stronger.</p>

Society’s right to knowledge is an unconditional right.</p>
</blockquote>
The knowledge, in part, lives in the software we write to facilitate the studies. A couple of questions before we move forward:</p>

How is it progress if someone takes your work, builds upon it, but does not give back? That is the argument being made by the commercial side.</li>
How is that I am reading the same sentence and coming to an opposite conclusion? :)</li>
</ol>
It has been hard to get answers apart from just statements like "copyleft licenses are not permissive...". So, I searched for more...</p>
A 2012 paper in PLOS by Moris et. al.[5] is a good read where they suggest what you should choose and why. A blog post in Astronomy Computing Today[4] with the same title, referring to this paper, summarizes this nicely:</p>

If you want…</p>
</blockquote>

…the widest possible distribution and adoption, fewest restrictions on
users, open and transparent source code, peer review, community
contributions to the codebase, and easy incorporation of your code by
others… then a permissive FOSS license such as the BSD/MIT, Apache, or ECL
licenses may work well</p>
</blockquote>

…to assure the benefits and openness of FOSS in all future derivatives of
your work, open and transparent source code, peer review, community
contributions to the codebase, and the potential incorporation of your
code into other copyleft- licensed works… then you should consider a
copyleft FOSS license like the GPL, LGPL, or MPL.</p>
</blockquote>

the ability to separately pursue proprietary models while leveraging the
wide distribution, adoption, community contributions, and other benefits
of open source software… then a hybrid or multi-license scheme may be
ap-propriate.</p>
</blockquote>

…protect the confidentiality of your source code, reserve maximum control
over the distribution and use of your software, and derive licensing
revenue… then you should consider a proprietary license.”</p>
</blockquote>
Now we have a few pointers on when to choose which license. According to the comments above, a copyleft license makes sure that future derivatives are open as well. As I noted above, in my experience a vast majority of repositories are never touched again, after the publication of the research paper (this is purely anecdotal). There is proof that wide adoption can still happen, even with copyleft licenses, if the published software has value.</p>
A blog post from Jake VanderPlas on "The Whys and Hows of Licensing Scientific Code"[13] is also a good starting point for scientists to figure out what they want to do. The summary in the post is:</p>


Always license your code.  Unlicensed code is closed code, so any
open license is better than none (but see #2).</li>
Always use a GPL-compatible license. GPL-compatible licenses ensure
broad compatibility for your code, and include GPL, new BSD, MIT,
and others (but see #3).</li>
Always use a permissive, BSD-style license. A permissive license
such as new BSD or MIT is preferable to a copyleft license such as
GPL or LGPL.</li>
</ol>
</blockquote>
This aligns with Prof. Stodden's views. One of the amazing things about the post[13] is the discussion in its comments which was incredibly insightful. I will reproduce some of those comments here:</p>
Jeremy Sanders writes:</p>

If I’m publicly releasing code, I’m not writing it so that it can be
taken by a for-profit company and essentially close-sourced. The GPL
is philosophically much closer to academic freedom, where any modified
versions distributed, also have the source distributed.</p>
</blockquote>
To which, Jake responds:</p>

If I’m publicly releasing code, I hope it’s useful enough that a library
like scipy, scikit-learn, or matplotlib will want to incorporate it. In that
case, GPL is a barrier to its usefulness. Remember that in academia, it’s not
the text of a license that protects your ideas, but the norms of the academic
community.</p>
</blockquote>
Jeremy again:</p>

Jake: that’s all very well for code that is purely academic and not
interesting to commercial users. If you code is at all commercially
viable, the GPL is a much better prospect. If your code is useful,
people will use it regardless of the choice of free license. People
even use black boxes like sm and galfit.</p>
</blockquote>
Jake believes that projects like Matplotlib, Numpy, scipy, pandas, scikit-learn, IPython are successful because it is "much more than a simple coincidence". I think this is alluding to the fact that they use permissive licenses. This is where it gets even more interesting because Matthew Turk who moved his yt library to BSD and wrote about it in "Relicensing yt from GPLv3 to BSD"[14], chimes in:</p>

Hi Jeremy, I agree. I was really quite torn about re-licensing yt, as I am
personally an enormous fan of the GPL and the copyleft. I am, in fact, still
rather torn about this for the reasons you wrote here — I am committed to
ensuring that the code remains free, and that future versions of it are
inspectable at the source level. BSD licensing does not enforce that freedom,
but we as a community do — yt itself, even if a nefarious corporation takes
it and improves it and sells it, will be free software, respecting all four
freedoms.
...</p>
</blockquote>

I guess my main point is, I think you’re right, and I think the issue is a
subtle one, but I also</em> think that in the end the choice that we made as
the yt community was the right one for us at the time. But that doesn’t keep
me from being a little sad that the GPL is viewed as such a pariah, as in
essence I firmly believe that the de facto standards of FLOSS in science
will be GPL-like, with an active curation and preservation of the four
freedoms, even if BSD in actual license.</p>
</blockquote>
This comment is critical to understand that there are scientists who do believe that a GPL-like license is aligned with the scientific endeavor.</p>
Moving along, if you are scrolling through comments there is a gem by Jeremy Sanders:</p>

...as Linux shows that it’s certainly possible for commercial companies to
thrive in a GPL ecosystem. I’ve had commercial companies contributing towards
my GPL code with no licensing issues. If a company is scared off by the GPL,
it’s likely they need better lawyers. The code being GPL protects their
contributions from being swallowed up by competitors in rival closed source
apps.</p>
</blockquote>
and a detailed comment to prior "bundling" comments by Mohammad Akhlaghi:</p>

This is a follow up to Jake’s comment at March 14, 2014 at 10:09 am.
Sorry for continuing this discussion after about 2 years. I just wanted to
know exactly what part of GNU LGPL restricted the bundling?
...
So if I have understood GNU LGPL correctly, you can easily bundle an GNU LGPL
library into a BSD-licenced program without much effort. But then again, I am
not a lawyer or have too much experience in the different software licenses
yet, so I would be grateful if you could let me know if I have incorrectly
understood the GNU LGPL.</p>
</blockquote>
And finally, Don Barry's comment's first paragraph:</p>

I must disagree strongly with your endorsement of permissive licenses and
your arguments for them. What is nowhere here discussed is the enormous
amount of corporate lobbying which has influenced the issue. Google, with
the exception of work with the Linux kernel, a “too big to avoid” project,
has actively sought to expunge the GPL from other efforts of theirs: Android
contains only the kernel as GPL software. The fragmented Android ecosystem
is one of many examples where this choice is hostile to the end user.</p>
</blockquote>
So far, the most common theme among scientists (and many programmers) that I see is the leaning towards MIT or BSD type of licenses. Licenses that allow users to freely modify and distribute, without any strings attached to where the source came from or giving back. This is true even if it means that some of them still love GPL and its derivatives and are sad about not being able to use copyleft licenses. It'd be worth looking into how much of the sentiment against copyleft licenses is due to the industry pressure.</p>
Chatter outside the scientific community</h2>
There is no dearth of commercial programmers hating on copyleft licenses. But some voices clarify why we should stick to a license that helps gain the modifications back. Look at what MongoDB writes in their post about licensing and their choice of AGPL[7]:</p>

To say this another way: if you modify the core database source code,
the goal is that you have to contribute those modifications back to
the community.</p>
</blockquote>
This is the second piece of software (other than GNU/Linux kernel) that is "famous" and uses a copyleft license. I still fail to see why copyleft licenses are a stigma and hence the title of this post. It is working fine for some commercially successful software.</p>
Moving on, David Wheeler has an essay[6] that GPL compatibility is important and how to achieve it. It also notes which licenses to avoid and software projects that consider compatibility with GPL important. I think it is worth a read even though it is an old post.</p>
In an old blog post (now unavailable, wayback link[21])</a> Zed Shaw, talked about why he is using (A/L)GPL. However, in his Reddit comment[3] he says he was wrong and gives the reason(s):</p>

This article is old but basically everyone is right and I was wrong: I didn't
make any money on Lamson and nobody contributed to it, no matter what license
I used, and no matter where I hosted it. Pretty much, Lamson proved to me that
all the reasons you're given for open source success (license, github, BDFL,
etc.) are a load of horse shit. It's marketing dollars, propaganda, and random
chance just like everything else.
So now my stuff is BSD because I write books at
http://learncodethehardway.org/ and there's not really an alternative license
that works for code in books. That's all. No major revelations or drama, I
just moved on to something better.</p>
</blockquote>
So, if Z. Shaw is to be believed that the commercial success of a project is mostly marketing, money, and chance, then to me, it makes sense to stick to copyleft license if sharing and openness is something you even remotely care about. It seems to me that copyleft licenses are beneficial, in general, to the scientific openness. I am not sure if the importance of "permissivity" of the license mostly a cry from those who find it cumbersome to give back while raking profits or there is more to it. I would love to know. However, in science, we cannot let this dictate the ethos of sharing and openness.</p>
Open and accessible is the final word</h2>
In recent years, the term "Open Science"[16] has become popular in our community. One of the ways Wikipedia defines it as:</p>

Open science is transparent and accessible knowledge that is shared and developed through collaborative networks.</p>
</blockquote>
It is a noble effort and I am glad that there is awareness within the community to make sure that the information stays open and accessible. However, the question remains that why shouldn't science be "open" by default? Almost every researcher I know understands the power certain paid journals have since many research publications are behind paywalls and convoluted logins. Many agree that these places hinder science in the end. You should be able to use previous research and build upon it and this new work can inform the previous work that can be improved even further. If this model works for other parts of scientific work, then why is scientific software any different?</p>
Many thanks to the following people who reviewed this post:</p>

Jonathan Dursi</a></li>
Shveta Kumar</li>
Ana Hobden</a></li>
</ul>
References</h2>


Prof. Stodden, V  "Why Copyleft Isn’t Right for Scientific Code" https://web.stanford.edu/~vcs/talks/VictoriaStoddenIPSC2010.pdf</p>
</li>

VanderPlas, J  "The Whys and Hows of Licensing Scientific Code" https://www.astrobetter.com/blog/2014/03/10/the-whys-and-hows-of-licensing-scientific-code/</p>
</li>

Reddit Comment by Zed Shaw https://www.reddit.com/r/programming/comments/llw0s/zed_shaw_on_gpl/c2tt5e3/</p>
</li>

astrocompute. “A Quick Guide To Software Licensing for the Scientist Programmer.” Astronomy Computing Today (blog), February 25, 2014. https://astrocompute.wordpress.com/2014/02/25/a-quick-guide-to-software-licensing-for-the-scientist-programmer/.</p>
</li>

Morin, Andrew, Jennifer Urban, and Piotr Sliz. “A Quick Guide to Software Licensing for the Scientist-Programmer.” PLOS Computational Biology 8, no. 7 (July 26, 2012): e1002598. https://doi.org/10.1371/journal.pcbi.1002598.</p>
</li>

“Make Your Open Source Software GPL-Compatible. Or Else.” Accessed April 20, 2020. https://dwheeler.com/essays/gpl-compatible.html.</p>
</li>

MongoDB. “The AGPL | MongoDB Blog.” Accessed May 10, 2020. https://www.mongodb.com/blog/post/the-agpl.</p>
</li>

“Conditions on Distributing Ghostscript in a Commercial Context.” Accessed May 10, 2020. https://www.ghostscript.com/doc/current/Commprod.htm.</p>
</li>

“Licenses & Standards | Open Source Initiative.” Accessed April 20, 2020. https://opensource.org/licenses.</p>
</li>

astrocompute. “Licensing Your Code: GPL, BSD and Edvard Munch’s ‘The Scream.’” Astronomy Computing Today (blog), January 17, 2014. https://astrocompute.wordpress.com/2014/01/17/licensing-your-code-gpl-bsd-and-edvard-munchs-the-scream/.</p>
</li>

“Neuroimaging in Python — NIPY Documentation.” Accessed April 20, 2020. http://nipy.sourceforge.net/nipy/stable/faq/johns_bsd_pitch.html.</p>
</li>

“The GPL and License Compatibility.” Accessed April 20, 2020. https://producingoss.com/en/license-compatibility.html.</p>
</li>

“The Whys and Hows of Licensing Scientific Code.” Accessed April 20, 2020. https://www.astrobetter.com/blog/2014/03/10/the-whys-and-hows-of-licensing-scientific-code/.</p>
</li>

The yt Project Blog. “The Yt Project Blog » Post: Relicensing Yt from GPLv3 to BSD,” September 12, 2013. http://blog.yt-project.org/post/Relicensing/.</p>
</li>

“Why I Don’t Use the GPL | Linux Journal.” Accessed April 20, 2020. https://www.linuxjournal.com/article/5935.</p>
</li>

“Open Science.” In Wikipedia, May 12, 2020. https://en.wikipedia.org/w/index.php?title=Open_science&oldid=956239136.</p>
</li>

“OpenDP.” Accessed May 20, 2020. https://privacytools.seas.harvard.edu/opendp.</p>
</li>

“Society of Research Software Engineering.” Accessed May 20, 2020. https://society-rse.org/.</p>
</li>

“CanDIG.” Accessed May 20, 2020. https://www.distributedgenomics.ca/.</p>
</li>

“Mertonian Norms.” In Wikipedia, May 9, 2020. https://en.wikipedia.org/w/index.php?title=Mertonian_norms&oldid=955747690.</p>
</li>

"Why I (A/L)GPL" Zed Shaw, From Wayback Machine, July 13, 2009. https://web.archive.org/web/20090831045815/http://zedshaw.com/blog/2009-07-13.html</p>
</li>
</ol>


NixOS and other tools
2020-01-25T00:00:00+00:00
Note: This blog post is old and many things here have been changed and moved on. I will write another post to update.</h3>
Before I begin, you must know that my inspiration to move to NixOS was Spacekookie</a>. I had no idea about NixOS
before I learned about it from Spacekookie. You can read the NixOS/Home Manager post</a>.</p>
You can see my NixOS and Home Manager configs</a>. This is a big deal!</p>
History</h2>
Years ago, I moved to the Apple ecosystem for stability and things like the Time Machine backup system. That is still where my personal computing lives.
But I was getting more and more worried about having personal data on the same machine where I download and run code. I was hoping to
separate my development setup from my personal computing setup. I could have gone the route of QubesOS but back then I was not ready
to shave more yaks than what I was already helping groom. So, I decided to buy a laptop and have been running Ubuntu on it, up until
a few months ago, when I removed Ubuntu and moved to NixOS.</p>
Why NixOS</a></h2>
For years I have looked at way too many tools to have a decent backup and restore strategy and nothing stood out. I can manage
to backup my home directory and restore it but I needed something that helped reliably reinstall all the applications, dotfiles
and other tools that I need day-to-day. Then I can just reinstall in case of a computer crash and fetch the home contents from a backup.
This is where NixOS</a> helps. In short, it is a Linux distribution that is based on Nix</a>, a purely
functional package manager (it is also a functional programming language). This allows your installations, upgrades, etc. to be atomic, which
makes them much more reliable. That is, every time you install or upgrade, NixOS creates a new snapshot</em>. You can clean older snapshots</em>
when you feel like it or boot into an older one if you wanted. There is also home-manager</a> which is userspace Nix. I highly recommend
you look into that as well.</p>
For those interested here is my Nixos and Home Manager configs</a>. I can give a quick run down.</p>
A build shell script</a></h3>
This is needed because I want to be able to override certain packages and have the config live in my home directory rather than the default
/etc</code>.</p>
Root(s)</a></h3>
This is where I store the root configs for various machines. A root config is your configuration.nix</code> and hardware-configuration.nix</code>
that is created the first time you bootstrap while installing NixOS. You can use configuration.nix</code> for everything but it is better
to have some semblance of order. Programmers, eh!</p>
I have three development machines and at the time of this writing, two of those are on NixOS. Yes, I love wolves and yes I came up with the name Torontula.</p>
Common stuff</a></h3>
This is mostly common stuff for all machines without having to make duplicates. This could go into a configuration.nix</code> but I chose to move it
into its module.</p>

This file defines the unstable</code> branch</a> of Nix because certain packages
are only available in that. At the time of this writing, I have Zulip which I needed for Rust's official chat. Note that you can define ref</code> and
revision</code> and fetch only that. Talk about thinking of pinning from the ground up.</li>
It installs Virtualbox and related services. Yes, I need this on all machines and it takes horribly long to recompile.</li>
When was the last time you defined a font</a> in the config? Or created a user in the config</a> with some Puppet/Chef/etc.? ;)</li>
Oh, look at the desktop managers here</a>.</li>
</ul>
Packages</a></h3>

Ahem! Manager your config files</a>. The confs live in a
separate directory.</li>
This entire section is the list of packages I want to be installed</a>.
I add and remove most of them here and run the rebuild command.</li>
When was the last time you managed your git config and settings</a> like this?</li>
Do you use emacs (or even vim)? Here is the list of all the emacs packages that I use</a>.
Some of these are directly from Spacekookie</a>!</li>
</ul>
Bonus</h3>

Change your Linux Kernel in one line</a>.</li>
I moved to fish shell</a>; again thanks to Spacekookie</a> from whom I
stole this entire set of functions</a>.</li>
I moved to Alacritty</a> as my main terminal emulator.
Here is Alacritty's config YAML</a>
and here is how you "install" Alacritty's config</a>
It is truly faster than any other terminal emulator I have used.</li>
If you like QubesOS, you should check out SpectrumOS</a>. It is like QubesOS but based on Nix. I am excited about this and I wish I had time
and knowledge to contribute to this project.</li>
</ul>
If you want to get help, folks on the NixOS IRC channel are very helpful!</p>


man7.org Linux training and Google cloud virtual machines
2019-03-03T00:00:00+00:00
I had the privilege to attend a week-long training by Michael Kerrisk</a> on "System Programming for Liunux Containers". If you are interested in Linux deep-dive, I cannot recommend anyone more than Michael. I have been waiting for his training for about four years and it finally happened! So, keep your hopes high, you may someday get that too.</p>
Michael is the maintainer of the Linux man-pages</a> and is extremely knowledgeable. His style of teaching is balanced
with enough theory for you to get started and decent collection of exercises along the way. In his class, you will be working as pair-programmers. This helps speed up the work you have to do and encourages discussion with your peers. He is receptive to comments and suggestions.</p>
You should contact him!</p>
For his course, you need a Linux machine and it is better if it is your laptop but you could work with a virtual machine on your laptop. To make sure that we have spare VMs, I created a bunch on Google cloud platform. You can use this Terraform repo to do the same</a>. For his courses, you may have to access the GRUB prompt to edit Linux kernel args. The output for Terraform code after it generates the VMs, will show the command to do that as well.</p>
In short, Google cloud platform allows you to connect to your VM's GRUB prompt via a seial console</a> (that you have to enable prior to VM creation).</p>
Happy hacking!</p>


How to document Rust's macro invocation
2019-02-21T00:00:00+00:00
Since, I have spent way too much time on this, I decided it is worth noting down.</p>
The problem</h3>
You can easily document your Rust items like functions by putting three slashes ///.</p>
/// My amazing function
</span>/// # Example
</span>/// amazing();
</span>fn </span>amazing</span>() -> () {
</span>    println!("</span>Rust is amazing!</span>");
</span>}
</span></code></pre>
You can also document your macro like this -</p>
/// My amazing macro's own doc
</span>macro_rules! </span>amazing {
</span>    (</span>$func</span>:</span>ident</span>) => (
</span>        </span>fn </span>$func</span>() -> () {
</span>            println!("</span>Rust is amazing! Rust has powerful features!</span>");
</span>        };   
</span>    )
</span>}
</span></code></pre>
However, if you want to document each separate invocation of your amazing! macro, it is not that straightfoward. You might ask why should we be doing that anyway? Because macros can generate a lot of boilerplate code for you and each of those invocations might be slightly different which must be conveyed to your user in docs.rs. For example, this will not work</p>
/// this is a macro invocation but
</span>/// these doc strings will not show
</span>amazing!(amazing_function_1);
</span></code></pre>
Phew!</p>
Solution</h3>
Slightly modify your macro</h4>
/// My amazing macro's own doc 
</span>macro_rules! </span>amazing {
</span>    (
</span>        $(#[</span>$meta</span>:</span>meta</span>])*
</span>        </span>$func</span>:</span>ident
</span>    ) => (
</span>        $(#[</span>$meta</span>])*
</span>        </span>fn </span>$func</span>() -> () {
</span>            println!("</span>Rust is amazing! Rust has powerful features!</span>");
</span>        }
</span>    )
</span>}
</span></code></pre>
Let me explain briefly what those two new lines mean.</p>
Capture meta</h5>
$(#[$meta:meta])*</code> tells the macro to match 0 or more instances of meta attributes. Rust doc comment /// a comment</code> is just another way of saying #[doc = " a comment"]</code> This means that if we provide a comment in our invocation, this will now be captured.</p>
Output meta</h5>
$(#[meta])*</code> just spits out all the meta attributes right before the function.</p>
Add comment in your invocation</h4>
amazing!(
</span>    </span>/// this macro invocation will have a comment
</span>    </span>/// # Examples
</span>    </span>/// amazing_function_2();
</span>    amazing_function_2
</span>);
</span>
</span>amazing!(
</span>    </span>/// this macro invocation will have another, its own, comment
</span>    </span>/// # Examples
</span>    </span>/// amazing_function_3();
</span>    amazing_function_3
</span>);
</span></code></pre>
The comments in the docs will now show up for both functions that were created via invoking macro. :)</p>
Many thanks to kind folks in Rust community discord server.</p>


AWS load balancers and instance health checks with terraform
2018-10-07T00:00:00+00:00
Auto Scaling Group (ASG)</a> is an AWS feature that allows you to manage the size of a cluster (group) of similar instances. You can create an ASG with a minimum number and maximum number of the instances of a particular image. In other words, a group</em> of instances that scale</em> auto</em>matically.</p>
In its simplest forms, it relies on the Health checks</em> to determine if any of the instances is unhealthy. In a more advanced setup, if configured, it can scale the number of instances up or down depending on the usage of the instances.</p>
Health check types</h3>
From what I understand, there are three major types of health checks that AWS provides (not counting custom health checks).</p>
AWS EC2 Status Checks</h4>
For the most basic ASG, the health checks are simply based on the EC2 instance's vitals like system power, networking issues, memory exhaustion etc. You can read more about Status checks for your instances</a>.</p>
These are default checks and are readily available to use. However, there are a couple of issues that you may see with these checks:</p>

They can only tell you about the instance or system health and not the application level health. This means that we have to rely on metrics that may not be telling the true state of your application health. For example, the CPU consumption may be low and network maybe fine but the application itself crashed.</li>
We cannot truly gauge the load on our instances and hence, scaling up or down in the number of instances may not be feasible with these checks alone.</li>
</ul>
For this reason, AWS offers a feature of adding a Load Balancer</a> in front of your instances. Amazon calls it Elastic Load Balancer</a>.</p>
Elastic Load Balancing Health Checks - Classic Load Balancer</h4>
Classic Load Balancer</a> is meant mostly for EC2-Classic network. New customers do not get this option (EC2-Classic) to launch instances anymore but it is worth writing about the limitations.</p>
The idea is simple enough — you define the CLB, you define health check and the Load Balancer does not route traffic to an unhealthy instance in the group. This is already an improvement over the EC2 Status Checks because these LB health checks let you define more granular checks and lets you rely on a "200 OK" response status of your application.</p>
The downside of CLBs is that you have only one health check per LB. If you want to have more than one health check, then you have to create new LBs and point them to the backend instances. This can grow cumbersome real fast but there are other ways to do more checks without maintaining multiple LBs. One of them is the Application Load Balancer.</p>
Elastic Load Balancing Health Checks - Application Load Balancer</h4>
Application Load Balancer</a> is a strict Layer-7 Load Balancing. It is much better than the Classic Load Balancer in many ways -</p>

Host-based routing via HTTP Host header along with Path-based routing.</li>
HTTP/2 support.</li>
Wider range of error codes (200-499).</li>
</ul>
The major point to remember is that you create target groups</em>, which each have one health check. Then you can configure a listener for ALB and provide rules to the listener that tell it to route to a particular target group.</p>
Overview of steps to create an ALB</h5>
Two major resources that you need to pay attention to are Listeners and Targets.</p>
Target Groups and health checks</h6>
Setup Target Groups</a> and configure health checks for each group.</p>
# An example of target group
</span>resource "aws_alb_target_group" "target-group-1" {
</span>  name = "target-group-1"
</span>  port = 80
</span>  protocol = "HTTP"
</span>
</span>  lifecycle { create_before_destroy=true }
</span>
</span>  health_check {
</span>    path = "/api/1/resolve/default?path=/service/my-service"
</span>    port = 2001
</span>    healthy_threshold = 6
</span>    unhealthy_threshold = 2
</span>    timeout = 2
</span>    interval = 5
</span>    matcher = "200"  # has to be HTTP 200 or fails
</span>  }
</span>}
</span></code></pre>
Listener and Listener rules</h6>
Setup a Listener</a> with Listener Rules</a> that allow you to forward the requests to appropriate targets</em> in one or more target groups</em></a>.</p>
# An example of a Listener
</span>resource "aws_alb_listener" "my-alb-listener" {
</span>  default_action {
</span>    target_group_arn = "${aws_alb_target_group.target-group-1.arn}"
</span>    type = "forward"
</span>  }
</span>  load_balancer_arn = "${aws_alb.my-app-alb.arn}"
</span>  port = 80
</span>  protocol = "HTTP"
</span>}
</span>
</span># An example of a Listener rule
</span>resource "aws_alb_listener_rule" "rule-1" {
</span>  action {
</span>    target_group_arn = "${aws_alb_target_group.target-group-1.arn}"
</span>    type = "forward"
</span>  }
</span>
</span>  condition { field="path-pattern" values=["/api/1/resolve/default"] }
</span>
</span>  listener_arn = "${aws_alb_listener.my-alb-listener.id}"
</span>  priority = 100
</span>}
</span></code></pre>
Conclusion</h3>
As you can see above, each target group has a check and the ALB listener rules decide which group to send the request to based on the rules like PATH, Host header etc. What makes it more convenient is that you always have a default rule that is a catch-all. Also, you can have multiple conditions in a rule like</p>
resource "aws_alb_listener_rule" "multi-condition-rule" {
</span>  "action" {
</span>    target_group_arn = "${aws_alb_target_group.my-specific-target-group.arn}"
</span>    type = "forward"
</span>  }
</span>
</span>  condition { field="path-pattern"  values=["/api/1/resolve/default"]               }
</span>  condition { field="host-header"   values=["example.org"]  }
</span>  
</span>  listener_arn = "${aws_alb_listener.my-listener.id}"
</span>  priority = 108
</span>}
</span></code></pre>
Finally, here is a sort of semi-complete Terraform code to get you some idea. I have also provided the code as Github Gist: AWS Auto Scaling Group with Application Load Balancer using Terraform</a>.</p>
# Create a basic ALB 
</span>resource "aws_alb" "my-app-alb" {
</span>  name = "my-app-alb"
</span>}
</span>
</span># Create target groups with one health check per group
</span>resource "aws_alb_target_group" "target-group-1" {
</span>  name = "target-group-1"
</span>  port = 80
</span>  protocol = "HTTP"
</span>
</span>  lifecycle { create_before_destroy=true }
</span>
</span>  health_check {
</span>    path = "/api/1/resolve/default?path=/service/my-service"
</span>    port = 2001
</span>    healthy_threshold = 6
</span>    unhealthy_threshold = 2
</span>    timeout = 2
</span>    interval = 5
</span>    matcher = "200"
</span>  }
</span>}
</span>
</span>resource "aws_alb_target_group" "target-group-2" {
</span>  name = "target-group-2"
</span>  port = 80
</span>  protocol = "HTTP"
</span>
</span>  lifecycle { create_before_destroy=true }
</span>
</span>  health_check {
</span>    path = "/api/2/resolve/default?path=/service/my-service"
</span>    port = 2010
</span>    healthy_threshold = 6
</span>    unhealthy_threshold = 2
</span>    timeout = 2
</span>    interval = 5
</span>    matcher = "200"
</span>  }
</span>}
</span>
</span># Create a Listener 
</span>resource "aws_alb_listener" "my-alb-listener" {
</span>  default_action {
</span>    target_group_arn = "${aws_alb_target_group.target-group-1.arn}"
</span>    type = "forward"
</span>  }
</span>  load_balancer_arn = "${aws_alb.my-app-alb.arn}"
</span>  port = 80
</span>  protocol = "HTTP"
</span>}
</span>
</span># Create Listener Rules
</span>resource "aws_alb_listener_rule" "rule-1" {
</span>  action {
</span>    target_group_arn = "${aws_alb_target_group.target-group-1.arn}"
</span>    type = "forward"
</span>  }
</span>
</span>  condition { field="path-pattern" values=["/api/1/resolve/default"] }
</span>
</span>  listener_arn = "${aws_alb_listener.my-alb-listener.id}"
</span>  priority = 100
</span>}
</span>
</span>resource "aws_alb_listener_rule" "rule-2" {
</span>  action {
</span>    target_group_arn = "${aws_alb_target_group.target-group-2.arn}"
</span>    type = "forward"
</span>  }
</span>
</span>  condition { field="path-pattern" values=["/api/2/resolve/default"] }
</span>
</span>  listener_arn = "${aws_alb_listener.my-alb-listener.id}"
</span>  priority = 101
</span>}
</span>
</span># Create an ASG that ties all of this together
</span>resource "aws_autoscaling_group" "my-alb-asg" {
</span>  name = "my-alb-asg"
</span>  min_size = "3"
</span>  max_size = "6"
</span>  launch_configuration = "${aws_launch_configuration.my-app-alb.name}"
</span>  termination_policies = [
</span>    "OldestInstance",
</span>    "OldestLaunchConfiguration",
</span>  ]
</span>  
</span>  health_check_type = "ELB"
</span>
</span>  depends_on = [
</span>    "aws_alb.my-app-alb",
</span>  ]
</span>
</span>  target_group_arns = [
</span>    "${aws_alb_target_group.target-group-1.arn}",
</span>    "${aws_alb_target_group.target-group-2.arn}",
</span>  ]
</span>
</span>  lifecycle {
</span>    create_before_destroy = true
</span>  }
</span>}
</span></code></pre>
Further ToDo</h3>

Learn more about Network Load Balancer.</li>
Comparison to GCP and Azure.</li>
</ul>


RustConf 2018 Portland OR
2018-09-03T00:00:00+00:00
RustConf has been the first ever conference for a programming language that I was eager to attend. Since, it’s a new-ish language, the conference was not as big as, say, PyCon or KubeCon would be. This made it easy to talk to people you generally only know via Twitter. Also, the duration of conference was one day (two if you include the training day). During this conference I met three kinds of rustaceans —</p>

Core team.</li>
Using Rust at work.</li>
Trying to push my boss to use Rust at work.</li>
</ol>
Out of the three categories, most folks I met were in #3, including myself. I met a bunch of enthusiasts who just showed up and I like that.</p>


“Hello everyone! Welcome to @rustconf</a> everyone! How many of you is this your first time at RustConf? [almost the whole room raises their hands] Holy s***!” —@arshia__</a> 😆</p>— Chris Krycho (@chriskrycho) August 17, 2018</a></blockquote>

Highlights (for me)</h2>

Material</h3>
I have always wanted to get hands-on security courses from the vantage of reverse-engineering, fuzzing, shellcode, and learn about the tooling around it. All of that was covered.</p>

Slides</h3>
I give extra mention for slides because Patricia’s slide-deck is so beautiful. You can get some idea of what to expect by visiting her website</a>.</p>

List of my failure modes</h1>

Not putting the correct board "feature" in `Cargo.toml</code></h2>`
Yes, when you include `embassy-stm32</code> in your Cargo.toml</code> dependencies, you need to specify the correct board ID</em>. In my case it was stm32l433rc</code>.` `See my Cargo.toml</code> for details</a>.</p>`

`Conclusion</h1> I have failed but this was so much fun! I will continue playing.</p>`

Readability</h3>

Tools</h2>

Feedback</h2>
I would love to hear what has worked for you. Is there something I am missing. Reach out to me via email or twitter.</p>
Many thanks to Jonathan Dursi</a> for constantly helping me improve this process.</p>

Types of scientific software</h2>
My experience mostly comes from genomics and adjacent areas. It is important to note that in this area, the privacy of individuals is critical and so is their data.</p>

Further ToDo</h3>

Learn more about Network Load Balancer.</li>
Comparison to GCP and Azure.</li> </ul>

Amanjeev Sethi

Banality of Grief (Poem)

Some notes on OpenWrt

Create a package for OpenWrt</h2>
I should begin by saying that in this exercise, you need a lot of GNU Make knowledge. The hell of Make will be enough for you to say no to creating OpenWrt package. However, let's look at a few things I learned during this "simple" exercise.</p>

(In)secure C++ Training with Patricia Aas

Publications

How to fail at STM32L433RC board with Embassy Rust embedded framework

Rust in Science and ever-changing requirements

A year in CanDIG project

My process for bibliography and notes

Why on Earth are copyleft software licenses bad for scientific software?

NixOS and other tools

man7.org Linux training and Google cloud virtual machines

How to document Rust's macro invocation

Solution</h3>

Capture meta</h5>
`$(#[$meta:meta])*</code> tells the macro to match 0 or more instances of meta attributes. Rust doc comment /// a comment</code> is just another way of saying #[doc = " a comment"]</code> This means that if we provide a comment in our invocation, this will now be captured.</p>`

AWS load balancers and instance health checks with terraform

RustConf 2018 Portland OR

Amanjeev Sethi

Banality of Grief (Poem)

Some notes on OpenWrt

Create a package for OpenWrt</h2> I should begin by saying that in this exercise, you need a lot of GNU Make knowledge. The hell of Make will be enough for you to say no to creating OpenWrt package. However, let's look at a few things I learned during this "simple" exercise.</p>

(In)secure C++ Training with Patricia Aas

Highlights (for me)</h2>

Material</h3> I have always wanted to get hands-on security courses from the vantage of reverse-engineering, fuzzing, shellcode, and learn about the tooling around it. All of that was covered.</p>

Publications

How to fail at STM32L433RC board with Embassy Rust embedded framework

List of my failure modes</h1>

Rust in Science and ever-changing requirements

Readability</h3>

A year in CanDIG project

My process for bibliography and notes

Tools</h2>

Why on Earth are copyleft software licenses bad for scientific software?

Types of scientific software</h2> My experience mostly comes from genomics and adjacent areas. It is important to note that in this area, the privacy of individuals is critical and so is their data.</p>

Open and accessible is the final word</h2> In recent years, the term "Open Science"[16] has become popular in our community. One of the ways Wikipedia defines it as:</p>

NixOS and other tools

man7.org Linux training and Google cloud virtual machines

How to document Rust's macro invocation

Solution</h3>

Capture meta</h5> $(#[$meta:meta])*</code> tells the macro to match 0 or more instances of meta attributes. Rust doc comment /// a comment</code> is just another way of saying #[doc = " a comment"]</code> This means that if we provide a comment in our invocation, this will now be captured.</p>

AWS load balancers and instance health checks with terraform

Further ToDo</h3> Learn more about Network Load Balancer.</li> Comparison to GCP and Azure.</li> </ul>

RustConf 2018 Portland OR

Create a package for OpenWrt</h2>
I should begin by saying that in this exercise, you need a lot of GNU Make knowledge. The hell of Make will be enough for you to say no to creating OpenWrt package. However, let's look at a few things I learned during this "simple" exercise.</p>

Material</h3>
I have always wanted to get hands-on security courses from the vantage of reverse-engineering, fuzzing, shellcode, and learn about the tooling around it. All of that was covered.</p>

Types of scientific software</h2>
My experience mostly comes from genomics and adjacent areas. It is important to note that in this area, the privacy of individuals is critical and so is their data.</p>

Capture meta</h5>
`$(#[$meta:meta])*</code> tells the macro to match 0 or more instances of meta attributes. Rust doc comment /// a comment</code> is just another way of saying #[doc = " a comment"]</code> This means that if we provide a comment in our invocation, this will now be captured.</p>`

Further ToDo</h3>

Learn more about Network Load Balancer.</li>
Comparison to GCP and Azure.</li> </ul>