Leon Mika

On Reconcilable Difference #221, Merlin and John introduced the concept of “Best, First, Favourite”. For a particular category, which would you consider the best (i.e. closest to a perfect representation of that category, in however you define it), which would you recommend someone who’s interested in starting should experience first, and which one is your favourite.

I thought it was a fun idea, so I’ve put together a few of my own.

It was hard coming up with categories for this one, particularly when considering “best” and “favourite”. You need to have had enough experience to know what makes a good “thing”, in order to judge it against all the others and come up with a “best” one. It also helps to have enough experience to avoid picking your favourite as the best as well. I tried picking categories in which my favourite is different than what I consider the “best”. And it might be that I lack variety in my life, but the list of categories that I managed to come up with was relatively short.

Nonetheless, here they are:

Category: Mike Oldfield music

• Best: Tubular Bells 3. Oldfield was in his element here. A balanced helping of both accoustic and electronic, slow and moving, and very consistent in it’s theming.
• First: Tubular Bells 2. It may seem that Tubular Bells should be the album to goto for a taste of Mike Oldfield, and it certainty has the Oldfield signature sound. But I’d suggest considering going with this album first, as it’s a bit more refined while having the same basic structure. It’s also the album that grabbed me.
• Favourite: Crises; The Songs of Distant Earth. I’d probably put TB3 here as well, but in lieu of choosing something that I also consider the best, these two are probably my next favourite. Or it could just be the positive associations I have of them: Songs of Distant Earth reminding me of faraway places, Crises reminding me of home.

Category: Episodes of Seinfield

• Best: The Parking Garage. A refinement of The Chinese Resturant, which was groundbreaking in it’s own right. Honourable mention: The Parking Space.
• First: The Conversion. I think anything in Season 5 or Season 6 would work here. I’ve chosen this one as I wanted an episode which showcases all the character’s traits without having too many supporting character (that also features George’s parents). Honourable mention: This Bris.
• Favourite: The Busboy. This is a series 2 episode, while they were still finding their feet. But it’s one of the first where the writers manage to have multiple plot threads all wrapped up together in a cohesive whole by the end, an attribute of the writing that I absolutely love. Honourable mention: The Dinner Party.

Category: Programming text editors (for MacOS)

• Best: VS Code. I’m not a user of this myself but I can’t deny the amount of effort (and that sweet, sweet Microsoft cash) that’s going to this project. Certainly it’s the most capable out there for pretty much any language you need to work in.
• First: Nova, depending on which language you’re working in. Obviously if you’re doing anything Apple related, it’s probably best to go with XCode or something. But I think for anything else, Nova is a pretty decent text editor, and definitely one worth trying for anyone starting out.
• Favourite: Anything from JetBrains. When you feel like moving into something a little more integrated, especially for languages considered “complicated”, I can definitely recommend the IDEs from JetBrains. I use Goland in my day-to-day, with the occaional WebStorm for anything frontend that is considered large. Others include IntelliJ and Android Studios.

Category: Apple-related Tech Podcasts for anyone that has never heard a podcast before

• Best: Upgrade. I’m not much of a listener of this one anymore, but it’s still a very well-produced show, and Jason really knows his stuff.
• First: The Talk Show. I think having something a little more off-the-cuff is the way to get into the medium. You have to warm yourself into it, like you’re having a conversation with friends, and starting with something a little “produced” can leave you feeling as if you’re just another listener (which, I guess, you are but you shouldn’t want that feeling). I think the Talk Show fits the mould here. It did for me.
• Favourite: Accidental Tech Podcast. Hands down. Informative and enjoyable to listen to. This is one that I do my best to catch every episode they release.

Category: Walks in and around greater Melbourne

