Hey everyone! I’m excited to introduce Kwarks — a sleek new puzzle app for iOS that challenges your abstract-reasoning skills in a way even advanced AI finds tough.

How it works:

You’ll study sequences of 5×5 grid patterns, uncover the hidden logic, and pick the correct next pattern from five options. Ready to see if your human intuition still rules?

Features:

• 150+ unique puzzles across easy, medium & hard difficulty.
• AI-resistant logic that keeps the game human-centric.
• Minimalist design, no distractions—just you vs. the pattern.

Whether you’re a puzzle lover, prepping for assessments, or just want a smarter way to kill 5 minutes between meetings—you’ll enjoy this. And if you’re a software engineer hoping to keep your pattern-matching muscle in shape—it’s especially for you.

Download it here: App Store link

💡 Feedback welcome! If you spot a pattern that’s too sneaky (or too easy), I’m all ears.

Thanks for taking a look, and happy puzzling—may the best human brain win.

#Kwarks #AbstractReasoning #CognitiveTraining #AppLaunch #PuzzleGame #BrainTeasers

Cel podróży: Rio Miranda, Mato Grosso do Sul (Pantanal)

"Nie czytaj na głos: armia tu jest, dlatego nie ma mięsa z krokodyla. Carne do Jacare é proibido."

Takimi słowami szwagier zaczął obiad pisząc je w swoim telefonie i pokazując mi go ukradkiem nad swoim talerzem. Mieliśmy dzisiaj spróbować mięsa z kajmana, lecz pech chciał, że owy zakazany smakołyk nie był tego dnia dostępny, mimo że w menu widniał dumnie na pozycji nr 5. Przyjechaliśmy do restauracji Hotel e Restaurante da Cida, w której dzień wcześniej próbowaliśmy bezskutecznie zostać na noc. Szwagier miał nam załatwić miejscówkę do spania w miejscu, do którego już raz niegdyś przyjechał na ryby kontaktując się z Doną tegoż przybytku przez WhatsApp, ale tym razem nie dostał od niej żadnego potwierdzenia, o czym niechcący zapomniał nas poinformować przed przyjazdem w środku nocy do ciemnego zaułka z wydawałoby się opuszczoną budą nad rzeką, która jedynymi gwiazdkami, jakie widziała to te, które nocą widać przez dziury w dachu obok przylepionej na ścianie kumkającej sobie z zadowolenia ropuchy.

Na całe szczęście po dobrych 20 minutach starania się obudzić naszą Donę, krzycząc, pukając, waląc w drzwi i trąbiąc klaksonem samochodu nikt nam nie otworzył i byliśmy "zmuszeni" znaleźć prawdziwy hotel, a nie budę, w której zatrzymują się zdesperowani rybacy. Ja i szwagierka byliśmy zdecywanie uradowani faktem, że znalezienie dwugwiazdkowego hotelu w środku nocy po uprzednim przejechaniu około 30km przez początek puszczy Pantanal do miasta, żeby znaleźć zasięg w telefonie trwało zawrotne 3 minuty i pare kliknięć w aplikacji mobilnej Booking Do tego mogliśmy spać spokojnie wiedząc, że większość zwierzaków-futrzaków z liczbą nóg od zera do ośmiu z równie zróżnicowaną liczbą kłów i szczękoczułek zostało po drugiej stronie serii pięciu zamkniętych po sobie nocą drzwi.

***

Płynąc łódką przyszedł mi do głowy fakt, że po 16 godzinach lotu wrzeszczącym samolotem, po ponad 15 godzinach jazdy wrzeszczącym samochodem z zepsutymi zegarami mierzącymi prędkość i stan paliwa, z wrzeszczącymi pasażerami, popłynęliśmy wrzeszczącą łódką z małej wrzeszczącej wioski, by w końcu zakotwiczając gdzieś na zakręcie rzeki zaznać... ciszy. Prawdziwej ciszy. Nie takiej ciszy gdzie w tle słuchać radio Miranda i przytłumione głosy lokalnej ludności cywilnej, tylko takiej, która wypełnia uszy ciepłem i przyjemnością zdaję się prawie zapomnianej już sztuki usłyszenia własnych myśli. Chwilę po tym jak piszczenie w uszach ustało i kiedy mój mózg w końcu jakby zaczerpnął powietrza uszami, do środka wtargnęły inne brzęczące dźwięki owadów, baratas, cigarras i innego rodzaju koników polnych, które przez lata przystosowały się do otaczających ich wrzeszczących ludzi.

Na ryby popłynęliśmy z zestawem wędek szwagra. Każdy z nas, w ciuchach z wielką, komicznie wyglądającą rybą i napisem Pescador na koszulce i spodniach własnoręcznie zdjętymi z manekina dzień wcześniej. Po drodze nad głowami przelatywały nam dwie błękitne ary z długimi falującymi ogonami, a wracając, podziwialiśmy lecącego w śmieszny sposób tukana. Kolorowy ptaszor wyglądał trochę niezdarnie, trzepocząc skrzydełkami jak koliber z odrobinę za ciężkim i nieaerodynamicznym dziobem w kształcie sierpa. Naszą tajną bronią okazała się minhoca* (czyt. minioka). Minhoca to taka olbrzymia dżdżownica, która idealnie nadaje się do łowienia gigantycznych ryb w Rio Miranda, ale niestety jest to oficjalnie zabronione z uwagi na jej bycie zagrożonym gatunkiem. Co z drugiej strony nie znaczy, że nie można jej po prostu kupić w każdym sklepie wędkarskim pytając czy nie mają państwo może isca prohibida* (pt. zakazanej przynęty) płacąc dwanaście Reali brazylijskich, czyli odpowiednik mniej więcej dziesięciu naszych złotych. Jedyne co trzeba zrobić to tylko na wszelki wypadek się odwrócić, by sprawdzić czy gdzieś za plecami nie panoszy się pan policjant z lokalnego przystanku policji leśnej, środowiskowej lub militarnej.

