Don't you just hate how boring ls is? I mean, it just spits out the names of files and folders on a line, one after the other. Come on, it's not 1987 anymore.
Let's try to make our own version, using Rust! Don't know any Rust? Go ahead and read last year's Introduction to Rust first! 🦀 I'll be waiting 🥱

Let's list some files


To get started, let's just grab all the files in our current working directory and spit them back out. Let's use the excellent walkdir-crate. Let's create our project and get going, and call our project explore 🔎



And in our src/main.rs:


And run it:


Wow, that's a lot of output! It prints all build files and .git-files, but I truncated it. Let's clean that up by changing the files we're interested in, which means hiding hidden files (e.g. files that start with .) and only show one-level of depth:


Now let's run it again:


Nice! 🎉

Oh, and by the way, I'm skipping showing you all the imports, so if you're following along, just use rust-analyzer's code actions to import them automatically.


Hold for the applause 👏


Let's add the excellent command-line argument parsing library Clap and use that to parse some input arguments. We want it to figure out the parsing, so we add the feature derive as well:


To use Clap, we create a struct representing our input arguments, slap on some attributes to tell Clap how to initialize things, and change our usages so it works just the same:


And run it again to check it still works as before:


It does! And now we can also tweak the output with --max-depth, --min-depth, --hidden and --path/-p!


Awesome!

Sizable files


Now let's spice things up by adding size output to our entries! Let's look at an entry's metadata and find out:


Looks simple enough, but that printing stuff is weird. Let's break it down: {size} will print the size variable, which is in bytes. {size:>9} means to align the number right-aligned to 9 characters in width. \t adds a tab character, which aligns the next stuff somewhat nicely. And also we add a B because the size is in bytes. Let's run it:



Sweeeet! Now we're almost on par with ls.However, at some point in time, or perhaps from the beginning, ls got support for colors. We can't be any worse! Let's add some colors to differentiate directories, files and symlinks from each other. colored looks good!


And in our src/main.rs main loop:




colored adds a Colorize-trait which gives us extension methods like .blue() and friends, but it only works on strings (&str and String), so we need to convert the output of .display() to a string, using .to_string(). If you'd inspect .display(), you would see it returns a Display-type, which implements std::fmt::Display, which is why it works without converting it to a string first. But anyway, let's run it:


Sweeeeeet!! Ehh... wait.. You can't really see the colors like that.. Give me a second... Now!


Woo! It's looking a bit bland with the size missing colors, so let's spice it with some colors too:


And rerun:


Awesome! However, this beautiful new colored output highlights a problem. 9471B? It's over 9000! We should get ahead of ourselves and format large byte quantities into something more readable. Let's add bytesize and use it!


bytesize adds B, KB or whatever, so we need to remove our B from the output. Also, since we want the formatting 123 KB first, and then color it, we need to format it using format!("{}", ByteSize(size)) and then color it green, and then print it:


Rerun time:



Nice!

Putting aside the noise


Now, I don't know about you, but I'm not a super fan about it spitting out ./ as a prefix to everything, and the whole directory path for every line of the nested files.


To fix this, let's grab only the filename and extension without all the prefixing paths to each entry before printing. To avoid printing everything on a single line and not understanding which file belongs in which directory, let's indent each file by the depth it has (the number of nested directories it is in). Also, as a bonus, walkdir gives us the directory itself as a single entry first, so we automatically understand which entry belongs to which directory! Let's make it clearer by putting it into code. Let's change our main loop code for formatting entries to:


And let's compile and run, again:


Awesome! I love the dimmed bars for indentation, too. Nice touch, Isak. 😏

Time for a change


This is a pretty nice-looking CLI-tool already! Let's spice it up to ls's level by adding some date stuff. Rust has support for dates in the standard library, but doesn't support formatting them (trust me, with the amount of weird stuff going on with dates/timestamps and the stability promises of a standard library, this is really a good thing).
Let's use chrono:


We saw earlier that each entry has a .metadata() object. It returns an Option<Metadata> and we've been .unwrap()-ping it without problem until now. This object also contains a .modified()-method that gives us a Result of a SystemTime. We've been cowboying fine so far, so let's unwrap that as well and hope it exists:


Let's add an option for actually printing the date modified, because we might not always need it. In our Options-struct, add:


Onto formatting and actually using chrono. For non-serialization formats, it's pretty nice to see which day, date and time something has changed. I don't know what you like, but my favorite RFC for those types of date formats is RFC 2822, which spits out something in the likes of Mon, 13 Nov 2023 19:18:49 +0000, so we'll just use chrono to spit out that!


Let's create a formatted_date variable that checks if the modified/-m-flag is set, and returns an empty string if it isn't. If it is, it will convert our date to chrono's DateTime<Utc>, spit out the beautiful RFC 2822 output, and then strip away the ugly + 0000-suffix, because who wants that.