• Best: Sherbrooke Falls, Mt. Dandenong. This is not the longest, nor the most challenging, but it’s by far the prettiest. Walking amongst the great Mountain Ash is quite a moving experience. Be sure to have the soundtrack of the Atterborough documentary series The Private Life of Plants playing while you do.
• First: The Domino Trail, Trentham This is about an 1.5 hours out of Melbourne but a nice easy rail-trail going through the lovely forest around the Domino Creek.
• Favourite: Bushrangers Bay to Cape Shank Lighthouse: A two hour return walk that is moderately challenging with lovely scenes of Bass Strait. Don’t be surprised to run into a kangaroo or two (plus the occasional snake; look out for those).

Category: Pubs in and around greater Melbourne that make a decent parma

• Best: The Panton Hill Pub, Panton Hill. This is a good 30 km out of Melboune area, in the green-wedge in a little town called Panton Hill. There’s not much there: a few houses, maybe a shop or two, and this pub. But they do a pretty solid parma there. Good fillet, decent balance of cheese and ham, and a good portion of chips and salid. It’s been a while since I’ve been there, so things may have change.
• First: The Turf Bar, Queens St. If you’re visiting Melbourne for the first time, and you’d like to try a pretty decent parma, then I’d probably suggest trying out the Turf. It’s probably not the best pub in town: it’s more of a sports bar and can be pretty load when city-workers go there for Friday lunch or drinks. But I’ve been pretty impressed by the quality of their parmas. Be prepared to wait a little while for them.
• Favourite: The Old England Hotel, Heidelberg. This is not the best parma out there, but they’re pretty consistent. One thing going for this place is that it’s easy to get to.

Well the “big presentation” was today, the one I thought would be a good canditate for trying out iA Presenter. And after spending the last couple of weeks preparing for it, I’d thought it would be good time to give my thoughts on how it worked for me.

First, I must say that I can appreciate using an app that is opinionated. This is not a drop-in replacement for Keynote¹: the app really does try and steer you towards a particular presenting style. They’re quite upfront with this: the example shown on first launch outlines how to prepare the slides and why writing out the entire presentation in full, while leaving slides as the role of accenting your points, makes for better presentation.

I knew this going in, so it wasn’t a big shock to me. Plus it’s easy to like an opinionated piece of software when you share that opinion yourself.

This flows naturally into the second thing that I like about iA Presentation, which is the Markdown support. Using Markdown to prepare the slides is wonderful, especially when you compare it to the point-and-click content-by-bullet-point interaction style you’d find in Keynote. That WYSIWYG styles is not for me, particularly when it comes to correcting style and alignment issues that only affects one slide that sticks out like a sore thumb when giving the presentation. Markdown only means iA Presenter is left to handle the layout, and that’s fine with me.

Now, it would be nice to have even more control over the slide layout and styling. iA Presentation has very limited support for this, and while I was preparing the slides, I kept finding myself wishing that I could do more of the finer things, like adjust the font size of a code block to avoid line-wraps.

There are some things you can do, such as choose whether elements should appear below or beside each other. This is done through the use of new-lines — or lack there-of — which is a style that didn’t really gel with me. It seemed like a concept that was a little undercooked. It also didn’t help that there wa no way to actually force a new line, to do something like space out content vertically.

I don’t know how this could be improved. Maybe having a way to specify a layout or styling that is separate from the implicit styling from the Markdown, sort of like slide-specific front-matter, maybe? If done in such a way as to avoid complicating things too much, it’ll probably be welcomed.

One other thing that would be good is to have more control over separating the layout of the slides from that of the exported speaker notes. You’re essentially writing long-form content, complete with headers that’ll appear on the slide. But putting a H2 header over a H1 header to start a section would look strange in a PDF export. It’ll look fine on the slide, but that’s becasue you’re stuck using header levels (h1, h2) to control text size. Because the content on the slide is interleaved with the speech itself, the order of elements that make sense on the presentation may note for the exported PDFs.

Although I guess the solution there would be just to open the presentation in a regular Markdown editor and export to PDF. But having a one-stop solution to that would be nice. So, I don’t know: having a way to separate the symantics of the header from the size they appear on the slide would work? (Maybe all I want is just HTML, 🤷)