Mówią, że ryby głosu nie mają, ale te tutaj zdecydowanie wydają dźwięki, jak na przykład zgrzyty pancernej skorupy sumika Armau, który obcina palce ostrzami pod pachami, gdy go chwycić pod ramię. Są też i te bardziej znane. Piranii specjalnie przedstawiać nie trzeba. Te tutaj w teorii nie jedzą ludzi. Te z żółtym brzuszkiem są całkiem milusińskie. Wyglądają bardzo podobnie do rybki Paku mającej uśmiech podobny do tego od człowieka zważywszy na podobne uzębienie. Piranie, z zębami przypominającymi bardziej piłę do drewna, w ostatnich latach się rozprzestrzeniły, gdyż ich naturalnym konkurentem w łańcuchu pokarmowym są kajmany. Tych za to w dzisiejszych czasach coraz mniej, jako że ludzie stwierdzili, że idealnie nadają się na buty i torebki, bo są takie mięciutkie w dotyku. Połów piranii polega na wrzuceniu linki z haczykiem na kijku od bambusa z malutkim kawałkiem świeżego mięsa, który po mniej więcej dwóch sekundach zaczyna gotować wodę od stada szybko poruszających się i rozrywających na kawałki przynętę pływających morderców.

***

[TBC]

There is no one "best" DMG format as each format has its own advantages and disadvantages depending on your specific use case. Here are some of the most common DMG formats used in macOS:

1. UDIF: This is the default and most widely supported DMG format. It supports compression, encryption, and segmented images. However, it is not as efficient as other formats when dealing with large files.
2. UDRO: This is a read-only format that is suitable for distributing software or data. It is smaller in size than the UDIF format because it does not support compression or encryption.
3. UDZO: This format supports read-only compression and is suitable for distributing large files over a network or loading from disk. However, it can take longer to create and may require more processing power.
4. UDBZ: This format supports read-write compression and is suitable for storing frequently accessed files on a disk image. However, it can take longer to read and write files to the image.
5. UDCO: This format supports copy-on-write compression and is suitable for creating disk images that are updated frequently. It is fast and efficient, but it can be complex to set up.

Ultimately, the best DMG format depends on your specific needs and use case. If you need to distribute software or data, then UDRO may be the best option. If you need to distribute large files, then UDZO may be the best option. If you need read-write access, then UDBZ or UDIF may be the best option.

What's the most typical DMG format used for distributing apps over the internet?

The most typical DMG format used for distributing apps on the internet is the UDIF format. This is because UDIF is the default and most widely supported format by macOS, making it easy for developers to create and distribute apps in this format. Additionally, UDIF supports compression and encryption, which can help reduce the size of the DMG file and provide added security. UDIF is also compatible with a wide range of third-party tools and utilities, making it easy for users to open and use the DMG file on their Mac. Overall, UDIF is a reliable and widely supported format for distributing apps on the internet.

Are any DMG file types not supported by older versions of MacOS?

Yes, some of the DMG formats may not be fully supported by older versions of macOS. Here is a breakdown of DMG format support by macOS version:

• UDIF: This format is supported by all versions of macOS.
• UDRO: This format is supported by all versions of macOS.
• UDZO: This format is supported by macOS (OS X) 10.2 and later.
• UDBZ: This format is supported by macOS (OS X) 10.4 and later.
• UDCO: This format is supported by macOS (OS X) 10.5 and later.

It's worth noting that while a particular DMG format may be supported by an older version of macOS, some features of that format may not be supported. For example, older versions of macOS may not support encryption or certain types of compression for a particular DMG format. Therefore, it's important to consider the specific features and requirements of your DMG file when selecting a format to ensure compatibility with the intended audience.

What does it mean for MacOS in 2023?

It's worth noting that, MacOS was renamed from OS X in 2016 which I would like to remind you is already 7 years old.

• OS X 10.2, also known as Jaguar, was released on August 24, 2002.
• OS X 10.4, also known as Tiger, was released on April 29, 2005.
• OS X 10.4, also known as Leopard, was released on October 26, 2007

These are fairly old versions of MacOS and are not so widely used any more. That being said if you'd like your application to support quite old versions of the operating system it is something you'd want to consider when building DMG files.

Change to 64-bit architecture only

Starting from macOS 10.15 Catalina (released in October 7, 2019), the default architecture for macOS only supports 64-bit applications. This means that 32-bit applications are no longer supported by default on macOS Catalina and later versions. Prior to macOS Catalina, 32-bit and 64-bit applications were supported, but Apple had been warning developers for several years that 32-bit support would be phased out. The shift to 64-bit only architecture is part of Apple's ongoing efforts to improve performance and security on macOS.

Change from x64 to ARM with M1 processors

Apple first introduced the ARM-based architecture for their Macs with the release of the M1 chip in November 2020. The M1 chip is based on Apple's ARM-based A-series chips used in iPhones and iPads. With the release of the M1 chip, Apple began transitioning its Mac lineup to ARM-based architecture, starting with the MacBook Air, MacBook Pro, and Mac Mini. The transition is expected to take a few years, and during this time, Apple will continue to support and release new versions of macOS for both Intel-based and ARM-based Macs.

Today in 2023, Intel-based Macs are still quite wide-spread so your application should be build for both x64 as well as the still relatively new M1 ARM CPUs.

Are UDCO files smaller than UDZO when compressed?

In general, UDCO files can be smaller than UDZO files when compressed because UDCO uses copy-on-write compression, which can be more efficient than read-only compression used by UDZO. With copy-on-write compression, the data is stored in blocks, and if a block is unchanged from the original data, it is not duplicated. Instead, the block points back to the original data, reducing the amount of storage required.

However, the actual compression ratio and resulting file size can depend on the specific data being compressed. For example, if the data being compressed is already highly compressed, such as a ZIP archive, then the compression ratio may not be as significant, regardless of the compression format used.

Ultimately, the choice of compression format depends on the specific use case and the type of data being compressed. Both UDCO and UDZO have their own advantages and disadvantages, and the best choice depends on the specific needs of the user.

With all that in mind, which format is best for me?

As mentioned above, it all really depends on the type of application you are building. Newer DMG file formats might not be supported by older versions of MacOS but the choice ultimately comes down to your needs. The most important question are:

• Do you need to support read-only or read/write types of DMG files?
• Do you want to use compression?
• Do you need to encrypt your DMG files?

At the end of the day the choice is up to your personal preferences and the nature of the application being distributed.

Use QuickTime to trim audio files on your Mac without any extra additional software. The feature is baked into your operating system just like a lot of other cool features you mightn't have known about.

Open the QuickTime application:

Select your audio file from the file browser

Once your file is opened press CMD+T or go to Edit > Trim...

Trim your audio file accordingly just as you would a video on iOS and press Trim

And that's it! You now have a shorter audio file you can Export in File > Export

Happy trimming!

Cześć!

