@bytesnz
Jack Farley, Computer Engineer

  • home
  • about
  • 12/11/2022

    Please! Stop with the mobile web sites! If you are using browser agent strings to change your CSS/layout don't! Use responsive CSS instead. There are other situations when you need a small window and devices that have a small screen where your web site does not work.

    • software
    • web
  • Minimal Accessible Tooltip

    12/1/2022

    Doing a lot of accessibility (a11y) fixes, I wondered what would be the minimum amount of code to create a WCAG 2.1 compliant custom tooltip. Unfortunately, it had to include Javascript. Here is what I can up with.

    • software
    • web
    • a11y
  • Day-to-day with Librem 5

    11/28/2022

    After quite a few years of waiting, I finally got my Librem 5 phone. I am now using it as my primary phone… using my work phone as a back-up. Here are the issues and whether I think using it as a primary phone is a good idea so far.

    • librem5
  • 11/28/2022

    If you are wanting to apply accessibility labels onto an image, here are the label (alt, title, aria-description, aria-label) priorities (highest first): aria-description (with aria-label, alt or title); aria-label; alt. Note aria description does not get read out if there is no other label attributes. (Tested on Windows, NVDA, and Firefox and Edge).

    • software
    • web
    • a11y
  • Email dates in Javascript

    11/24/2022

    Javscript is missing functions to format dates in some common formats, such datetime-local inputs and RFC 5322 (email dates) in a non-obsolete way. While Date.toUTCString() is close, the timezone is now obsolete (though it is handy for HTTP Date and other such headers). Here's the basic functions to get the right formats

    • software
    • javascript
  • Visibility and CSS Accordians

    11/24/2022

    When changing a reworked menu to have accordian animations, I came to the realisation that I have been missing a big issue when using max-height transition animations — accessibility. I detail a simple fix in this article.

    • software
    • web
    • a11y
    • css
    • javacsript
  • Can't touch list

    11/24/2022

    Turns out screen readers really don't like you playing with the display CSS property on lists, for example to change it to an inline list — it will cause lists items to be read like a paragraph. Here's how to do without upsetting the screen readers.

    • a11y
    • software
    • css
  • New Zealand Low Power Networks (LTE-M & NB-IoT)

    10/14/2022

    I have started experimenting with low power wide area networks (LP-WAN) in New Zealand using a u-blox SARA-R410-02B. Here is what I have experimented with so far.

    • electronics
    • software
  • JS Binary Decoder

    10/11/2022

    I have recently been dealing with parsing binary data packets from various sources, and have published two NPM libraries from it: binary-decoder and sbd-direct-ip. Here's how they came to be.

    • software
    • javascript
  • Starting with ESP32

    2/7/2022

    I started developing my trap-watch project on an ESP32-CAM using the ESP IDF. Here is the newbie difficulties I ran into.

    • esp32
    • electronics
    • software
    • trap-watch
  • VIM Window Rabbit Hole

    2/4/2022

    Developing ESP-IDF components I thought it would be great if I could make a command to open all the files for a component at once. What a rabbit hole it was. Here is how I did it.

    • linux
  • Parsing Arguments in Bash

    1/28/2022

    Making a script parse arugments in Bash took me way too long last time I did it, so here is a nice full example of how to do it using getopt

    • linux
  • Where's my bait gone?

    1/8/2022

    I have recently started trapping some introduced predators around my local area and have had baits and pre-feed disappear with nothing to show for it, so I decided to get sparky and see if I could catch the culprit in the act.

    • electronics
    • conservation
    • trap-watch
  • Bathymetric Contours

    3/26/2021

    Finally got around to creating a SLD style for GeoServer to display bathymetric contour lines using the GEBCO gridded bathymetric data. Here's how.

    • gis
    • geoserver
    • oceans
  • shm That Cache

    2/25/2021

    I am often trying to find more space on my hard drives and found today my own docker containers wasting space thanks to ! Here's how I fixed it.

    • yarn
    • docker
    • development
  • Blob blob blob blob Stayin' Alive Stayin' Alive

    2/2/2021

    Upon recently trying Deezer again, I found their web app ate all my memory when running in Firefox, so I decided to see if I could find out why. I got as far as memory-file-data/string and Blobs. Here's how.

    • software
    • javascript
    • debugging
    • memory
  • A new Litter Survey

    12/25/2020

    In a culmination of litter surveys and litter picks, linked data and data exploration, and remoteStorage and ActivityPub, I have created a web-based litter pick/survey app that I hope will allow federated citizen science.

    • software
    • litter
    • litter-survey
  • Hoe Stream Trash

    12/14/2020

    My latest litter pick target was Hoe Stream and the White Rose Lane Local Nature Reserve. Here's how it went.

    • litter
    • pi-trash-cam
    • litter-pick
    • environment
  • Release the Beast

    11/24/2020

    I just created a Gitlab CI job to create a release with information from a CHANGELOG.md file for some of my projects. Here's how I did it.

    • software
    • gitlab
    • ci
    • release
  • Gitlab CI Caching

    9/30/2020

    I noticed something strange happening during build process during a multi-tasking bug fix. Turns out I was using Gitlab CI's caching incorrectly. I should have been using artifacts. Here's what I saw.

    • gitlab
    • continuous integration
  • Birthday Trash

    9/22/2020

    As a birthday treat, I took the day off work to try out my electronerised litter picker. Here's how it went.

    • litter
    • pi-trash-cam
    • environment
  • Pi Trash Cam

    9/13/2020

    In preparation for a day of litter picking, I finally got round to a project idea - attaching a camera to a litter picker to record it all. Here's what I did.

    • raspberry pi
    • electronics
    • litter
    • pi-trash-cam
    • environment
  • yarn add --dev webdriverio

    8/25/2020

    I finally started implementing UI testing on first-draft using WebdriverIO. While writing tests was easy, getting the tests running was a little more difficult. Here is how I did it.

    • first-draft
    • software
    • testing
    • gitlab
  • 8/16/2020

    Hooray! My new blog is live! Based on Sapper, using MongoDB and eventually ActivityPub and ActivityStreams, it will be my federated posting hub to the world.

    • software
    • blog
  • Removing EXIF Data from Photos

    8/9/2020

    Creating this new blog, I wanted to make sure there was no metadata data leaking personal information. Here's how I removed all the metadata tags except the ones I wanted from my photos.

    • exif
    • photos
  • tmux List and Reattach

    8/9/2020

    Using tmux for your terminal multiplexer but want an easy to reattach to a session? Here's a small bash script to do it.

    • tmux
    • bash
    • software
  • Selectable Shell Examples

    8/8/2020

    Here's how to help your readers save time by making your post's shell commands easy to select and copy - with a simple CSS property.

    • markdown
    • syntax
    • css
  • Be Dates You

    8/5/2020

    Making my new blog, I didn't initially set the published dates to be native dates in the database. Here what I did to change them …and do all the upgrades I needed.

    • mongodb
    • docker
  • Testing vue components

    7/8/2020

    I recently needed to test that some Vue components were creating the correct HTML. To do this, I decided to create snapshots of Object representations of the rendered HTML.

    • software
    • vue
    • testing
    • javascript
  • No More Numbers

    2/20/2019

    HTML5 number inputs aren't useful, but tel inputs, have all the power

    • javascript
    • html5
    • software
  • A Hacker "Hacked" Me

    12/21/2018

    I decided to look into the extortion emails I have been getting and wrote a small script to extract the bitcoin addresses that have been used.

    • security
    • email
    • grep
  • Mouse Surgery

    12/7/2018

    As part of my pledge not to upgrade, I decided to repair two of my failing mice instead of replacing them with a brand new model (as tempting as it was). Here's what I did.

    • pledge to not upgrade
    • electronics
  • Danger Danger, Highly Reactive

    10/29/2018
    • vue
    • reactive
    • graphing
    • data
  • Switching to SSR

    9/11/2018

    Switching from no server-side-rendering (SSR) to SSR can require a rethinking of your apps loading process. On my blog, I initially, like on many examples, set it up with no SSR and the loading of all content was asynchronous - quick and dirty but it meant that I was able to easily test all of the communication between server and client.

    Considerations

    When moving to SSR, you need to determine:

    • what content and components you want to be loaded on the server render (and who you want them to be rendered for)
    • how you want to load the data for the server render
    • if you want to include the loaded data (and how much of it) in a format that can be imported into the client app when the Javascript starts
    • how you want the client javascript to start and with what data
    • how you will handle any asynchronously loaded components if you are using them.

    What you choose to do will depend on the app you are trying to create and the user experience you want to achieve.

    What Content and Components?

    What content and components you want to be loaded on server render will affect how the page initially looks (and looks for those people with Javascript disabled) and how large the page is to download. Some components, such as graphs and maps, may not be able to be rendered on the server, so may need to be left out.

    You may want to produce different renders for humans and computers, such web crawlers. For instance, on a list of blog posts, you may want to get only the first 20 posts for a human, but you might want to get all of the posts for a crawler to ensure all your posts are indexed.

    How To Load The Data?

    There are many ways to skin an orange and there is even more ways to load data into a store. There are three general ideas I had and saw about loading the data:

    • Creating an initial state object containing all the data required and using that when creating the store
    • Creating a store and then using the store actions to download the required data
    • Creating a store and then use the render cycles to load in the data.

    Creating an initial state object before creating the store would require having to duplicate all of the loading logic scattered throughout the components and router configuration, and also the data fetching logic located in the application actions. Depending on how complex your app is and how customised you want the loads to be, this could get very complex very quickly and result in a lot of code duplication or having to extract out this logic.

    Using the store actions to load the data after the store is created will be simpler than the above, but again depending on the complexity could lead to a lot of duplicated logic and code.

    Using the render cycles to load the data require means that there is no duplication of logic or fetching code, however it will be slower than downloading the data directly. It also means that you have to be able to run the render/update cycles multiple times (and in the case of the client app, not have it effect the DOM if you are not included the data with the server render).

    Frameworks like Nuxt do this with their component function like the asycData function. However, with Nuxt's asyncData component, you can't (at least at the time of writing) have conditional downloading of data based on props passed to the components.

    Including App-readable Data in Render

    When the client app activates on the client, it will need the same data that was needed on the server side to render the page as it was on the server. Unfortunately, for some apps (and most app frameworks), this data can not be interpolated from the rendered HTML and therefore must either be downloaded separately from the rendered page, or duplicated in the rendered page in app-readable format, like JSON. Fetching it separately will increase the amount of time before the client app can activate (start managing the DOM). Including the data in rendered page in a app-readable format will increase the size of rendered page - pointlessly if the user doesn't if they use don't have Javascript activated.

    Activating the Client App

    When to activate the client app to start managing the DOM will depend on how complete the render was on the server and how much data has been included with the server rendered page. If you activate that app without all the data necessary to render the page as it was on the server will result in nasty page flashes.

    Having a fully server rendered page and not including and app-readable data in the render will mean that the app won't be able to activate until all of the data has been fetched. This delay in activating the app will usually not be an issue, unless you use components that can't be rendered without the client app being activate. An example of such a component could be a map or an interactive graph where the code for rendering the component is in the client app. It will mean however that the users without Javascript will get the full content.

    Asynchronous Components

    Asynchronous components are usually the result of code splitting and allow components to only be loaded when they are required. This can be extremely beneficial when using modules like syntax highlighters, graphing libraries and other complex libraries and it can drastically cut down the amount of Javascript required to be downloaded.

    These components do cause problems on during server renders though as they need to be loaded before the final render is complete.

    My Implementation

    My aim of switching to SSR was be able to serve pages as static content to increase the loading time of my blog. It also had the added benefit of improving the blogs SEO as all content available to the crawler without Javascript. Though this is becoming a mute point with some crawlers nowadays, it also does affect page preview included in most social media apps among others these days.

    With all the things above considered, I chose to go down the path of using the render cycles to load the data. I chose this route so that I didn't have to refactor/duplicate much of the logic of the content loading and it also meant I could deal with the async components I had in the app, such as the syntax highlighter.

    To do this, I devised a Loader component to track any Promises that were created, both from fetching data and importing components, during the render cycles and rerendering until there was no more new Promises created.

    The Loader component was also able to be used to display a loader when navigating in the client app.

    I also decided to have multiple levels of render.

    Loader

    The Loader component creates an array where any promises or manual loadings can be tracked. It has a Context Consumer Component to allow

    However not doing this meant that I had to either pass the finialised state with the rendered page, or find a way to download the data on the client app without React rerendering the page as it would look with no data loaded.

    On each request, I created a new instance of MARSS

    Issues

    One issue encountered when I was implementing the loader and using multiple calls to renderToString was the component classes with instantiated everytime renderToString was called. This meant that any state setting that happeneded after the class was created, for instance in the render loop was not carried over to the next render call. I found this in the markdown component which I had created because it loaded and stored the highlighter module during the render cycle. Changing this to load the module as a module variable when required meant that it would survive the re-instantiation.

    • react
    • ssr
    • react-loader
  • Clean Docker Registry

    8/10/2018
    • node
    • docker
    • console
    • javascript
  • Testing on the Filesystem

    2/1/2018
    • testing
    • javascript
  • Tag You Are

    1/26/2018
    • javascript
    • tags
  • NaN Got Me

    1/25/2018
    • rubber duck save
    • javascript
    • nodejs
    • json
  • All our app's tabs are belong to us

    4/28/2017
    • angular
    • javascript
    • localstorage
    • rxjs
    • sessionstorage
  • Developing NPM modules

    2/20/2016
    • nodejs
    • npm
  • Nfa + Nfb or N(f+fa+fb)

    2/20/2016
    • array
    • function
    • javascript
    • jsperf
  • Photo Layout

    10/31/2015
    • arranger
    • css
    • gallery hierarchy
    • html
    • javascript
    • photos
    • tinymce
    • wordpress
    • software
  • Browning Pass HideAway Web Site

    10/31/2015
    • css
    • gallery hierarchy
    • html
    • wordpress
  • Think Mobile

    10/17/2015
    • mobile
    • web
  • Pledge to Refuse and Not Buy Bottled Water

    10/13/2015
    • environment
    • pledges
  • Run PHP run!

    2/25/2015
    • maximum execution time
    • php
    • trial and error
  • Gallery Hierarchy

    11/26/2014
    • gallery
    • hierarchy
    • photos
  • Vim and functions

    10/3/2014
    • function
    • navigation
    • tags
    • vim
  • I'm making hierarchies

    9/26/2014
    • hierarchical data
    • hierarchy
    • php
  • Google Sheets fun

    9/4/2014
    • google
    • google script
    • google sheets
    • javascript
    • sheets
  • Travel Photos

    8/13/2014
    • photo management
    • photos
    • travel photos
  • Image managment scripts

    8/13/2014
    • photo management
    • photos
  • MeldCE logo

    7/31/2014
    • css
    • html5
    • javascript
    • svg
  • MoltenDB

    4/26/2014
    • database
    • moltendb
    • mongodb
    • nodejs
  • The Expensive Side

    10/29/2013
    • house
  • abcde

    9/22/2013
    • music
  • Energizer Power Plus Rechargeable Batteries

    7/16/2013
    • gadgets
  • USAR FOGTeX

    3/4/2013
    • fogtex
  • Personal Gear Bag

    2/21/2013
    • rescue
    • gear
  • Geocaching Stamp

    2/18/2013
    • stamp
    • geocaching
  • Call Record Presenter

    4/2/2007
    • parser
    • python
    • sqlite
    • web
  • Kimi Ora School

    9/25/2004
    • css
    • html
  • All About Catering Web Site

    6/25/2004
    • css
    • html
  • Quantum Accounting Web Site

    7/26/2003
    • css
    • html
Copyright BytesNZ 2023. Powered by Sapper
[matrix]