So, what’s the verdect? Would I use iA Presenter again? Hmm, maybe. If I’m working on a presentation with a small number of slides containing simple visual elements designed to emphasise something, such things you’d find at TED talks or an Apple keynote, then yeah, I’d probably use it again. It’s a style of presentation that the app is clearly optimised for, and it does a good job for that. If I needed slides that were a little more informative in their own right, I’d probably consider something else. Probably not Keynote, but I’d consider one of the JS+HTML options.

But it’s a really nice app² and a pleasure to use, so it’s probably worth checking out for your next presentation.

It’s been 10 years to the day when I had the opportunity to tour the Pacific as part of my job at the Bureau of Meteorology, the so call “RA-V Missions”. This last month or so, I’ve been writing about them in my journal, trying to get it all down before I forget. I had grand plans of publishing them on a travel blog, which I shelved a couple of months ago.

But while I was updating my journal, I was wondering if anyone else would find it interesting. Probably not, really: I don’t know if people enjoy reading about other peoples work trips (I can go either way, myself).

But in the off-chance that someone out there will find this story intriguing, I decided to resurrect my travel blog and publish these (moderately edited) journal entries.

If this ends up being your cup of tea, I hope you enjoy it. I may add some other trips to the site down the line (including the ones that were on the old one). I’ll let you know here if I do.

I see that Gabz, Robb, and Manique — along with many others — have posted their defaults after listening to Hemispheric Views 097 - Duel of the Defaults!, which was a really fun episode. I thought I’d do the same.

• Mail Client: Fastmail. Web-app on the desktop and app on mobile
• Mail Server: Fastmail
• Notes: Obsidian for work. It was Obsidian for personal use but I’m trying out Notion at the moment.
• To-Do: Obsidian/Notion (todos go in as notes)
• Photo Shooting: Android camera app
• Photo Management: Google Photos
• Calendar: Google Calendar
• Cloud file storage: Google Drive
• RSS: Feedbin. I mainly read it with NetNewsWire but I also use the web-app.
• Contacts: Android contacts app.
• Browser: Safari, Vivaldi
• Chat: Mainly still use Android Messanger for SMS but started using WhatsApp more
• Bookmarks: Linkding running on Pikapods.
• Read It Later: None, but if I were to start, I’d probably try out Feedbin’s RIL service.
• Word Processing: n/a
• Spreadsheets: Google Sheets, Numbers (I don’t do a lot of spreadsheeting)
• Presentations: Keynote, but giving iA Presenter a try at the moment.
• Shopping Lists: Google Keep
• Meal Planning: n/a
• Budgeting & Personal Finance: n/a
• News: ABC¹ News, in a web-browser
• Music: Alto (my own music app), Spotify
• Podcasts: Pocketcasts
• Password Management: 1Password
• Photo Editing: Google Photo
• Weather: Bureau of Meterology website.
• Social Clients: Tusky (Mastodon)
• Code Editor: GoLand (Jetbrains in general), Android Studios, or XCode
• Text Editor: Nova
• Hard Quiz Expert Subject: Probably the music of Mike Oldfield.

Scored myself based on the rules of the game and came up with 44 points. It was a little tricky as I’ve got both feet in separate ecosystems.

This question was posed to me in the Hemispheric Views Discord the other day. It’s a bit notable that I didn’t have an answer written down for this already, seeing that I do have pretty concrete reasons for why I really like Go. So I figured it was time to write them out.

I should preface this by saying that by liking Go it doesn’t mean I don’t use or like any other languages. I don’t fully understand those that need to dislike other languages like they’re football teams. “Right tool for the job” and all that. But I do have a soft-spot for Go and it tends to be my go-to language for any new projects or scripting tasks.

So here it is: the reasons why I like Go.

First, it’s simplicity. Go is not a large language, and a large majority of it you can keep in your working memory. This makes Go easy to write and, more importantly, easy to read.