Here's something that I found out today. Well, it really wasn't today but rather in 2020 when the Xiaomi MiBand 4 was the latest smart band from the Chinese electronics company. Putting together a smart band watch face is as simple as putting together a bunch of pictures and a JSON descriptor file, linking them all together and running the WF_Builder app. Heres what a Chased by Penguins themed watch face looks like. Pretty neat huh?

The band files can be found on GitHub here . I'll pop over the source in the same place at a later stage.

Flexbox is quite a powerful tool once you get a handle on it. I found the Complete guide to Flexbox missing a particular edge case I needed, illustrated here below.

My use case was to only wrap the first and last columns in a flexbox so that on a mobile phone view they would wrap from the sides inwards like the picture illustrates here:

Turns out the CSS Trick to do this is quite straightforward.

First we need to define our HTML code to wrap our 3 internal divs with a single container wrapper.

<div class="wrap">
    <div class="a">A</div>
    <div class="b">B</div>
    <div class="c">C</div>
</div>

Next, some CSS magic:

.wrap {
    display: flex;
    flex-wrap: wrap;
    justify-content: space-between;
}
.wrap > .a {
    background: #0f1e33;
    order: 1;
}
.wrap > .b {
    background: orange;
    order: 2;
    flex: 1;
}
.wrap > .c {
    background: #53a8e1;
    order: 3;
}
@media screen and (max-width: 500px) {
    .wrap > .b {
        background: orange;
        order: 1;
        min-width: 100%;
    }
    .wrap > .a {
        background: #0f1e33;
        order: 2;
    }
    .wrap > .c {
        background: #53a8e1;
        order: 3;
    }
}

And if you really want to spice things up with some colours:

/* Backup CSS code */

body {
  font-family: 'Roboto', sans-serif;
  font-weight: 400;
  font-size: 26px;
  color: #141414;
}

.wrap {
    display: flex;
    flex-wrap: wrap;
    justify-content: space-between;
}
.wrap > .a {
    background: #0f1e33;
    color: white;
    order: 1;
    padding: 10px;
}
.wrap > .b {
    background: orange;
    color: white;
    order: 2;
    flex: 1;
    padding: 10px;
}
.wrap > .c {
    background: #53a8e1;
    color: white;
    order: 3;
    padding: 10px;
}
@media screen and (max-width: 500px) {
    .wrap > .b {
        order: 1;
        min-width: calc(100% - 20px);
    }
    .wrap > .a {
        order: 2;
    }
    .wrap > .c {
        order: 3;
    }
}

Has this been helpful to you?

You can support my work by sharing this article with others, or perhaps buy me a cup of coffee 😊

OK, it's been a while using the Apple Watch and I thought I might say a few words to give it some credit. Overall it's been very good to me. I think I'm generally healthier and move my butt a lot more effectively than I used to on a day-to-day basis. Never before did I go for a walk out in the cold, wet and dark night just to move a little, which now also allows for listening to podcasts, audiobooks and of course "Closing My Rings™️".

How does it compare with a smart band?

My smart wrist band story started with a Xiaomi MiBand 4 which proved to be a life saver in the confined life during the 2020 coronavirus pandemic. I got it a couple of months before the crazy started and even then it was an interesting little device which primarily showed my step count for the day and lasted for weeks on a single battery charge. Having something like that is a no brainer, especially that it costs in the region of €30 and allows you to see a little bit more into your daily life routine. With the smart band, I started walking a bit more and it gave me a quick view into how many steps did I take on a given day. It also solved another problem, which is: I don't always have my phone with me, especially at home. This meant that the difference between sitting on the couch for a couple of hours vs walking around the house, cooking, cleaning or doing other things you don't typically use your phone with hasn't been recorded. As it turns out, even standing up a little to get a coffee adds up throughout the day. It showed the periods of inactivity during the day when I needed to focus and the times I was going to grab a snack. It turned out to be a helpful unobtrusive way to see into my own life. When summer came and the days were longer and the mornings weren't as chilly, I started to run every working day morning to stay sane during the full lockdown period. It proved invaluable in those days. A morning routine like that seriously helped to alleviate the growing mental unease.

The smart band has its limitations however. The morning routine was fun but I felt like I can do better. I got myself a pair of wireless AirPods to remove the need for sticking cables into the phone every morning and being annoyed with pulling on cables throughout the run. The AirPods solved that problem but the one with the phone remained. As mentioned before, having the smart band was a great way to get rid of the phone and yet still have the benefits of tracking my daily life in an unobtrusive way. Removing the phone on the run removed two aspects I didn't want to lose:

1. Music: Running without a soundtrack is just not as fun, and I found that I got bored a lot easier and didn't push myself as much as I did with a nice motivational track.
2. GPS tracking: Less important, because it is possible to measure the length of the run just using the accelerometer in the device, but it didn't seem as accurate in the long run. I wanted to see how much progress I was making in a more reliable way. The next generation of the MiBand does have a GPS tracker and a bit more functionality nowadays. If you're looking for an entry level smart band to start your adventure, in my fairly limited and biased opinion, that's the way to go.

Enter Apple Watch

I decided to get an Apple Watch as an experiment. I've had a Moto 360 smart watch for a little while and when paired with an Android phone it was quite fun to use, though I had to disable the constant buzzing on both my wrist and in my pocket so that I wouldn't go insane. Buzz buzz buzz...

I was excited to see what happened in the world of smart watch tech in the couple of years. As it turned out, quite a bit!

The freedom of not having a phone

This is the reason I bought the Watch. Has it stood up to the task?  
- Absolutely yes.

As this was the sole reason to buy the watch and use it for working out, it has been the tool for the job. Running with music, podcasts, audiobooks, walking with meditation apps, from a physical health device perspective it solved all of the issues.  After a little research I went with the bigger 44mm, Wifi-only version. I have tried both the smaller and the bigger one in a shop felt like the bigger one would be just as good, especially that it has a bigger battery which should last longer. After using it for a good couple of months now, I still think I'd like to try out the smaller one for a while to see if it would be more comfortable. It is quite a bulky machine on the wrist and being white it tends to be a little too "showy". Still, even with that, I do wear it every day. Next time I'll probably go with a smaller version. Mainly because even though it's a very powerful device, it's literally like a phone on your wrist, it is not a watch. It's still expanding and it's becoming more and more a health device, like a smart band on steroids that does multiple things well. It won't be a super accurate running device tracking all of your stats. It will be your running partner. Something you grow to like over the time you use it.

Should I buy the Wifi or LTE version of the Apple Watch?