We'll print out our dates in blue:


Sick! 🤩


Now let's not compare ourselves with others...


I'm not gonna lie, this is pretty similar to the output of the awesome tool exa, also written in Rust. Let's compare them!


In fact, ignoring the permissions and author of the files (because who cares about those), they're mostly the same! Except our outputs files with hidden files and directories last. This is a simple fix:


And rerun one last time!


Neeat 😎

This article is probably getting a bit too long, so let's leave it at that. Adding more features such as permissions, error-handling and so on is left as an exercise to the reader (but really can be solved by running cargo add anyhow, search-and-replacing .unwrap() with .context("describe the error")? to yeet the error out of the function, assuming you changed the main function's return type to anyhow::Result<()> and return Ok(()) at the end of the function). Huh, we almost could have done all that stuff in the parenthesis, but anyhow.


Time to feed the dog


If you want to use this program as a replacement for ls, it's super easy!
Just run:


And then a bunch of output is spat out. Afterwards it should be installed in $HOME/.cargo/bin/explore ore wherever your Cargo installation is, and assuming you have that in your path (which you should have), you can run it like this now!

Conclusion


Thanks for reading! I hope you see how easy it is to create a tool of your own using Rust and its great tooling and ecosystem. And we did all of this in... how many lines? Well, the title was a lie, we actually only used 68 lines of Rust, according to the awesome written-in-Rust tool tokei


68 lines for all that functionality! And of course some more when we include the dependencies, but oh well. Pretty nice! Doesn't make for a good title, though... Perhaps "A better ls in less than 69 lines of Rust" is nicer. Is it really a better version of ls? Probably not, but that wouldn't make for a good title either.


There's plenty more that can be done if you want to create your own version. As an example, you can add:

Permissions

Author

Date created

Options for all of the above

Support for ignoring files and folders according to ignore-files (perhaps use ignore)- And so on


Happy holidays! 🦀


A better `ls` in 100 lines of Rust

As a meeting organizer, I quite often experience that people are not aware of these useful features and strange quirks. This blog post can hopefully help you to use Outlook in a more efficient way. My experience and cases below are based on the Windows version of Outlook.

O N E 



When you tick off "all day" on a calendar event, the "show as" field automatically turns itself into "free".

Ex. You want to add a "day off" into the calendar, but when someone tries to invite you to a meeting and for instance uses "the scheduling assistant", you appear as availble.





T W O 

If you haven't heard about the scheduling assistant mentioned above, it is a tool which helps you find an available meeting slot for all your participants. 



T H R E E 

Somehow, everyone (aka default Outlook settings) thinks that 60 minutes is a perfect meeting duration. Also, some people think it is possible to get from one meeting to another without any breaks between the meetings. You can change the settings in Outlook to shorten appointments automatically. Go to File > Options > Calendar > Calendar options.





F O U R

Did you know that if you don't choose "send response now" when you answer a meeting invitation, the meeting organizer won't get any update if you're planning to come to the meeting or not. 



I use the tracking overview quite often in order to find the responses from people. 



F I V E 

Not everyone are aware that someone else can see their calendar. You can decide yourself how much you share with other people. My personal preference is that you share title and location as a default (just make sure to mark personal events as private). In general, your work calendar should not be secret. 

Pro-tip: You can share more detailed calendar information with specific people.



I hope you had a couple of new learning outcomes from the tips above. Good luck with testing them in your daily life. 

Five things you perhaps didn't know about Outlook

Arbeidsdagen har en tendens til å starte rolig for så å fylles av ting som skal følges opp. Denne luken ser på hvordan jeg bruker notatboken min og hvilken litteratur jeg har tatt inspirasjon fra.

Dette er notatboken min. Den husker de tingene jeg glemmer. Den husker prioriteringene jeg kommer frem til. Den husker hva jeg har gjort. Jeg bruker den flittig.



Jeg avslutter uken mine med å finne frem til neste doble blanke side. For selv om uka nesten er ferdig, er det mye jeg ikke har fått gjort. Og det er nettopp dette notatboka er flink til å huske for meg.



Jeg starter med å fortelle notatboken at neste uke er det uke 50.



Så forteller jeg den at det også neste uke er 5 arbeidsdager. Den siste ruta får den bruke som den vil. Det varierer fra uke til uke.



Så forteller jeg notatboka hva det er jeg ikke er ferdig med og må gjøre neste uke.


Og hva jeg skal på mandag, og eventuelt andre ting jeg vet jeg må gjøre på bestemte dager eller tidspunkt.

Med hodet tømt, kan jeg gå hjem til helg uten å være redd for å glemme noe. Notatboken min vet alt som skal skje og minner meg på det på mandag.



Mens jeg har fri, jobber notatboken min flittig. Den ønsker å fortsette å utvikle seg.