It might seam that a small feature set makes the language quite limiting. Well, it does, to a degree, but I’d argue that’s not a bad thing. If there are only a couple of ways to do something, it makes it way easier to predict what code you’re expecting to see. It’s sort of like knowing what the next sentence will be in a novel: you know a piece of logic will require some dependant behaviour, and you start thinking to yourself “how would I do that?” If the answer space is small, you’re more likely to see what you expect in the actual code.

But just because Go is a deliberately small language doesn’t mean that it’s a stagnant language. There have been some pretty significant features added to it recently, and there are more plans for smoothing out the remaining rough edges. It’s just that the dev team are very deliberate in how they approach these additions. They consider forward compatibility as much as they do about backwards compatibility, being careful not to paint themselves into a corner with every new feature.

Type parameters are a great example of this. There were calls for type parameters since Go 1.0, but the dev team pushed back until they came up with a design that worked well for the language. It wasn’t the first design either. I remember one featuring some new constraint-based constructs that did about 80% what interfaces were doing already. If that were shipped it would’ve meant a lot of extra complexity just for type parameters. What was shipped isn’t perfect, and it doesn’t cover every use case type parameters could theoretically support. But it made sense: type parameters built on interfaces, a construct that already existed and was understood.

This, I think, is where C++ fails to a huge degree. The language is massive. It was massive 30 years ago, and they’ve been adding features to the language every few year since, making it larger still. I see Apple doing something similar with Swift, and I’m not sure that’s good for the language. It’s already quite a bit larger than Go, and I think Apple really should curb their desire for adding features to the language unless there’s a good reason for doing so.

The drive for simplicity also extends to deployments. Go is compiled to a static binary, one that is extremely portable and could be easily deployed or package as you so desire. No need to fluff about with dependencies. This is where I found Go having a leg-up over scripting languages, like Python and Ruby. Not because Go is compiled (although that helps) but that you have less need to think about packaging dependencies during a deploy. I wrote a lot of Ruby before looking at Go, and dealing with gems and Bundle was a pain. I’m not a huge Python expert to comment on the various ways that language deals with dependencies, but hearing about the various ways to setup virtual environments doesn’t fill me with confidence that it’s simple.

And I will admit that Go’s approach to this isn’t perfect either. For a long while Go didn’t even have a way to manage versioned dependencies: they were all lumped into a single repository. The approach with modules is better, but not without some annoyances themselves. Any dependency that goes beyond version 1 requires you to change the import statement to include a vX, an unnecessary measure if the version change is backwards compatible. That’s not even considering packages that avoid this, and are forever on version 1 (or 0).

But since moving to modules my encounters with package dependencies issues remains quite rare, and once you’ve got the build sorted out, that’s it. No need to deal with packaging after that.

And I’d argue that Go rides that sweet-spot between a scripting language like Python and Ruby, and a compiled language like C (maybe Rust, but I know very little of that language to comment on it). It’s type safe, but type inferences make it easy to write concise code without excessive annotations everywhere. It’s compiled to an executable, yet memory is managed for you. I won’t talk about how Go does concurrency, but after dealing with Java threads for several years, using them are a joy.

I should probably balance the scale a bit and talk about areas where I think Go could be made better. The big one is error handling. While I do like the principals — that errors are values and can be handled as such — it does mean a lot of boilerplate like this:

foo, err := doThis()
if err != nil {
  return err
}

bar, err := doThat(foo)
if err != nil {
  return err
}

baz, err := doAnotherThing(bar)
if err != nil {
  return err
}

To the Go teams credit, the are looking at improving this. And I think there’s enough prior art out there for a solution that’ll look pretty nice without having to resort to exceptions. Maybe something like Swift’s guard statement, that can be used in an expression.