To add a little on connectivity. The GPS works perfectly well on the Wifi only version and so does Apple Pay which turned out was a nice addition. After my bank finally decided to add support for Apple Pay, I stopped taking my wallet to the shop and I find myself paying with the watch most of the time for almost anything. In Ireland, Apple Pay doesn't have limits on the transaction amount, like the €50 on typical contactless transactions with your card. Which means you can buy coffee, groceries or a TV using your Watch.

TL;DR: Apple Pay works offline. You don't need internet connectivity on your Apple Watch to pay for groceries.

When it comes to connectivity, the only time I find it would be useful to have the 4G version is when I want to stay in touch with the world, when waiting for an important text or an email or generally when going for a walk at lunch time. That's when I do take the phone with me and that sorts out the issue. On the other hand, it's good to be able to disconnect sometimes but still be able to take music or an audiobook with you.

How do I listen to music on the Apple Watch?

Since we're on the topic of phone-less music, what can I do with watch you, might ask. Well, it turns out quite a lot. You can synchronise your own iTunes playlists for offline listening. While there are apps like Overcast or Audible which synchronise their content when the watch is on your wrist, most of Apple's content: Apple Music, Podcasts, etc. synchronise when the Watch is put onto a charger. Why that is I am not quite sure, the most compelling reason must be battery optimisation and the fact how the WatchOS communicates with iOS as it isn't just as straight forward as all processes running in the background on all the time. Some apps also say that putting your Apple Watch on a charger will speed up the process of sending data between the phone and the watch. It can be a bit frustrating at times when you want to sync something specific NOW. The watch works best if you let it do its thing in the background. Subscribe to a podcast or make a playlist available offline and let it synchronise whenever it's charging or whenever it feels is most appropriate to do so. This way you don't feel it and content appears on your wrist. I do find that some of my podcasts are missing sometimes or they are not completely in sync.

When it comes to audiobooks, you have Audible. It downloads the books to the watch and treats them like a copy. The app does need a little bit more work. The offline (on Watch) vs online (on Phone) players are different and don't synchronise fully when they need to and it generally feels like the app was made once by somebody who wanted to support the Watch but never went deep into the core of how WatchOS works internally to make it work as good as it could. It does what it should but it's quite buggy. There have been times when I opened the audible app and the On Phone player showed me the song I was playing through Apple Music before opening the app. Most of the time it works though and I haven't seen a good alternative yet so I guess we're stuck with it at the moment. I would also like to see other audiobook apps, like for example Audioteka.com to release an app for the Watch so that I could listen to books in Polish for example.

Music-wise, you do get Apple Music. There have been some news that you can now use Spotify to stream music directly from your Watch without the phone but since I don't use Spotify any more, I am yet to find out how that works. Maybe it's release on a per-region basis. With my free subscription I don't seem to be able to stream content when my phone is not around and my Watch is connected to wifi.  As of writing this post the only way to store music for offline is Apple Music, having a playlist downloaded to your phone or perhaps use a podcasting app to subscribe to some music podcasts. Apple Music is a little different to Spotify, there are ways to make it work if you're thinking about moving. You can sync your playlists and the content discovery however different, still exists. You do get a 3 month trial so it's worth a shot just to check it out fore if it's for you for free. Music handling of Spotify on the watch is really good too. It's a solid app to control your home speakers for example. It works blazing fast. You can play music to any device connected to your account.

Sports

Nike running app

It's one of the most well-thought-out fit for purpose 3rd-party app on the Apple Watch. I has four quick look screens showing your latest runs, starting a run, guided runs and a settings screen. During the run you can get prompts in the regular or guided runs and you get quick access to workout controls such as pausing, resuming, etc., your running stats as well as quick access to the built-in Music Player. You can control the music volume using the digital crown just like in most music players on the Watch.

Apple Workouts App

The Nike running app is one of the best apps out there for running there's no doubt about that. Sometimes however you might want to go for a swim, or an outdoor walk in which case the app to use would be the built-in Workouts app. It has a ton of workouts built-in and there are new ones being added in every once in a while with software updates. Additionally, the Workouts app is not as selfish with some of the data like the GPS tracking points which in case of the Nike app is not saved into Apple Health's activity repository data. GPS tracking from the Workouts app can then be imported into other apps like Google Fit or Strava. I find the swimming tracking pretty good and better than the Swimming activity tracking on the MiBand which would only give you the main swimming style instead of sharing all of them.

AirPods or any other bluetooth headphones

The Watch does have a speaker but you wouldn't be able to use it to play music while working out, nor should you do it as it would drain the battery, annoy everybody around you and you wouldn't be able to hear the music properly anyway. The watch works great with AirPods as they are small enough to put them in and get out of the house with just the watch. At times the bluetooth connectivity can do some funny things, especially if you're near the house but not quite inside. I found that with some 3rd party apps (especially Amazon's Audible) the phone would sometimes steal my music when I pass near the house or better yet play the audiobook on both devices and give my wife a bit of a scare when randomly starting to talk in the dark room.

Activity rings

This might be the most recognisable feature of the Apple Watch. It doesn't only count your steps like most other smart bands out there but looks at your active burnt calories. You burn calories by raising your heart rate level to a certain point and generally by 'moving'. This is why the red circle is called the Move ring.

The green Exercise ring shows the Active Exercise minutes. You can earn them by running a workout or by doing some moderate activities which will raise your heart rate to around 100 BPMs. A brisk walk would do that, a run is even better. Doing a couple of flights of stairs might earn you a bit of the green ring also.

The blue ring counts the hours in the day in which you were Standing and moved just a little bit. Standing up without moving much might count as a "standing hour". The watch can also remind you it's time to stand up if you've been sitting down for too long by a notification and a gentle nudge.

All of these setings can be edited so that you can hit goals that are more appropriate for you.

The watch still measures your steps count just like any other band, so if you were joining a work steps competition you can still do that and get relatively accurate results with some extra data.

Battery life

As we've been living the pandemic life, the battery hasn't been a problem. The Watch would last for about a day and a half generally with a moderate use with workouts, GPS tracking, Apple Pay payments almost every day. Going away proved pretty OK too. The battery charges pretty fast and I generally like to keep it between 30%-60% during the day anyway to make sure the battery keeps happy and is not overcharged or left undercharged for too long either. I would generally charge it in the morning or right before going to sleep to be able to track my sleep quality.

The Nice-to-Have's

Sleep tracking

I tend to sleep with the Watch on my wrist to track my sleep quality using Pillow. This is where the smaller one would come in handy as the bulky size can be a little annoying at times at night in which case it lands on the nightstand nearby. It's still comfortable enough to sleep in though. The watch would also send you a gentle reminder that it's time to go to bed, and if necessary will remind you to charge it before doing so.