Den leste Getting things done.

Der lærte den om det å lage seg en prosess for å ta imot oppgaver på en måte som lar en følge de opp. Den lærte om å gjøre de oppgavene en kan gjøre på kort tid, 2 min eller mindre, med en gang, da det fort tar mer tid å lage en oppgave på det enn å gjøre det. Den lærte også om å bruke kalendere og andre verktøy for å organisere bestemte typer oppgaver.

Sist, og kanskje viktigst, den lærte at en bør skrive opp hva det neste steget en skal gjøre i en oppgave er. Det lar en komme raskt igang med en oppgave når en plukker den opp.



Den har studert Eisenhower prioriteringsmatrisen. For selv om Getting Things Done sa mye smart, var det lett å miste oversikten over hva som var viktig. Det hjelper ikke å være produktiv hvis en gjør feil ting.

Den lærte om også om andre metoder for å prioritere, som “The Action Priority Matrix”, som ser noe om forholdet mellom innsats og effekt for ulike tiltak.




For å lære mer om lister har den lest boka Every tool is a hammer av Adam Savage

Der snakker Adam om hvordan å tømme hode ut på papir, om å lage lister, om hvordan lage lister med lister, hvordan markere progresjon, hvordan dele opp oppgaver, og om hvordan bygge momentum. Den inspirerer også til å skape og utrykke deg.





Den har også studert Bullet Journaling. Der lærte den om å bruke forskjellige typer bullets for å formidle forskjellig behov. Den lærte også om å lage prosjektsider med notater og en index for å lettere å kunne finne frem til møtereferater og planer. Den syntes at det er spennende at en notatbok og en metodikk for å ta notater kan bli til en bevegelse som normaliserer nevromangfold og deler nyttige verktøy.





Når mandagen kommer, og en ny uke starter husker notatboka mi hvor vi sluttet uken som var. Den bruker det den lærte mens jeg var borte til å gjøre jobben min enklere. 

Jeg vet rett og slett ikke hva jeg skulle gjort uten. 








Notatboken min

Say you want to open a project in VS Code, or in IntelliJ IDEA, or maybe you want to navigate to one of several projects in Google Cloud.

If you are currently spending more than five seconds to find what you are looking for, this blog post is for you.

If you are using a Mac and you are not using Alfred, you are missing out. Alfred is a Spotlight replacement on steroids, and the free version gives you an incredible tool for searching your files or the web.

To whet your appetite, here are some useful commands:

Type "find x" to start searching for a file and then press enter, and your file will be revealed in Finder. Handy!

Type "open x" to search for any file or folder and open it in a relevant program. Spotlight can't do this!

Type "define x" to find the meaning of a word. No longer will you be ignorant of the meaning of "octothorpe", "petrichor" or "sillage"!

However, the real fun starts with the Alfred Powerpack. I promise I'm not sponsored by Alfred, it is just that good!

With the Powerpack you can make your own workflows, but more importantly you can partake in a plethora of pre-made plugins from the Alfred community. Today I will share some of my favorite workflows with you, dear reader.

Open any GitHub Repo

Find and navigate to public and private repos by entering "gh" and a search term. This one saves me a lot of time!

Check out https://github.com/gharlan/alfred-github-workflow for info on how to install it. Requires a tiny bit of fiddling (and installing PHP), but it's definitely worth it for the time it saves!

Open a project in Visual Studio Code

VS Code is perhaps the tool I use most during a working day, often jumping between folders and projects. With "code ..." I can find and open a folder as quickly as possible.

There are several workflows to choose from; I use the one from https://github.com/alexchantastic/alfred-open-with-vscode-workflow, but feel free to try any other and find one that works for you.

Open a project in IntelliJ IDEA (or any other Jetbrains IDE)

Quite similar to the VS Code one, this workflow lets you jump straight into a matching IntelliJ project using "idea ...". Can also be used with any other JetBrains IDE like PyCharm or Rider. Grab it at https://github.com/bchatard/alfred-jetbrains and start saving time today!

Open a specific service in a Google Cloud Project 

This one is probably my favorite for the amount of time it has saved me. For anyone working with GCP, I imagine your workflow to be something like this:

Open console.cloud.google.com in a browser

Navigate or search to find your project

Click or search to find your service

Unfortunately, each one of these steps have quite a delay to wait for things to load.

Now, with https://github.com/jarlefosen/alfred-gcloud-shortcuts, you only have to type "g", and it will automatically remember your most recent GCP projects and services, and let you search them. Saves me 15 seconds every time, which does add up.

I hope these Alfred tips and workflows will give you a flying start, and if you don't find a workflow you are looking for, why don't you start making your own?

Everyday hacks

A better `ls` in 100 lines of Rust

Five things you perhaps didn't know about Outlook

Notatboken min

Let Alfred accelerate your actions!