And yeah, other areas of Go, like it’s support for mobile or GUI-style programming and lacking a bit. That could probably be plugged with third-party modules to a degree, although I think because Go is not an object-orientated language, the seals won’t be perfect (take a look at Go’s implementation of QT to see how imperfect Go maps to a toolkit that assumes objects). And some gaps need to be plugged by Google themselves, like with mobile support (they do have something here, but I’m not sure to what degree they’re being maintained).

But I’m sure most of these issues are surmountable. And no language is perfect. If Go doesn’t work for a situation, I’ll use Java or Swift or something else. “Right tool for the job” and all that.

So these are the reasons why I like Go. And I think it all boils down to trying to keep the language simple while still being useful. And as far as my experience with Go is concerned, those maintaining it are doing a pretty stellar job.

Opened my work email this morning and received a greeting from the following spam messages:

• Webinar to “overcome the fear of public speaking” from some HR Training mob
• A training course on “accelerating innovation in data science an ML” (there’re a few emails about AI here)
• Webinars from Stripe, Slack, and Cloudflare about how other companies are using them
• Weekly updates about what’s happening on our Confluence wiki (this probably could be useful… maybe? But our wiki is so large that most updates are about things other teams are working on)
• A training course on some legal mandates about hiring (honestly, my email must’ve appeared on some mailing list for HR professionals)
• Another webinar from the first training mob about dealing with “employees from hell”

Marked all as read, closed email, and opened Slack.

John Gruber on the Pixel 8 launch event:

It’s also impossible not to comment on just how much less interest there is in Google’s Pixel ecosystem. […] On the one hand I’m tempted to say the difference is just commensurate with how much better at hardware Apple is than Google. But I think there’s more to it than that. There’s something ineffable about it. There are aspects of marketshare traction — in any market — that can’t be explained by side-by-side product comparisons alone.

Can’t speak for the market but as a Pixel 6 Pro owner I can give you my opinion. You don’t need to watch the keynote to get that sense of disinterest. You can get it just by using the phone.

For the last few months¹ I’ve been experiencing a bug with the calendar widget. If you have nothing on your calendar for the next two weeks, it completely blanks out:

I doubt that this is intentional as the plus button doesn’t work either. Tapping it does nothing at all.

For comparison, here’s how it’s meant to look:

Now, bugs in software happen — they certainly happen in mine — and there’s no reason why Google would be immune to this, so I can forgive them for this bug showing up in a shipped version of Android. My problem is that it’s been like this for months now. This is a widget built by Google, included in Google’s Calendar app running on Google’s OS and Google’s hardware, and it’s been broken for this long. I would’ve expected this to be fixed in a few weeks, but for it to take this long?

I can’t see how anyone with an Android phone using this widget would not notice this. And the only reason I can come up with is that no-one in Google has noticed this. They simply don’t use Android, the OS that they build, in their day-to-day. Maybe some of them do, but obviously not enough of them to drive change. If there was, they would’ve found this problem and fix it by now. To quote Linus, “given enough eyeballs, all bugs are shallow,” and those eyeballs are obviously looking elsewhere.

Now this theory may be far fetched, but after reading Gruber’s piece, it seems like I’m not alone in thinking this. As he says later in the same article:

I’d wager that more Google employees carry an iPhone than carry a Pixel.

It shows.

There will be certain things you’re going to need to do in your development environments that you should never do in production. That’s pretty much a given: playing around with user’s data or potentially doing something that will cause an incident is generally not a good idea.

But there are things you shouldn’t do in prod that you may need to do in dev. And make no mistake, there may be a legitimate need to do these things. Using Auth0 and only have a limited number of emails available for your test environment? You may need a way to quickly reset a user. Support billing in multiple countries and need to do a test in one of them? You’ll need a way to change the user’s countries.

And I think that’s fine. Not every environment needs to be a reflection of production. As long you’ve got a staging or pre-prod environment where you can do things like rehearse deployments. But everything else should be skewed towards ease of development, which will mean making these drastic options available and easy to use.

Found this plaque while passing through Southern Cross station this morning.