Alarm clocks

I really like the alarm clock slightly tapping me on the wrist to wake up instead of a buzzing alarm clock. You will need to set your watch to Silent mode to make sure it won't also wake everybody else in the house. Having it linked to sleep analysis is a nice feature.

So long passwords...

When using a MacBook Pro, unlocking the laptop is really neat. Once paired and set up to trust each other, all it takes to log into the device is to press any key and be close enough to it. It's secure enough that it won't just unlock even if you're standing 1-2 metres away from the laptop.

Breathing

Now this is pretty interesting. It goes into the list of nice to have and low-barrier mindfulness. 1 Min = 7 breaths. And you feel a little better because of it. Useful in lockdown times.

Control Keynote

You can do that. There are 3 hoops you need to jump through and the connection is finicky but it works. Is it really better than a clicker? Not sure yet. Probably won't be needing a clicker for a while in today's world

Shortcuts

Recently I also found that I can do a lot more using shortcuts. It's the little things that you would think some apps would do for you but don't. Like caffeine intake. How many cups of coffee do you drink a day?

Other 3rd party apps... Games?

As the Apple Watch has its own App Store now, you can download apps directly on from the watch. There aren't many choices yet as it's quite a niche device and there's only so much it can do, but you are able to get a browser, if you're into that, many sleep tracking apps, sports apps... and then, there's this...
because of course who wouldn't want to play a mini-football game on a mini watch screen.

Short answers to complex questions. To check the schema version of a moor created database you will need to use a PRAGMA statement. As the documentation puts it:

The PRAGMA statement is an SQL extension specific to SQLite and used to modify the operation of the SQLite library or to query the SQLite library for internal (non-table) data.

Long story short, moor uses the default name for the sqlite schema. In SQLite, the default schema is called `main`. Running the PRAGMA `schema_version` command on the main schema will do the trick!

PRAGMA main.schema_version;

Read more on migrations at the official moor plugin documentation here: https://moor.simonbinder.eu/docs/advanced-features/migrations/

Read more on SQLite pragma statements at: https://www.sqlite.org/pragma.html#pragma_schema_version

For a while now, I've been coding a little in Dart by writing a Flutter mobile app. It's a very fun and easy to follow React-ish, SwiftUI-ish kind of language in which you can easily create beautifully looking applications with minimal effort by describing the UI a self-enclosing objects and functions. So far so good.

After leaving my tutorial Candyland and starting to write real code I hit a couple of walls and had to come back to re-read what I've just learnt. Coming from a JavaScript / Node.js environment background I was struck by the amount of types, data types, function types, return types... ugh, why can't everything just be a var like in my hippy language?! Well.. it kind of can... but not really... Dart is... well, special. It also has a const, a final and a static which are kind of similar but... no, they are really completely different and they confuse me and everybody in my current office. For clarification I'm going to add that since it's the beginning of 2021 that makes it literally just me in the home office , because we're at a Level 5 lockdown and I'm stuck at home and the only person to talk to about code return types is Mr Rubber Ducky.

In case you are unfamiliar with the concept of Rubber Ducky Debugging, let me introduce you.

Enough babbling, let's go one by one for my own benefit to get to know the types. What I want to know is: What is the difference between a final and a const in Dart?

For Numbers, Strings, etc, I would like to send here: https://flutter-examples.com/list-of-all-data-types-available-in-dart-flutter/

Const

From what we know from programming, a constant value is one that doesn't ever change, and if you do try to change it your code will blow up. Now, in Dart there's a little bit more to it than that. In Dart a const is a specific value that is assigned once at compile time. What this means in practice is, a const in Dart should only really hold things that are set in stone and not dynamically generated. A good example are some reusable numbers, strings, doubles, etc. Once the value is assigned at compile time, it is baked into the app code and is stored in zeros and ones. A const cannot hold any dynamically generated data, like for example a Date.now() or a `Color` widget because this value won't be known to the compiler ahead of time.

// You can do:
const a = 10;

// But this will fail
const b = DateTime.now();

// A common use case for example could be reusing a colour like so:
const myConstantColour = Color('0xFF1D1E33');

Final

So whats a final in that case? A final in Dart acts more like a const in JavaScript you know and love. A final is an immutable value which can only be assigned once at any given time. It can hold any value which is assigned once and then never changed again. It's something of a loose constant which you'll see appear in your code a lot.

Static

The post wouldn't be complete if we didn't mention the keyword static.

Used in a Class context, a static value is static to the Class. Which means in human terms that the value should be accessed statically from the Class like in this example:

class Ducky {

static String material = 'Rubber';

}

In this case, in another object the static value will be referred to through the Class itself not through the instantiated object (i.e. Ducky duckyObject = new Ducky() in this case)

Ducky.material == Rubber

While considering hosting applications on IBM Cloud you might be tempted to use Node.js and Cloudant in your application stack. Cloudant is one of the most commonly used NoSQL database on IBM Cloud. It's based on Apache CouchDB and hosted in the cloud. If you're using Cloudant in your application you should consider using streams.

Tip: for development purposes you can run a local instance of CouchDB and your app will be mostly compatible with it.

Handling big queries

When it comes to querying data from a database, the frequently spotted attitude of "let's just run this query and return the data in an API and it'll be fine" can lead to serious bottlenecks and cause trouble when the queried data turns out to be a lot bigger than anticipated. Querying hundreds of megabytes of data from a database is generally a bad idea and in most cases can and should be avoided. The memory burden and performance cost of each request can be quite high and can lead to unexpected consequences. In simple terms, every time you make a query your data needs to be stored somewhere to be processed.

What does this 'memory usage' mean anyway?

Take a typical REST API database query example from any available tutorials out on the inter-webs. For demonstration purposes we'll make one adjustment. Let's assume that your database has 30,000 medium sized JSON objects and for some good reason you want to return them all at once without pagination (and not just because you made a terrible mistake when you designed the system in the first place; never thinking there will eventually be so many records in there...).

What happens in this instance is, you make a request to an API endpoint which queries a database for some records. The application waits for the database to go through its tables or collections (1st bottleneck) after which the data is send through the network (2nd bottleneck) to the application and stored in a variable (3rd bottleneck). As this variable is stored somewhere in memory, it means there is a single object of 600MB of JSON data in your app which will be eventually returned through your API (4th bottleneck). Only then it can be safely disposed off by the garbage collector. In a typical example, it's a very synchronous process. It takes a some time to make the query, pass the requested records to the app, handle them in the app and eventually pass the results to an API endpoint. If you're lucky enough this process can lead to a timeout of said API endpoint before the data starts to download through it. Before it gets to that though, your app will most likely blow up.

NodeJS streams to the rescue

According to the Node.js documentation:

A stream is an abstract interface for working with streaming data in Node.js. The stream module provides an API for implementing the stream interface. There are many stream objects provided by Node.js. For instance, a request to an HTTP server and process.stdout are both stream instances. Streams can be readable, writable, or both. All streams are instances of EventEmitter.

In other words, we can use a stream to prevent data clogging by making the data pass through the app bit by bit, instead of synchronously passing gigantic numbers of records at a time. Did I already mention it's a bad idea?

Pipes

The official Cloudant Node.js library includes streaming as standard. Functions such as List() or Find() have equivalents with a *AsStream suffix. Instead of a Promise they return a request object which may be piped as a stream. For example:

cloudant.db.listAsStream()
  .on('error', function(error) {
    console.log('ERROR');  })
  .on('end', function(error) {
    console.log('DONE');  })
  .pipe(process.stdout);

Note that there are no callbacks when using the streams functions and event listeners must be used instead.

Below we'll build a fully fledged example to test the streams in action.

First, let's set up a simple express app and pass along the Express response object to a newly created service. Let's call it dbService.js.

const express = require('express');
const dbService = require('./dbService'); // We will create a service next

const app = express();

app.get('/', (req, res) => {
  dbService.getRecords(res); // Passing the express res object to dbService
});

app.listen(3000).on('listening', () => console.log('Listening on port 3000'));

The application will import a dbService module and pass along the express response object. The response object is a stream which means you can pipe a stream of data into it. Here's the dbService in full:

const Cloudant = require('@cloudant/cloudant');
const cloudant = Cloudant('https://username-bluemix:password@username-bluemix.cloudantnosqldb.appdomain.cloud');

module.exports = {
  getRecords(res) {
    const db = cloudant.use('your-cloudant-db-name');

    const querySelector = {
      selector: {
        something: {
          $eq: 'here',
        }
      }
    };

    db.findAsStream(querySelector)
      .on('error', (error) => {
        console.error('ERROR', error);
        // Make sure you end your request on error
        // as otherwise the API will hang
        res.end('Error finding data');
      })
      .on('end', (error) => {
        if (error) {
          console.error('ERROR on DONE');
        }
        console.log('DONE');
        res.end();
      })
      .pipe(res);
  },
};

The getRecords() function assumes there is a JSON document in your Cloudant collection* called 'your-cloudant-db-name' which looks something like this:

{
  "something": "here"
}

*Collections in cloudant are called 'databases'.

The findAsStream() function returns a stream object which can be piped to the res object. We should also end the response after the read is finished on the end event as well as on an error to prevent the API from hanging.

And that's it, it's fairly easy to take the burder off your strained application.

Leave a comment below if you like this example and let me know if there's anything you'd like me to cover next.

Cześć!

Has this been helpful to you?

You can support my work by sharing this article with others, or perhaps buy me a cup of coffee 😊

As we're all stuck and home and as far as productivity goes, apparently we're still doing pretty alright. But let's face it, there are times where you need to brainstorm some new ideas and a whiteboard has always been the simplest goto utility we could grab and draw a couple of boxes to explain what's on our mind. Being a visual person myself, sometimes it's just easier to draw a bunch of boxes on a piece of paper or a napkin to understand the idea being discussed better.

There are many helpful tools out there in which you can doodle and put together some quick designs with your colleagues or friends. There's Mural.ly, InvisionApp, Slack now has a quick drawing on everybody's screen sharing feature which I love and Zoom and WebEx themselves actually each now have a built-in whiteboard feature.

However, none of them give you the same freedom of expression and dynamics as a piece of paper or a whiteboard on a wall which everybody can see and using a mouse is just not the same. The closest available remotely utility would be to draw on an iPad screen using a stylus pen.

The good news here is, if you're a proud owner of a Mac and an iPad you don't need any extra apps. Just use your operating system's built-in functionality.

TL;DR - You don't need any extra apps! Just use QuickTime and Apple Notes!

To show your iPad's screen on a Mac you don't need any extra tools. QuickTime on MacOS Catalina has a built-in feature which allows you to Record a Movie using an iPad's screen plugged in to the USB port on your desktop.

Important: Plug in your iPad to your Mac using a USB cable before doing this.

There's no need for any extra apps or spending unnecessary €€€s. QuickTime allows us to show the screen before recording and doesn't block the view with any buttons. Once you move the mouse cursor away from the window all it shows is the iPad screen and your doodles. Nice and clean!

You can record the screen for reference if you like, but there is no need to do it. Now when you share your screen on any Zoom or WebEx call, you can also draw on an iPad whiteboard and make the most out of it!

The app shown in the demo screenshots above is called Notability. It's great for note taking in general. It enables you to move things out of the way and has an endless paper feature, so you'll never run out of space. You can also doodle in Procreate or just plain old Apple Notes. The possibilities are endless because all you're doing is just sharing what's on the iPad screen. All you need to do is hop on that Zoom call and get going.

Angry Birds anybody?

Has this been helpful to you?

You can support my work by sharing this article with others, or perhaps buy me a cup of coffee 😊

When approaching the useEffect hook in React and to be fair hooks in general, the first thing is to forget what you think you know because you will get confused and you'll try to include a square block in a circular hole. When approaching creating components in React you should probably already be thinking "reactively" if you're not already doing so. What it means and how does it fit within the useEffect hook as an example is something that many front-end developers already know and will find this completely obvious. On the other hand, it took me a while to understand the concept of a reactive component enough to be able to explain it to a grandma in one or two sentences. The moment you create a self-enclosed component with its own Axios API calls based on the props you pass to it feels really good. I could finally say "I get it" now. So here's the deal. For those of you who don't yet grasp the concepts, building your lego blocks in React can be done the ugly way - creating a standalone piece of code with a class component and an API call in the constructor, coming from an older version of Angular this was the concept I initially understood, - the OnInit() function is being run when the component builds. That's great, it used to work fine with the older concepts, but that's not how it's done any more for a good while now and you may think you're doing it logically right when in fact that's not the way to go in React (nor is it Angular any more btw for a long while...).

Effects