I didn’t have time to read it, and the subject matter looks really interesting to me (Trains? Power Lines? What’s not to love? 😀). I also don’t know how long it’ll be up for, and I’ve been burned in the past of not capturing something when I had the chance.

So I’m posting photos of it here for posterity reasons. Enjoy.

I had an alternative idea for today’s photo challenge, which is “orange”. I was hoping to post a photo of something related to Melbourne’s busses.

You see, PTV has designated different colour for different modes of transport. Blue for metro trains, purple for regional trains, green for trams, and orange for busses. And from my experience using the service, they’re pretty consistent with adhering to this design language:

Anyway, they’re doing train works along my rail line over the past few weeks and this morning I noticed this sign (forgive the lighting, it was before dawn):

It’s not the first time I saw this sign, but I had orange on my mind and the fact that it mentioned busses got me thinking, “how cleaver, they’re maintaining the design language through and through, using an orange sign to reference the bus service that would be replacing the trains.” Or so I thought, until I saw this sign:

Ah, that blew that theory out of the water. And also the opportunity to use it as today’s photo. I mean, I could’ve still used it — it’s still orange after all — but it doesn’t have the neat adherence to the design language that I was hoping it did.

The thing about building tools to automate your work is that it’s hard to justify doing so when you’re in the thick of it. Easy to see all the time you save in the aggregate, but when you’re faced with the task in your day to day, you’re just as likely to say “I can build a tool which will let me do this task in a couple of seconds, but it’ll take me an hour to build it verses the 5 minutes it’ll take for me to just do the task.”

So you just “do the task.” And the next time you get that task, you face the same dilemma.

Of course the alternative is spending the hour to automate it, and then never running that tool again (or investing more time than you save keeping it up to date l).

I’m not sure what the best answer is. Maybe tracking times where you wish you had that tool you didn’t build somewhere? Then, when you’ve done it at least 3 times for the same thing, you have supporting evidence that it’s worth automating. Maybe include the time it took to do it manually as well, so you can compare it to how long it might take to build the automation.

Might be worth a try.

Still doing the code first, tests after at work and I’m really starting to see the benefits from it. Test driven development is fine, but most of our recent issues — excess logging or errors that are false positives — have nothing to do with buggy business logic. It’s true that you can catch these in unit tests (although I find them to be the worst possible tests to write) but I think you gain a lot more just from launching the application and seeing it run.

Now granted, it’s not always possible to do this with micro-services. There’s always some dependency you need, and setting all these up is a bit of a pain. That’s probably why I deferred all my manual testing to the end, when I’ve pushed my changes to get them reviewed and deployed it to the environment. Do a quick cursory test from the frontend just to make sure it hasn’t broken anything, then move on to the next task.

I think this way of working was a mistake. This is something frontend developments get right: you need to run your software while you’re working on it. It’s so important to see not just how well it works, but how it feels to work¹: what goes to the log, how fast it performs, etc. You don’t get this feeling from just depending on unit tests.

Plus, there’s always a nice buzz to see the thing you’re working on run for the first time. That magic seems to decay the further you are from where it’s running. It just becomes another cog in the system. And maybe that’s what it’s destined to be, but it doesn’t need to be this way while you’re working on it.

Ben Thompson has been writing about the Reddit strike in his daily updates. I like this excerpt from the one he wrote yesterday:

Reddit is miffed that Google and OpenAI are taking its data, but Huffman and team didn’t create that data: Reddit’s users did, under the watchful eyes of Reddit’s unpaid mod workforce. In other words, my strong suspicion is that what undergirds everything that is happening this week is widespread angst and irritation that everything that was supposed to be special about the web, particularly the bit where it gives everyone a voice, has turned out to be nothing more than grist to be fought over by millionaires and billionaires.

That, though, takes me back to Bier’s tweet; the crazy thing about the Internet is that said grist is in fact worth fighting over.

It’s easy for me to say this, as I’m not a user of Reddit, but I have full sympathy for the striking moderators.