Did you know you can add many useEffects listeners to a single component? Did you know sometimes you have to add more than one if you want to tie in state changes together? A 'side-effect' as it's nicely called by the documentation is basically something that happens when the state of any of the items in the dependency array changes. You can throw in some props or state variables and (and this is important, because the eslint will keep annoying you) functions which are used in the effect. The change of a variable is pretty self-explanatory, it's pretty cool when you tie in a variable to an API call and it calls and updates everything for you automagically. This automagical way ties in to our Reactive way of coding. We observe changes and then do something when that change happens. It is quite a paradigm shift which can be seen increasingly in other languages, like Swift or Flutter or even good old Java with RxJava or RxJS in JavaScript.

Our good old friend ESLint will also suggest to include a reference to the function in the dependency array of our useEffect(). When it comes to functions, what you need to know is if they are included within the main body of the functional component, on the next render their memory reference will change. This means that it will technically be a different fetchMyDataStuff() function than the one you first rendered. This is why you might also get another ESLint suggestion to enclose your fetchMyDataStuff() in a useCallback effect. The documentation explains it with a very clear Returns a memoized callback. which for those of us who prefer plain English means that the enclosed function will be stored in memory, so that it doesn't change every time you re-render your component.

As Wikipedia explains: "In computing, memoization or memoisation is an optimisation technique used primarily to speed up computer programs by storing the results of expensive function calls and returning the cached result when the same inputs occur again. Memoization has also been used in other contexts (and for purposes other than speed gains), such as in simple mutually recursive descent parsing.^[1] Although related to caching, memoization refers to a specific case of this optimisation, distinguishing it from forms of caching such as buffering or page replacement. In the context of some logic programming languages, memoization is also known as tabling.^[2]

Going by this logic, the useCallback function being memoised will not only prevent your linting errors from annoying you, but more importantly, it will cache your function and speed up your app's performance.

So components?

To conclude, when writing your app in React and building component, hooks or no hooks, try to think about it as a self-enclosed piece of logic which depends on the prop data you provide it AND what's more important here, asynchronously changes by reacting to the changes in the web app and re-renders itself and its content without the need for external handling. Otherwise things get out of hand very quickly.

If you followed part 1 of this guide you should have a local eslint check script on your git repository and a pre-commit hook that prevents you from uploading dodgy code to Github. In this part we will look at one of many ways you can work with Github, taking into account code reviews and working in a team. We will enable the same eslint check in our secondary stage in Travis CI on a Pull Request (from now called a PR). This is the point before the code gets merged into the main repository; a place where you would usually review the code and check for potential mistakes, typos and generally bad code you might've missed. This is what we'll use Travis for.

Set up a Github repository

Before we continue you will need to create a new empty Github repo. I created one initialised with a README.md file.

We will plug the newly created remote Github repository to our local git folder from step 1. To do that we will need to add a remote in our local git. To be in line with the standards we will call it origin. Open your git folder and run the command below:

$ git remote add origin https://github.com/YOUR_USERNAME/REPO_NAME.git

This will connect the local repository to the remote which will enable you to push code over to Github.
Note: this is using the HTTPS method to fetch and push to simplify the steps in this post. You should familiarise yourself with the SSH method which in the long run is easier to work with, mainly beause you won't have to type in your login details all the time.

Agile workflow with Github

There is no right or wrong way of using Github really. The way you use it though generally depends on the size of your team. As a single user you could use a single master branch and use the repository as a one-to-one mirror of your local folder. That's perfectly OK, but by doing so you won't be able to use the full potential of git and Github.
In our case, we'll extend the single user work flow with an extra check & review layer, which will come in handy if the team grows. We'll introduce the concept of branches and pull requests. It also gives you the ability to take another look at your own code in context before it's merged with the master repo.

Here are a few concepts that you will need to know.

Branches

Git branches are effectively a pointer to a snapshot of your changes. When you want to add a new feature or fix a bug—no matter how big or how small—you spawn a new branch to encapsulate your changes. [Atlasian]

We will use branches to encapsulate a single task we want to tackle. This way we'll be able to come back to it any time. We will also be able to revert it easily if something goes wrong.
In my previous post I wrote about Github Projects and how you can use it to manage your project. Let's say the first task is to push the code that we wrote earlier to a Github repository. We will also include a file to enable Travis at the pull request stage.

Let's first fetch the latest changes from the remote and then create a branch in our local git repo folder with the git checkout -b [task_number] [remote_branch] command:

$ git fetch origin
$ git checkout -b task_1 origin/master

These commands will do a couple of things. Our local repository will download all the changes from the remote repo, but won't merge them into the master branch. The second command will create a copy of the remote repo on a clean branch called task_1, it will then put everything you already had in your folder on top of that. Keep in mind doing stuff this way might cause merge conflicts. In our case that shouldn't matter because our remote repository at this stage should be empty.

The default branch in git is called master and the origin is typically your own repository fork.

In case you were working with more people you could create an organisation level repository, which other team members (including yourself) would fork in Github, in a way creating seprate remote instances (origins). In our case we only have a single remote repository so we can disregard this.

Two things to keep in mind - first, we will now refer to the remote repository as the origin. Second, the master branch is our production branch. That being said, we will deploy the production ready code from the master branch.

Commits

A commit is a packaged delta of your local changes. It can be a single file, or a bunch of lines in many files. This also includes removed lines! Git is flexible when it comes to the number of commits on a branch. I tend to stick to a single commit on a single branch, because it makes it easier to review code, but it's not a rule.

Push

A push is a git command that takes all commits on your current branch and pushes them to the remote repository. It can create a branch you pushed on the remote if it doesn't exist yet. You can also push to an existing remote branch.

Pull request

A pull request is a piece of code you want to suggest to copy over from one branch to another. As an example in the above workflow it would be the new task branch being pulled into the master branch. Notice that the code is pulled into the master and not pushed directly to it. It is a suggestion that can be rejected, amended or closed without resolution. At this stage team members would usually request each other to take a look at the code before it gets merged into the master branch.

Using Travis we will be able to test the code in this PR in context of what branch it's getting merged into before it is approved. Some quick quality checks can go a long way and speed up the review process.

Here we set the second barrier.

Second barrier

A pull request (PR) can be blocked from merging into the master repository if the code is not good enough. That is if any checks like eslint, unit tests, end-to-end tests, etc. fail the quality control. Using Travis we are able to run these checks here. Another advantage of merging code this way is that if there were more than one PR at the time and they had conflicting changes i.e. two people made changes to the same file at the same time, this fact would be caught here and block the user merging code before resolving the conflicts.

Travis

Let's add a new file to enable Travis here. We will call it .travis.yml.

$ touch .travis.yml

Then add in the code below:

language: node_js
node_js:
  - "10.15.3"
install:
  - npm install
script:
  - npm test

We will set the language of the scripts to Nodejs version 10. This is the current LTS support version as I write this. This could be any newer even numbered version if you read this at a later stage.
The install: will be executed before any of the scripts run. We will only have single commands in each of them but you can run anything you like. As this is a YAML file you can list script commands in a dashed list. If you'd like you could run a full end-to-end test suite here. In our case, we will run the npm test command which at the moment only runs the eslint tests. If we ever extend the test command, Travis will pick it up automatically.

Travis checks will get picked up and show in the PR as a green tick if your code passes the lint tests.

Push to Github

OK, so we're at the stage where we can start adding in some code to our commit and push it into the remote to see if we set the barrier correctly. If you followed the previous post you'll have a commit hook and eslint set up in your local repository. We will need to add in the new files to the commit and push the extra travis file to your remote repository, in our case also being the origin. We can do that easily with the git add . command

$ git add .
$ git commit -m "[Task 1] Push some files to repo and enable travis"

After the commit check runs you will need to push the local commits to your remote repository. This will create a new branch in your origin called task_1 just like your local branch

$ git push origin task_1

We will now move over to the browser and open up your Github repository.

Github source control stage

Create PR

Your Github repository should automatically show a yellow box on the top of the code page showing the newly created branch. Press the green button to Compare [code] & [create a] pull request

PR review page

In Github your PR should look something like this. If you scroll down you can see your commit and all the changes you made in files added to this commit. The description is optional. You can now press Create pull request.

We are almost there. Your PR should now be there, waiting to be reviewed. This is where you can possibly assign some reviews if you'd like. Send somebody the link to the PR and they could look at the changes in context of the whole code, which makes it really handy.

Enable Travis checks

The PR is created, files are there but something is missing. Well, Github doesn't automatically add any app integrations, but it's nice enough to suggest them in your PR. Click on Several apps are available and add the Travis Github App to your Github repositories.

Once you're done you will see the Travis page. To check if everything is added properly to the repository you can take a look at your repository Settings tab. In the Integrations & services section you will find the Travis CI app.

Is it running yet?

Almost. The PR we already created will not be picked up because we enabled Travis after the fact. The checks will run on the next push. Let's create another commit and push it into the same branch.
You can make a small change to your code now. Let's add a comment at the end of the lintMe.js file.

You can then git add the file, create another commit and push.

$ git add lintMe.js
$ git commit -m "[Task 1] Run travis now"
$ git push origin task_1

Now your Travis checks should be picked up by the app and your eslint tests will run.

You can see both of your commits and the checks below in yellow. Yours will most likely have two checks on branch and PR. Once they're finished they will either give you a green tick, or a red cross depending if the files that you pushed were passing the eslint checks. If you did follow part 1 of this guide your commit hooks should prevent you from pushing changes that won't pass in Travis.

If they are failing, you might want to check if you pushed the package.json file and Travis is running the npm install and npm test scripts correctly. Also make sure you don't push your node_modules/ folder because that could cause trouble.

Two ticks or one tick?

By default you'll see two ticks here rather than just the one in the screen shot. This is due to the fact that Travis is running a build on the branch and a build on the Pull Request.

You can go to your Travis page by clicking on the Details link in the PR. In Travis / Settings you can deselect the option to run builds on branches if you don't want to.

You could potentially leave it ON, and for example utilise some of the deploy capabilities of Travis. This is something I will talk about in the next post, which will be about the Third Barrier at the deployment stage. I will also mention how to run your app in IBM Cloud / Bluemix.

Preventing broken code from getting merged

For a meaningful PR status check we can do one more thing. In the repository settings you can block the PR from getting merged into some of your branches. As we decided that the master branch is going to be production code, we wouldn't want to push anything to this branch if the status checks are not passing. It's a small thing that could be overwritten with administration privileges, if you really want to, but it will be screaming at you that it's broken, just in case you didn't notice the red X crosses everywhere.

You can do it in the Branches section of your repo Settings.

Oooff! OK, this was a long one, but I hope it was somewhat useful. As usual more to come.
Stay tuned.
Cześć!

Has this been helpful to you?

You can support my work by sharing this article with others, or perhaps buy me a cup of coffee 😊

Working with NodeJS sometimes you get to see some strange things in your dev environment. For example, when working with Cloud Foundry your apps would automatically assign a port number to the running app and sometimes mess up your configuration when working with other people on the same project. But worry not, here's the answer. The (in)famous ports module.

Why do my Cloud Foundry app ports keep increasing exponentially?
~ Peter (2018)

Turns out the IBM platform-as-a-service platform using cloud foundry cli (now ibmcloud and before that also bluemix-cli or bx) uses a handy little node module called ports.

Where ports comes in is it assign your package.json app name to a port number and then remembers it whenever you run a new app. Where it also comes in handy is, whenever you run a new app, it increases the port number by 1 each time you run a new app that takes into account the cfenv.port ENVIRONMENT VARIABLE.

Once you dig through the code you find that the ports module stores the port numbers in a JSON file in your home folder - on Mac ~/.ports.json or if you're using Windows it would be under your %USERPROFILE%/.ports.json which would typically translate to c:\Users\Peter or something like that. You can use the ports.json file to assign your apps a PORT instead of running the EXPORT PORT=XXXX.

{
    "6001": {
        "name": "MicoDashboard"
    },
    "6003": {
        "name": "BikeStand"
    },
    "6004": {
        "name": "automation-workshop"
    },
    ...
    "6013": {
        "name": "Innovation Sandwich"
    }
}

Sample config you might find.

Have fun Noding. Cześć!

I noticed a lot of people using some specialised apps just to unzip archives on iOS. I downloaded some zipped fonts from Google Fonts to use with Affinity Photo and then got stuck. I looked online and most websites recommend getting some extra apps. I noticed that there is a handy share option in the iOS built-in Files app preview section. I will show you step by step how to go about it.

Step 1: Download the zip file into a folder on the iPad or iPhone

Step 2: Open the file and press on Preview Content...

Step 3: Once in preview, press the Share button in the top right corner

Step 4: You can now save the previewed file directly back to your Files

Step 5: Choose the location for the unzipped file and press Add

Step 6: Congrats, file unzipped!

There you have it. Font file unzipped! At the moment when writing this on iOS 12.1 you will still need a third party app to compress files into a ZIP archive.