You spend much of your free time volunteering to keep a community on a site, producing value for it’s users and owner, with the expectation that the site would recognise your efforts and reciprocate by serving your needs with, say, an API. I can understand how enraging that would feel when they turn around and “alter the deal” while expecting the mods to continue as if nothing has changed.

So good on the moderators showing that they too have leverage.

And as to OpenAI using the API to train its model: well yeah I can understand the CEO of Reddit feeling shitty about that, but I would’ve hope he would have the ingenuity to solve that while maintaining the needs of those that actually provide value to the site. Either he doesn’t which, given that he’s one of the founders, I find hard to believe; or he just doesn’t want to.

It’s time to be honest: I think overseas travel is wasted on me.

We were driving down from Antibes to Genova today. It was a nice trip, complete with picturesque towns passing us by as we drove along the motorway. My friend was oohing and ahhing at each one: remaking about how nice it would be to see them, stay in them for a while. He was also remarking on what we would do when we arrived at our destination. There was just this air of enthusiasm about the whole thing.

I didn’t feel that enthausiasm. We heard some news that another friend of ours had their luggage stolen, and I just couldn’t stop thinking about it. I spent a fair bit of last night going through possible ways on how I could avoid it happening to me, and how I would handle it if it did, and just the whole hassle of dealing with that possibility.

This, mixed with the inevitable task of finding my barring in an unfamiliar place, stressing about how I would interact with the locals in their non-native language, the ongoing recovery from Covid-19, and a bit of home-sickness, and you can probably guess that I’m just not feeling the vibe of adventure at the moment.

And yeah, I might have done this to myself, particularly since I haven’t had much to do with this part of the trip.Happy to “go with the flow” of what others are doing. And people might ask me “oh, wouldn’t it be good to see this?” or “wouldn’t it be fun to experience that?” Yeah, maybe? I might get some enjoyment out of it, but I’m not sure if it’ll offset the stress I feel with the logistics of it all.

So that’s where I am at the moment. It’s got to the point where I’m contemplating coming home early. It would actually simplify my itinerary quite a bit, and I won’t be leaving my friends in the lurch: it would be a portion of the trip where I would be travelling by myself. Even with a week less, that’s still about 4 weeks in total, which I think it’s plenty, or at least plenty for me.

Update 30 June: Apart from taking a slightly earlier flight home, I ended up staying the the full 5 weeks. And in retrospect, I’m really glad I did. I figured that I would regret not visiting the places I’ve would’ve cut out if I were to go home early; and after visiting them, I know now that I would’ve missed out on some of the most memorable parts of the trip.

I think what sparked this post was a mixture of anxiety of travelling alone and little bit of home sickness. But nothing beats anxiety like working through the problem (if you can call travelling solo a “problem”). And as for home sickness: well, I’m not sure there’s much I can do about that apart from remembering that home will always be there.

More custom styling of Obsidian today. This snippet turns off fixed-width display of notes, so that they can span the entire window. Useful if you’re dealing with a bunch of wide tables, as I am right now.

body {
    --file-line-width: 100%;
}

div.cm-sizer {
    margin-left: 0 !important;
    margin-right: 0 !important;
}

I wish I could say credit goes to ChatGPT, but the answer it gave wasn’t completely correct (although it was close). The way I got this was by enabling the developer tools — which you can do from the View menu — and just going through the HTML DOM to find the relevant CSS class. I guess this means that this’ll break the minute Obsidian decides to change their class names, but I guess we’ll cross that bridge when we come to it.

While going through my archive about a month ago, I found all my old Basic programs I wrote when I was going through school. I had a lot of fun working on them back in the day, and I though it would be nice to preserve them in some way. Maybe even make them runnable in the browser, much like what the Wayback Machine did with the more well-known DOS programs.

So I set about doing just that, and today the site is live: F5 To Run.

And yeah, it’s likely that I’m the only one interested in this. No matter. I’m glad they’re off my dying portable drive and preserved on the web in some fashion.