Sean Borg

TB: Wrapper manager

2026-07-05T00:00:00+00:00

In my quest to remove all home manager</a> I have found wrapper manager</a> and thought I'd try document how I integrated it into my nixos config</p>

I still feel like im learning nix if i'm doing anything crazy please email me</a>, make an issue in this websites gitlab repo</a> or if you understand radicle submit a pr/issue to my nixos config</a></p>

My goal was to keep all my wrapped config in one directory, since I use krops</a> and do some crazy stuff my nixos directory looks a bit like this</p>

.
├── config
│   ├── configuration.nix
│   ├── readme.md
│   ├── channels
│   ├── hm-to-copy
│   ├── machine-specific
│   ├── my-pkgs
│   ├── public-keys
│   ├── roles
│   ├── sean
│   ├── vars
│   └── wrapped
│       ├── atuin.nix
│       ├── cib.nix
│       ├── ci-runner-radicle.nix
│       ├── firefox.nix
│       ├── fish.nix
│       ├── git.nix
│       ├── helix
│       │   ├── codebook
│       │   │   └── codebook.toml
│       │   ├── default.nix
│       │   └── helix
│       │       ├── config.toml
│       │       └── languages.toml
│       └── sherlock.nix
├── my-devices
└── tests
</code></pre>
Then I can pull in all the wrapped stuff under the wrapped namespace by doing
the following in the let statement of any nix file</p>
importJson = (import <nixpkgs> { }).lib.importJSON;
wrapper-manager-git = builtins.fetchGit {
  rev = (importJson ../channels/wrapper-manager.json).rev;
  url = (importJson ../channels/wrapper-manager.json).url;
  allRefs = true;
};
wrapper-manager = (import "${wrapper-manager-git}");
wrapped = wrapper-manager.lib {
  inherit pkgs;
  modules = map (n: <path to wrapped folder>/${n}) (builtins.attrNames (builtins.readDir <path to wrapped folder>));
};
</code></pre>
I'm making the assumption that repeating this in many files just gets squished
into 1 at the end. Also the import json allows me to pin the repo and update it
with 1 command like
nix-shell -p nix-prefetch-git --command 'nix-prefetch-git   --url https://github.com/viperML/wrapper-manager.git --rev refs/heads/master > config/channels/wrapper-manager.json'</code></p>
Resulting in nix files like</p>
{ config, pkgs, ... }:
let
  importJson = (import <nixpkgs> { }).lib.importJSON;
  wrapper-manager-git = builtins.fetchGit {
    rev = (importJson ../channels/wrapper-manager.json).rev;
    url = (importJson ../channels/wrapper-manager.json).url;
    allRefs = true;
  };
  wrapper-manager = (import "${wrapper-manager-git}");
  wrapped = wrapper-manager.lib {
    inherit pkgs;
    modules = map (n: ../wrapped/${n}) (builtins.attrNames (builtins.readDir ../wrapped));
  };
in
{
  # <snip>
  users.users.sean = {
    shell = wrapped.config.wrappers.atuin-fish.wrapped + "/bin/fish";
    packages = with pkgs; [
      wrapped.config.wrappers.touch-firefox.wrapped
      wrapped.config.wrappers.sean-helix.wrapped
      wrapped.config.wrappers.sean-git.wrapped
      wrapped.config.wrappers.atuin-fish.wrapped
      wrapped.config.wrappers.pc-atuin.wrapped
    }
  }
  # <snip>
}
</code></pre>
Full file here</a></p>



TB: Euler diagram of rust week talks
2026-06-29T00:00:00+00:00
Was trying to pick categories that are not the track they was in so no, Project/Applied Rut/Industry/Compiler categories.
Also attempting to not give a category that is extremely clear from the name unless others made a category :D</p>
Some I couldn't really group but put similarish ones close by... others just went over my head so I couldn't categorise them :(
Happy to update submit suggestions to https://gitlab.com/seam345/my-website/-/blob/main/content/tiny-blog/2026-06-29_rust-week-ven-diagram.md?ref_type=heads</a></p>


TB: Build a nix pkgs out of nixpkgs
2026-06-08T00:00:00+00:00
Nixpkgs uses CallPackage</a>
to simplify things in Nixpkgs</p>
Often I find myself making things to eventually go into my nix config so taking
advantage of CallPackage is helpful, but it can be quite tedious to build my
whole config repeatedly to confirm I got all the nix right...</p>
Here is where this short snippet comes in handy</p>
nix-build -E 'with import <nixpkgs> { }; callPackage ./path/to/default.nix { }'

</code></pre>
This builds like nixpkgs does allowing me to test everything without needing to
jump to my config and build the whole machine every time.</p>
Links to learn CallPackage itself</h2>
Think I originally learned (and have now forgot) how callpackage works from https://github.com/NixOS/nixos-summer/blob/main/content/blog/callpackage-a-tool-for-the-lazy.md</a>
this has now been used as a base to write https://nix.dev/tutorials/callpackage</a>
which I shall have to read at some point.</p>
Attempting to find the original article I read I came across a few links,
I have barely skim read but hopefully will have some time to one day</p>

https://toraritte.github.io/posts/callPackage/2024-08-18-callPackage.html</a>

https://github.com/NixOS/nix.dev/issues/651</a></li>
https://github.com/NixOS/nixpkgs/issues/36354</a>

stackoverflow</code> Where is callPackage</code> defined in the Nixpkgs repo
(or how to find Nix lambda definitions in general)?</a></li>
nixos discourse</code> Where is callPackage</code> defined exactly? (part 2)</a></li>
Tangential:

stackoverflow</code> Nix: what's the concrete difference between
nixpkgs and nixpkgs.pkgs?</a></li>
stackoverflow</code> nix - Why is functionArgs</code> implemented twice
(i.e, as a primop and in lib</code>)</a></li>
stackoverflow</code> nixpkgs - How does Nix's "callPackage" call
functions defined without an ellipsis?</a></li>
</ul>
</li>
</ul>
</li>
https://github.com/NixOS/nixpkgs/pull/270696</a></li>
</ul>
</li>
</ul>


TB: Rust Result
2026-04-23T00:00:00+00:00
type alias Result type Result<T> = std::result::Result<T, Error></code></p>
allows you to specify Result<T></code> in your code instead of Result<T,E></code></p>


All the Rust Tutorials
2025-08-19T00:00:00+00:00
TL;DR I made a website (webpage) of all the previous This Week in Rust
walkthroughs https://tutorials.rustmanchester.co.uk/external-learning/</a>
and I would love help making the page more useful, see #Call for participation</a></p>
The idea</h2>
One night I had the idea to catalogue all the Rust tutorials I could find and
make one of those awesome list pages, both to increase awareness of Rust Manchester</a>
and to have a place to direct people when they were asking for things to learn at
our events.</p>
Searching</h3>
At the moment I think clicking "show all tutorials" and ctrl+f the website is the
best search, but I have started making a more robust search and as the webpage grows
it will improve</p>
For searching there are 3 parts:</p>

Search if text exists in the title/summery. At the moment this is a case-insensitive
exact search, I hope to make it fuzzy soon</li>
Format filter, all catalogue resources have a format type like; Blog, video,
...</li>
Tag filter, I have started assigning various hierarchical tags to each resource</li>
</ol>
 Tag & Format options</figcaption></figure>
Formats originally was fairly straightforwards thinking each tutorial will only
be one format, but I started to come across videos that also had the same content
in a blog, or recorded talks that were born from blogs or had transcripts, giving
rise to something like the following :D</p>
 
Technical</h2>
Source code at https://gitlab.com/rust-manchester/website-external-learning/</a></p>
To kick-start the list I grabbed all the previous walkthroughs
in This Week in Rust</a>,
then got to categorising & tagging them. Originally started with markdown
converted to html with Zola</a>
on Rust Manchester's main website. I got through cataloguing about 100 before I
realised this was untenable! So I moved it to a subdomain/separate repo, soon after
I also moved away from Zola and wrote a huge json</a>
that is parsed with some JavaScript then saved to the browser local storage (indexedDB)
for better search performance and to keep the site static (for the free hosting).</p>
Overall I'm happy with the current page and a happy
accident of all the data being in JSON is you are able to curl and
query it using JQ on the command line (if you don't like the look/feel of the website)
curl https://gitlab.com/rust-manchester/website-external-learning/-/raw/master/tutorials.json | jq .</code></p>
Call for participation</h2>
To date I have got through cataloguing 162 of ~2000 and have quickly realised why
nobody has done this before[1]</a></sup> :D</p>
Which gets to the point of this article, I need help!</p>

With the content

Help categorising, anything after 162
in this JSON</a></li>
Help defining the categories, for easier categorising. I started in the README,</a>
but it just looks like a wall of text not very quick/easy to parse (also
horribly written, sorry)</li>
Help consolidating, there are a lot of blog series ( one subject being
taught over multiple blogs ) that are currently shown as separate items
but should be 1</li>
Feedback, good or bad! I have no idea if what I've done is useful, I know
I've found some use out of it and a few of my friends have, but I don't know
if it's something the community would want, or heck if there is something
similar that exists that I could put my effort into</li>
Probably some help documenting how to do all the above :/ I tried my best
with
the README,</a>
but I suspect I missed a lot of things</li>
Submitting your learning resources! If you've made a thing to help teach
rust I'd love to add it to this list</li>
</ul>
</li>
With the site, these I
made gitlab issues for</a>

Improve the search, this really encompass a lot of possible changes

Real time updating of the list instead of requiring the page to
reload issue #5</a></li>
have some and/or/not logic, so you can better narrow a
search issue #7</a></li>
Clicking tags could auto update the search in some
way issue #6</a></li>
give a date range for
search issue #8</a></li>
</ul>
</li>
Clicking crate tags could jump you to the official crates.io page (realise
this is in conflict with one of my search
ideas) issue#14</a></li>
Sorting
issue #9</a>

probably by date</li>
</ul>
</li>
Error handing - I'm sorry I basically did none :/ js is very forgiving...
until it's not

Handle failed saves to the
indexedDB issue #11</a></li>
handle failed downloads of the JSONL
files issue #10</a>

have some retry mechanism for these</li>
</ul>
</li>
</ul>
</li>
Improve
editing issue #12</a>

a way to click from website to the item in the huge json, for easy
editing</li>
a forum to fill out that could generate a diff, or at the start an
email</li>
</ul>
</li>
</ul>
</li>
</ul>
Again all of the above is very open to interpretation changes! Please open issues</a>
for any ideas you have or even email me if you don't have Gitlab sean@seanborg.tech</a></p>
Other stuff</h2>
Daily tutorials</h3>
Chatting about the webpage with Rory and Kiran</a>
they came up with the idea of daily tutorials as a way to have a common tutorial
to discuss between other Rustaceans on the Rust Manchester discord, this also gave
an easy tutorial to go to when you're not looking for something specific.
I thought it was a great idea, so it's right at the top of the page :D also for
permalinks there is an archive page!</a></p>
Link checking</h3>
To attempt to keep the links relevant I am using Lychee</a>
however with over 2000 links I found there are a lot of transient problems...
To mitigate this issue the CI</a>
now caches the result of daily link checks and only errors if the link failed
for 7 days in a row, which still kicks out a lot of errors I need to address >300</a></p>



I have no idea if anyone has done this before, I went looking but no luck,
if someone has done this before please let me know as it would be a lot better
to consolidate this in one place than have 2 places :D ↩</a></p>
</li>
</ol>


Rust learning list
2025-03-25T00:00:00+00:00
Goal</h2>
Make a nice and easy way to search all of Rust's learning resources by
cataloging every Rust learning resource out there!</p>
Why</h2>
Both to increase awareness of Rust Manchester</a>
and to help direct people when they were asking for things to learn at our
events.</p>
Where</h2>
https://tutorials.rustmanchester.co.uk/external-learning/</a></p>
Source code</h3>
https://gitlab.com/rust-manchester/website-external-learning/</a></p>
Current state</h2>
Actively worked on, categorised ~160 of ~2000 so far!</p>


Structuring code in a multi-page Crux app
2025-02-19T00:00:00+00:00
Welcome to how I structure a multi-page application using the
Elm architecture</a>
in the Crux</a> framework.
Writing this because I found a lot of single page app examples but haven't come
across how people handle multiple pages.</p>
All code examples come from my UpLine app</a>
(specifically from the blog-post</code> branch</a>)</p>
The first 4 things is how I structure the core (Rust), 5 is then the
shell (Android) side.
(p.s. I don't explain Crux at all, I am assuming your familiar with it. I would
recommend the design overview</a>
as a quick way to understand this blog)</p>

Starting out with the data types I
structure The Model</a></li>
Then continuing with the types I structure
the Events</a></li>
Finally jumping
into The Code</a>
and show how the above heavily influence the structure</li>
A quick look at how I organised
the UiModel</a></li>
Lastly how the UiModel influences
the Android</a> code
structure</li>
</ol>
The model</h2>
The internal data struct</code></p>
Top level Model</h3>
#[derive(Default, Clone, Debug)]
pub struct Model {
    pub screen: Screens,
    pub user_messages: UserMessages,
    pub example_data: ExampleData,
}
</code></pre>
Above we have the Screens</code> type, which hides all the magic, then anything
I want persistent across screens I need to also keep at this level so in
my case user_messages</code> and example_data</code> we keep out of Screens</code></p>
Model.screens</h3>
The magic... A massive enum</code> :D</p>
// order is alphabetical to be in line with file browser  
#[derive(Clone, Debug)]
pub enum Screens {
    InitialScreen(InitialScreenData),
    InputFieldsTagsScreen(InputFieldsAndTagsScreenData),
    PostWriteReviewScreen(PostWriteReviewScreenData),
    SelectOrgBucketMeasurementScreen(Box<SelectOrgBucketMeasurementScreenData>),
    SettingPreviousConnectionsScreen(SettingsPreviousConnectionsActionsScreenData),
    SettingsScreen,
}
</code></pre>
With Rust allowing enum variants to hold internal data I make a variation per
screen appended with Screen</code> and create a new data type per screen appended
with ScreenData</code>, the naming scheme was helpful for myself to keep track of
what I have where.</p>

Why the box?</summery>
Very simply clippy or the compiler suggested it once and I went with it, at some
point I should review and maybe convert others. The reason was about the enum
data types being wildly different sizes.</p>
</details>
Moving screens</h3>
Originally thought moving screens would be problematic/annoying but using
Rust's strong typing we can get some nice wins from this. First is we can
take unvalidated user input held as option<String></code> and validate
it converting it to just a String</code> or another strong type, simplifying
logic on later screens. We can see this between my first 2 screens
initial</code>>SelectOrgBucketMeasurement</code>.</p>
</p>
Secondly we can leverage TryFrom quite nicely so we can do
~ let screen2: Screen2data = screen1data.tryinto()</code>
allowing us to easily move to screen2 with the Err giving us a nice
message to relay back to the user</p>
Events</h2>
Top level Events</h3>
Similar to Model</code> with Event</code> we can associate data with the enums,
this time though we are just wrapping up more enum</code>s as sub events
per screen, so...</p>
// order is alphabetical to be in line with file browser
#[derive(Serialize, Deserialize, Clone, Debug)]
pub enum Event {
    EvInitialScreen(ScEvInitial),
    EvInputFieldsAndTagsEventsScreen(ScEvInputFieldsAndTags),
    EvPostWriteReviewScreen(ScEvPostWriteReview),
    EvSettingsScreen(ScEvSettings),
    EvSelectOrgBucketMeasurementScreen(ScEvSelectOrgBucketMeasurement),
    EvSettingsPreviousConnectionsScreen(ScEvSettingPreviousConnections),
    EvGlobal(GlEvGlobal),
}
</code></pre>
As the Event</code> type crosses the FFI boundary I found it much nicer for type
completion in Kotlin to prepend the Ev</code> for event variation and ScEv</code> for
the internal data on each event variation.</p>
Screen event</h3>
Internally the screen events</p>
// order is alphabetical to be in line with file browser
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum ScEvInitial {
    AppendPreviousConnection(PreviousConnection),
    #[serde(skip)]
    AppendPreviousConnectionResult(PersistentStorageOutput),
    InfluxBucketsConnectionTest,
    #[serde(skip)]
    InfluxBucketsConnectionTestResponse(crux_http::Result<crux_http::Response<BucketsResult>>),
    LoadPreviousConnections,
    #[serde(skip)]
    LoadPreviousConnectionsResult(PersistentStorageOutput),
    QuickActionsLoad,
    #[serde(skip)]
    QuickActionsLoadResult(PersistentStorageOutput),
    QuickActionsUserSelected(UiStringIndex),
    LoadSettingsScreen,
    SetApiToken(String),
    SetBaseUrl(String),
    UserSelectedPreviousConnection(UiStringIndex),
}
</code></pre>
Above is all the events I have on the initial</code> screen, this does make
calling an event in Android quite a long as we need to specify screen then event
e.g.</p>
core.update(
  Event.EvInitialScreen(
    ScEvInitial.LoadPreviousConnections()
  )
)
</code></pre>
but I found I can make a simple function to reduce that</p>
fun screenEvent(core: Core, coroutineScope: CoroutineScope, event: ScEvInitial) {
    coroutineScope.launch {
        core.update(
            Event.EvInitialScreen(
                event
            )
        )
    }
}

// now calls look like
screenEvent(core, coroutineScope, LoadPreviousConnections())
</code></pre>
Global Events</h3>
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum GlEvGlobal {
    UpdateTutorial(u8),
    BackButtonClicked,
}
</code></pre>
Originally I had global events in the top level but figured it was just nicer
to wrap them up in another enum</code> so they have a nice place to grow. 🌱</p>
The Code</h2>
app.rs (Rust entry point)</h3>
First the Event</code> enum and how that influences the code structure.</p>
</p>
With the above picture we can see why I ordered things alphabetically, because
for each ScEv<name></code> I have made a folder screens/<name>/mod.rs</code>. Keeping it
alphabetical helps with easily jumping between the enum folder and vice versa.</p>
Top level update function</h4>
Now all my top level Events are really a group of screen events my top level
update function, is just passing the event onto a function in the mod.rs of
the corresponding folder e.g. event of type EvInitialScreen</code> will call a
function in screens/initial/mod.rs</code>, I took the naming scheme of _
screen_events
so we get initial_screen_events</code></p>
fn update(&self, event: Self::Event, model: &mut Self::Model, _caps: &Self::Capabilities, )
          -> Command<Effect, Event> {
    // ...
    match event {
        InitialScreenEvents(internal_event) => initial_screen_events(internal_event, model),
        // ...
    }
}
</code></pre>
Full update function at time of writing</h5>
The actuality of the function has a bit of global setup, so for me setting up
android logging and some messing with
the user_messages. But after all that we have the same match statement and
keeping the alphabetical order to help find
things, so as long as we don't have a semicolon at the end we can quite quickly
verify that all the return commands are
actually coming from screen/<name>/mod.rs</code></p>
fn update(&self, event: Self::Event, model: &mut Self::Model, _caps: &Self::Capabilities,
) -> Command<Effect, Event> {
    START.call_once(|| {
        android_logger::init_once(
            Config::default()
                .with_max_level(log::LevelFilter::Warn)
                .with_tag("FL:C"),
        );
    });

    trace!("Clear all existing messages");
    model.user_messages.remove_all_messages();

    trace!("Run event");
    trace!("model:{:?}", model.screen);
    trace!("event:{:?}", event);
    match event {
        InitialScreenEvents(internal_event) => initial_screen_events(internal_event, model),
        SelectOrgBucketMeasurementScreenEvents(internal_event) => {
            select_org_bucket_measurement_screen_events(internal_event, model)
        }
        InputFieldsAndTagsEventsScreenEvents(internal_event) => {
            input_fields_and_tags_events(internal_event, model)
        }
        SettingsScreenEvents(internal_event) => settings_events(internal_event, model),
        SettingsPreviousConnectionsScreenEvents(internal_event) => {
            setting_previous_connections_events(internal_event, model)
        }
        PostWriteReviewScreenEvents(event) => post_write_review_screen_events(event, model),
        GlobalEvent(event) => global_events(event, model),
    }
}
</code></pre>
Screen mod.rs</h3>
Events / update function</h4>
We shall get to why mod.rs</code> has 400 lines before we get to the only function in
the file, but here is one of ourscreen/<name>/mod.rs::<name>_screen_events</code>
functions.</p>
</p>
First now we are one level down we can get the screen data out of the model,
sadly this can't be a thing we can assert at build time but in general the
folder structure makes this easy to maintain. This allows us to pass sreenData</code>
to our functions reducing scope the functions can effect and saving dealing
with repeatedly asserting the screen model.</p>
In general, we have repeated the same trick we had in app.rs</code> now in
screen/<name>/mod.rs</code> this time all our events correspond to a file. The enum
variant / file name / function
all have the same name (within naming conventions) e.g. variant
BackButtonPressed()</code> /
file name back_button_pressed.rs</code> / function fn back_button_pressed() {}</code>.</p>
Again keeping alphabetical order to make things easier to find.</p>

My full `function` at time of writing</summary>
pub fn input_fields_and_tags_events(
    initial_screen_event: InputFieldsAndTagsScreenEventsData,
    model: &mut Model,
) -> Command<Effect, Event> {
    trace!("input_fields_and_tags screen event: Validating model");

    let Screens::InputFieldsTagsScreen(ref mut screen_data) = model.screen else {
        error!("Screen was in an unexpected state {:?}", model.screen);
        model.user_messages.error_report_to_developer(N065_USED);
        return crux_core::render::render();
    };

    trace!("Running input fields and tags event");

    match initial_screen_event {
        InputFieldsAndTagsScreenEventsData::BackButtonPressed => {
            back_button_pressed(&mut model.screen, &mut model.user_messages)
        }

        InputFieldsAndTagsScreenEventsData::FieldExistingAdd(field) => {
            field_existing_add(screen_data, field, &mut model.user_messages)
        }
        InputFieldsAndTagsScreenEventsData::FieldExistingRemove(field) => {
            field_existing_remove(screen_data, field)
        }
        InputFieldsAndTagsScreenEventsData::FieldExistingValueSet(key, value) => {
            field_existing_value_set(key, value, screen_data, &mut model.user_messages)
        }
        InputFieldsAndTagsScreenEventsData::FluxGetMeasurementsExistingFields => {
            flux_get_measurements_existing_fields(
                screen_data,
                &mut model.user_messages,
                &model.example_data,
            )
        }
        InputFieldsAndTagsScreenEventsData::FluxGetMeasurementsExistingFieldsResponse(response) => {
            flux_get_measurements_existing_fields_response(
                screen_data,
                response,
                &mut model.user_messages,
                &model.example_data,
            )
        }
        InputFieldsAndTagsScreenEventsData::FluxGetMeasurementsExistingTags => {
            flux_get_measurements_existing_tags(
                screen_data,
                &mut model.user_messages,
                &model.example_data,
            )
        }
        InputFieldsAndTagsScreenEventsData::FluxGetMeasurementsExistingTagsResponse(response) => {
            flux_get_measurements_existing_tags_response(
                screen_data,
                response,
                &mut model.user_messages,
                &model.example_data,
            )
        }
        InputFieldsAndTagsScreenEventsData::FluxGetTagsExistingValues => Command::done(),
        InputFieldsAndTagsScreenEventsData::FluxGetTagsExistingValuesResponse(response, tag) => {
            flux_get_tags_existing_values_response(
                screen_data,
                response,
                &mut model.user_messages,
                tag,
            )
        }
        InputFieldsAndTagsScreenEventsData::InfluxWrite => influx_write(
            &mut model.screen,
            &mut model.user_messages,
            &model.example_data,
        ),
        InputFieldsAndTagsScreenEventsData::InfluxWriteResponse(response) => {
            influx_write_response(response, model)
        }
        InputFieldsAndTagsScreenEventsData::LineProtocolSubmitLine => Command::done(),
        InputFieldsAndTagsScreenEventsData::TagExistingAdd(tag) => tag_existing_add(
            screen_data,
            &mut model.user_messages,
            tag,
            &model.example_data,
        ),
        InputFieldsAndTagsScreenEventsData::TagExistingRemove(tag) => {
            tag_existing_remove(screen_data, tag)
        }
        InputFieldsAndTagsScreenEventsData::TagExistingValueAcceptModeChange(key) => {
            tag_existing_value_accept_mode_change(key, screen_data, &mut model.user_messages)
        }
        InputFieldsAndTagsScreenEventsData::TagExistingValueDismissModeChange(key) => {
            tag_existing_value_dismiss_mode_change(key, screen_data, &mut model.user_messages)
        }
        InputFieldsAndTagsScreenEventsData::TagExistingValueSetIndex(key, value) => {
            tag_existing_value_set_index(key, value, screen_data, &mut model.user_messages)
        }
        InputFieldsAndTagsScreenEventsData::TagExistingValueSetUser(key, value) => {
            tag_existing_value_set_user(key, value, screen_data, &mut model.user_messages)
        }
        InputFieldsAndTagsScreenEventsData::TagNewAdd() => {
            tag_new_add(screen_data, &mut model.user_messages)
        }
        InputFieldsAndTagsScreenEventsData::TagNewKaySet(string_index, key) => {
            tag_new_key_set(string_index, key, screen_data, &mut model.user_messages)
        }
        InputFieldsAndTagsScreenEventsData::TagNewRemove(string_index) => {
            tag_new_remove(string_index, screen_data, &mut model.user_messages)
        }
        InputFieldsAndTagsScreenEventsData::TagNewValueSet(string_index, value) => {
            tag_new_value_set(string_index, value, screen_data, &mut model.user_messages)
        }
        InputFieldsAndTagsScreenEventsData::TimeSet(time) => time_set(time, screen_data),
        InputFieldsAndTagsScreenEventsData::FieldNewAdd => {
            field_new_add(screen_data, &mut model.user_messages)
        }
        InputFieldsAndTagsScreenEventsData::FieldNewRemove(string_index) => {
            field_new_remove(string_index, screen_data, &mut model.user_messages)
        }
        InputFieldsAndTagsScreenEventsData::FieldNewValueSet(string_index, new_value) => {
            field_new_value_set(
                new_value,
                string_index,
                screen_data,
                &mut model.user_messages,
            )
        }
        InputFieldsAndTagsScreenEventsData::FieldNewKeySet(string_index, new_key) => {
            field_new_key_set(new_key, string_index, screen_data, &mut model.user_messages)
        }
        InputFieldsAndTagsScreenEventsData::FieldNewChangeType(string_index, new_type) => {
            field_new_change_type(
                new_type,
                string_index,
                screen_data,
                &mut model.user_messages,
            )
        }
    }
}
</code></pre>
We can see, although it gets bigger so long as im not terminating the match with
a semicolon Rust will guarantee we are passing the output of each match arm as
our output to the function</p>
</details>
Screen Events & Model</h4>
After watching both the Events enum and Model struct grow in their respective
top level files I decided to pull them into the screen/<name>/mod.rs</code> as well.
This made a lot of sense as mod.rs</code> is the entry point for the file it is now
also where the Events and Data is defined, keeping the majority of my work on a
screen in 1 folder. Downside mod.rs</code> gets very big, my order was:</p>

Model</li>
Events</li>
Update function</li>
</ul>
which is how the update function ends up 400 lines down :D</p>
</p>
</p>
In the images above we see the alphabetical ordering again, and the tryFrom
mentioned earlier on.</p>
Full file</h4>
Function files</h3>
Tiny subset of the function files to see how everything works.</p>
Load quick actions</h4>
In the bellow we have an example of a very small function but this is great to
show the testing of the commands</p>
pub fn load_quick_actions() -> Command<Effect, Event> {
    trace!("load_quick_actions called");

    persistent_storage::load(QUICK_ACTIONS_FILENAME.to_owned()).then_send(construct_response_event)
}
fn construct_response_event(body: PersistentStorageOutput) -> Event {
    EvInitialScreen(ScEvInitial::QuickActionsLoadResult(body))
}
mod tests {
    use super::*;
    use crate::screens_common::test_common::test_shell;

    #[test]
    fn test_load_quick_actions() {
        let mut commands = load_quick_actions();

        // confirm the correct events are called  
        let effects = commands.effects().collect();
        insta::assert_debug_snapshot!(  
            effects, @r#"[
                PersistentStorage(
                    Request(
                       Load("quick_actions",),                
                    ),            
                ),        
            ]"#
        );
        test_shell(effects);
        let events: Vec<Event> = commands.events().collect();
        insta::assert_debug_snapshot!(  
            events, @r#" [
                EvInitialScreen(
                    QuickActionsLoadResult(                    
                         FileData("Just a fake test",),
                      ),
                ),
            ]"#
        );
    }
}
</code></pre>
since there is no branching only one test is needed and really all im doing is
confirming I called the right construct_response_event</code> function but as I know
this function is being called from both the match</code> in app.rs</code> then screen/<name>/mod.rs</code>
I can be extremely confident that this function with very little scope for
mutability is the side effect of the loadQuickActions</code> event and that it is now
100% tested.</p>
Load quick actions result</h4>
Obviously these functions don't stay so small, here's a more average one</p>
pub fn load_quick_actions_result(
    screen_data: &mut InitialScreenData,
    user_messages: &mut UserMessages,
    response: PersistentStorageOutput,
) -> Command<Effect, Event> {
    trace!("load_quick_actions_results called");
    match response {
        PersistentStorageOutput::FileData(data) => {
            debug!("loaded data: {data}");

            let fp = BufReader::new(data.as_bytes());
            let reader = JsonLinesReader::new(fp);
            let items = reader
                .read_all::<QuickAction>()
                .collect::<std::io::Result<Vec<_>>>();

            match items {
                Ok(value) => {
                    model.quick_actions = RemoteResource::Loaded(MultiChoice {
                        options: value,
                        selected: None,
                    });
                    crux_core::render::render()
                }
                Err(error) => {
                    error!("Failed to get previous connections, error: {:?}", error);
                    error!("data was {}", data);
                    user_messages.add_message(
                        format!("Failed to get previous connections, error: {:?}", error),
                        Level::Error,
                    );
                    crux_core::render::render()
                }
            }
        }
        PersistentStorageOutput::SaveOk
        | PersistentStorageOutput::AppendOk
        | PersistentStorageOutput::Error => todo!(),
        PersistentStorageOutput::LoadErrorFileDoesntExist => {
            warn!("Quick actions file doesnt exist!");

            screen_data.quick_actions = RemoteResource::NonExistent;
            crux_core::render::render()
        }
    }
}
</code></pre>

Once we add the tests for this the file gets quite huge!</summary>
use crate::capabilities::persistent_storage::PersistentStorageOutput;
use crate::model::UserMessages;
use crate::screens::initial::{InitialScreenData, QuickAction};
use crate::screens::input_fields_and_tags::RemoteResource;
use crate::screens_common::model::multi_choice::MultiChoice;
use crate::{Effect, Event};
use crux_core::Command;
use log::{debug, error, trace, warn, Level};
use serde_jsonlines::JsonLinesReader;
use std::io::BufReader;

pub fn load_quick_actions_result(
    model: &mut InitialScreenData,
    user_messages: &mut UserMessages,
    response: PersistentStorageOutput,
) -> Command<Effect, Event> {
    trace!("load_quick_actions_results called");
    match response {
        PersistentStorageOutput::FileData(data) => {
            debug!("loaded data: {data}");

            let fp = BufReader::new(data.as_bytes());
            let reader = JsonLinesReader::new(fp);
            let items = reader
                .read_all::<QuickAction>()
                .collect::<std::io::Result<Vec<_>>>();

            match items {
                Ok(value) => {
                    model.quick_actions = RemoteResource::Loaded(MultiChoice {
                        options: value,
                        selected: None,
                    });
                    crux_core::render::render()
                }
                Err(error) => {
                    error!("Failed to get previous connections, error: {:?}", error);
                    error!("data was {}", data);
                    user_messages.add_message(
                        format!("Failed to get previous connections, error: {:?}", error),
                        Level::Error,
                    );
                    crux_core::render::render()
                }
            }
        }
        PersistentStorageOutput::SaveOk
        | PersistentStorageOutput::AppendOk
        | PersistentStorageOutput::Error => todo!(),
        PersistentStorageOutput::LoadErrorFileDoesntExist => {
            warn!("Quick actions file doesnt exist!");

            model.quick_actions = RemoteResource::NonExistent;
            crux_core::render::render()
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::screens::initial::InitialScreenData;
    use crate::screens_common::test_common::test_shell;

    #[test]
    fn test_load_previous_connections_result_empty() {
        let mut screen_data = InitialScreenData {
            ..Default::default()
        };
        let mut user_messages = UserMessages::default();
        let response = PersistentStorageOutput::FileData("".to_owned());

        let mut commands =
            load_quick_actions_result(&mut screen_data, &mut user_messages, response);

        // =========================================================================================
        // check that the view has been updated correctly
        // =========================================================================================
        // todo confirm if I want an empty list or a non exist
        insta::assert_debug_snapshot!(screen_data, @r#"
        InitialScreenData {
            api_token: None,
            base_url: None,
            quick_actions: Loaded(
                MultiChoice {
                    options: [],
                    selected: None,
                },
            ),
            previous_connections: NotLoaded(
                LoadingResource {
                    retry_count: 0,
                    failure_reasons: [],
                    current_state: Initialised,
                },
            ),
            failed_to_contact_influx: false,
        }
        "#);

        insta::assert_debug_snapshot!(user_messages, @r#"
        UserMessages {
            messages: [],
            current_id: 0,
        }
        "#);

        // =========================================================================================
        // confirm the correct events are called
        // =========================================================================================
        let effects = commands.effects().collect();

        insta::assert_debug_snapshot!(
            effects, @r#"
        [
            Render(
                Request(
                    RenderOperation,
                ),
            ),
        ]
        "#);

        test_shell(effects);

        let events: Vec<Event> = commands.events().collect();

        insta::assert_debug_snapshot!(
            events, @"[]");
    }

    #[test]
    fn test_load_previous_connections_result_file_not_exist() {
        let mut screen_data = InitialScreenData {
            ..Default::default()
        };
        let mut user_messages = UserMessages::default();
        let response = PersistentStorageOutput::LoadErrorFileDoesntExist;

        let mut commands =
            load_quick_actions_result(&mut screen_data, &mut user_messages, response);

        // =========================================================================================
        // check that the view has been updated correctly
        // =========================================================================================
        insta::assert_debug_snapshot!(screen_data, @r#"
        InitialScreenData {
            api_token: None,
            base_url: None,
            quick_actions: NonExistent,
            previous_connections: NotLoaded(
                LoadingResource {
                    retry_count: 0,
                    failure_reasons: [],
                    current_state: Initialised,
                },
            ),
            failed_to_contact_influx: false,
        }
        "#);

        insta::assert_debug_snapshot!(user_messages, @r#"
        UserMessages {
            messages: [],
            current_id: 0,
        }
        "#);

        // =========================================================================================
        // confirm the correct events are called
        // =========================================================================================
        let effects = commands.effects().collect();

        insta::assert_debug_snapshot!(
            effects, @r#"
        [
            Render(
                Request(
                    RenderOperation,
                ),
            ),
        ]
        "#);

        test_shell(effects);

        let events: Vec<Event> = commands.events().collect();

        insta::assert_debug_snapshot!(
            events, @"[]");
    }

    #[test]
    fn test_load_previous_connections_result() {
        let mut screen_data = InitialScreenData {
            ..Default::default()
        };
        let mut user_messages = UserMessages::default();
        let response = PersistentStorageOutput::FileData(
            r#"{"name":"test","api_token":"vzO0_9-u3Y0Q-FyO88bIVK8g3beRkvk00hDppgMGiiNVmk1wm0Cmek_QT2hTxcqdUL607FSMtgephwprZPIl7A==","base_url":"http://100.108.38.15:8086/","org":{"name":"test","id":"3aeb5581111a8d5a"},"bucket":"personal","measurement":"test_crux","tags":{"new_tag2":"hey2"},"fields":{"akey":{"Float":{"inner":""}}}}"#
                .to_owned(),
        );

        let mut commands =
            load_quick_actions_result(&mut screen_data, &mut user_messages, response);

        // =========================================================================================
        // check that the view has been updated correctly
        // =========================================================================================
        insta::assert_debug_snapshot!(screen_data, @r#"
        InitialScreenData {
            api_token: None,
            base_url: None,
            quick_actions: Loaded(
                MultiChoice {
                    options: [
                        QuickAction {
                            name: "test",
                            api_token: "vzO0_9-u3Y0Q-FyO88bIVK8g3beRkvk00hDppgMGiiNVmk1wm0Cmek_QT2hTxcqdUL607FSMtgephwprZPIl7A==",
                            base_url: Url {
                                scheme: "http",
                                cannot_be_a_base: false,
                                username: "",
                                password: None,
                                host: Some(
                                    Ipv4(
                                        100.108.38.15,
                                    ),
                                ),
                                port: Some(
                                    8086,
                                ),
                                path: "/",
                                query: None,
                                fragment: None,
                            },
                            org: Org {
                                name: "test",
                                id: "3aeb5581111a8d5a",
                            },
                            bucket: "personal",
                            measurement: "test_crux",
                            tags: {
                                "new_tag2": Some(
                                    "hey2",
                                ),
                            },
                            fields: {
                                "akey": Float(
                                    ValidatedFieldF64 {
                                        inner: "",
                                    },
                                ),
                            },
                        },
                    ],
                    selected: None,
                },
            ),
            previous_connections: NotLoaded(
                LoadingResource {
                    retry_count: 0,
                    failure_reasons: [],
                    current_state: Initialised,
                },
            ),
            failed_to_contact_influx: false,
        }
        "#);

        insta::assert_debug_snapshot!(user_messages, @r#"
        UserMessages {
            messages: [],
            current_id: 0,
        }
        "#);

        // =========================================================================================
        // confirm the correct events are called
        // =========================================================================================
        let effects = commands.effects().collect();

        insta::assert_debug_snapshot!(
            effects, @r#"
        [
            Render(
                Request(
                    RenderOperation,
                ),
            ),
        ]
        "#);

        test_shell(effects);

        let events: Vec<Event> = commands.events().collect();

        insta::assert_debug_snapshot!(
            events, @"[]");
    }
}
</code></pre>
</details>
Global events / Screen common</h3>
Organisation</h4>
Global events wise I found it nicer to group them like a screen at the moment I
group them in a global</code> folder I am tempted to put them in screens/global</code>.
Other than that it's the same structure.</p>
</p>
screens_common</code> is quite simply anything that I could generalise across screens
functions are top level and data types are under screens_common/model</code>. Stuff
in here will be imported in multiple screen functions.</p>
Global event propagation</h4>
A trick I found with some global events was that if the event changes depending
on what screen its on we can just make an event in the screens</code> folder</p>
so for the global back button in android
</p>
I implement back depending which screen im on, this will help as well for when
I move to iOS because they don't have a global back button, so I will just call
these events directly</p>
UiModel (ViewModel)</h2>
Last core organisation I did was the UiModel, renamed it UiModel instead of
ViewModel for fewer chars, and it made more sense to me.</p>
</p>
Maybe this could belong in the screens/<name>/mod.rs</code> but those files are big
enough and the UiModel crosses the FFi so made sense to keep it separate.
Organisation wise very similar setup to screens but now instead of folders I
have a file per screen.</p>
90% of this is just from methods :D</p>
Android</h2>
Organising jetpack compose</h3>
Lastly the Android (shell) side, we can keep a surprisingly similar layout
</p>
so instead of a match</code> statement per screen we have a when</code> statement working
in a very similar way, from there was can call a compose method in a separate
file so now every screen has a file under ui/<screen name></code></p>
Utilising preview</h3>
Then with the lovely @preview</code> annotation we can just build out our UI's while
staying all within the one file, I suspect if these files grow much more I may
move to a folder structure similar to core.
</p>
Conclusion</h2>
In conclusion my folder structure in core (Rust) is</p>
├── app.rs
├── capabilities
│   └── persistent_storage.rs
├── global
│   ├── mod.rs
│   ├── function1.rs
│   └── function2.rs
├── lib.rs
├── model.rs
├── model_ui
│   ├── mod.rs
│   ├── screens
│   │   ├── scren1.rs
│   │   └── screen2.rs
├── screens
│   ├── screen1
│   │   ├── mod.rs
│   │   ├── function1.rs
│   │   └── function2.rs
│   ├── screen2
│   │   ├── mod.rs
│   │   └── function1.rs
├── screens_common
│   ├── mod.rs
│   ├── common_function1.rs
│   ├── common_function2.rs
│   ├── model
│   │   ├── mod.rs
│   │   ├── common_type1.rs
│   │   └── common_type2.rs
└── shared.udl
</code></pre>

Naming schemes

Events

Ev<screen name></code> for event variation</li>
ScEv<Scren name></code> for the variation data</li>
keeping it alphabetical for easy searching.</li>
</ul>
</li>
Model Screens

<screen name>Screen</code> for variations</li>
<screen name>ScreenData</code> for variation data</li>
</ul>
</li>
Ui Model (realising I don't stick to this scheme but should update my code)

Everything is prepended with Ui</code> to keep an easy distinction for what
goes over FFI and what doesn't</li>
Ui<screen name>Screen</code> for variations</li>
Ui<screen name>ScreenData</code> for variation data</li>
</ul>
</li>
</ul>
</li>
</ul>
Pros</h3>

The majority of my time is spent in just a single folder working on 1 screen</li>
good separation of functions for testing</li>
simple naming scheme to follow</li>
</ul>
Cons</h3>

not 100% how this will work if I swap from multi screens to 1 large screen and
multi panes</li>
</ul>


Websites
2025-01-15T00:00:00+00:00
Goal</h2>
Make websites for Me / Rust Manchester / Track a Train</p>
Learn Zola</a> for easy website generation with
Gitlab pages.</p>
Where</h2>
Source</h3>

Rust Manchester</a></li>
Sean Borg</a></li>
Track a Train</a></li>
</ul>
Websites</h3>

https://rustmanchester.co.uk</a></li>
seanborg.tech ... but your already here :p</li>
https://trackatrain.co.uk</a></li>
</ul>


UpLine Privacy Policy
2025-01-05T00:00:00+00:00
Privacy Policy</h1>
Your privacy is critically important to us. Your data is your own. We make
no claims to it and will only use it according to the policies outlined below.</p>
If you have questions about deleting or correcting your personal data please
contact our support team</a>.</p>
Gathering of Personally-Identifying Information</h2>
UpLine allows you to upload data to an InfluxDB of your choosing, data used
during this process is only stored locally on your device for quick actions,
and any data sent is only sent to the InfluxDB server you have specified.</p>
Protection of Certain Personally-Identifying Information</h2>
Any Personally-Identifying Information entered is only sent to the InfluxDB
server you have specified when using UpLine No Personally-Identifying
Information is transmitted to external locations when using UpLine.</p>
Business Transfers</h2>
If UpLine, or substantially all of its assets, were acquired, or in the
unlikely event that UpLine goes out of business or enters bankruptcy, user
information would be one of the assets that is transferred or acquired by a
third party. You acknowledge that such transfers may occur, and that any
acquirer of UpLine may continue to use your personal information as set
forth in this policy.</p>
Privacy Policy Changes</h2>
Although most changes are likely to be minor, UpLine may change its Privacy
Policy from time to time, and in UpLines's sole discretion. UpLine
encourages visitors to frequently check this page for any changes to its
Privacy Policy. Your continued use of this site after any change in this
Privacy Policy will constitute your acceptance of such change.</p>
Limited Warranties</h2>
We do not warrant the completeness or accuracy of the information published
on this website; nor do we commit to ensuring that the website remains
available or that the material on the website is kept up to date.</p>
To the maximum extent permitted by applicable law, we exclude all
representations, warranties and conditions relating to this website and the
use of this website (including, without limitation, any warranties implied
by law in respect of satisfactory quality, fitness for purpose and/or the
use of reasonable care and skill).</p>
Indemnity</h2>
You hereby indemnify us and undertake to keep us indemnified against any
losses, damages, costs, liabilities and expenses (including, without
limitation, legal expenses and any amounts paid by us to a third party in
settlement of a claim or dispute on the advice of our legal advisers)
incurred or suffered by us arising out of any breach by you of any provision
of these terms of use, or arising out of any claim that you have breached
any provision of these terms of use.</p>


AI Boat
2024-09-10T00:00:00+00:00
Goal</h2>
Make a self-driving canal boat</p>
Why</h2>
Because it sounds like an awesome fun project</p>
Where</h2>
My repo dealing with interfacing with the sensors is here
https://gitlab.com/seam345/ai-boat-signaller</a></p>
Current state</h2>
It's been a while since I've had a chance to work on it</p>


Woodchopper
2024-06-25T00:00:00+00:00
Goal</h2>
Split logs from logcat without a device accessible.</p>
Why</h2>
A client of mine makes an Android device with pre-bundled apps, my main job
was working on these apps but whenever we captured logs from a customer they
were a bit of a nightmare to pull apart</p>
Android logs from a simple logcat -d</code> don’t print out the package ID they
come from, instead it outputs the PID and tag, I would love to know how
Android studio filters of package ID! The tag we can control and filter on
but it’s generally recommended to set the tag as the class name (todo
confirm its recommended and find a link ), I find due to Android studio
filtering with package ID in development I often don't pay much attention to
the tags (I admit this is probably the better solution).</p>
https://developer.android.com/reference/android/util/Log</a></p>

Tip: A good convention is to declare a TAG constant in your class:
private static final String TAG = "MyActivity";</code>
and use that in subsequent calls to the log methods.</p>
</blockquote>
Aaa although Google never explicitly suggests using the class name it is
accidentally implied, and timber automatically uses the method name as the tag.</p>
I find method name often is way too short lived for a tag ideally I need to
come up with a better convention but since I am inheriting a code base this
is not so easily changed. (started using abriviated app name with colon to a
smaller scope e.g. flow lines, rust core = FL:C</code>)</p>
A very similar application is “PID cat” which works great if you are
debugging a device you have on the desk, but this falls down if someone is
sending you system logs and you have no access to the device. This is where
woodchopper comes in splitting all logs by PID and then from there attempts
to match those logs to package IDs. Woodchopper can do this 2 ways
automatically by matching the PID on application start from the ( todo file
in demon that does this), or semi automatic by you providing some known logs
that your application emits and matching on them to give package id</p>
Who is this for… I’m not so sure really I realise the reason I’m in this
situation is because I’m writing with an Android manufacturer and they make
some built in apps but in normal operation you wouldn’t be shipping with so
much logging</p>
Differs from
https://github.com/JakeWharton/pidcat</a>
As this requires the device to be reachable via adb and calls the package
manager during running to get the PID to filter on</p>
Where</h2>
https://gitlab.com/seam345/woodchopper</a></p>
Current state</h2>
I haven't come back to it in a while atm it does manage to separate the logs
out, but I think i want to grab ratatui to properly display them nicely</p>


Yoto
2024-06-01T00:00:00+00:00
Goal</h2>
Run a Yoto with custom firmware so it doesn't need a cloud connection, ever</p>
Why</h2>
Yoto</a> is a neat little jukebox but im not a fan
of my data having to live in AWS</p>
Also, I have never done any reverse engineering before and that sounded fun</p>
Where</h2>
https://gitlab.com/sean-twitch-projects/notes/-/blob/main/Yoto.md</a></p>
Current state</h2>
I was doing half well weekly streaming me tearing it apart and flashing it
then I hit a bit of a bump and failed to maintain the weekly recurrence, I
have since learned I should really have read what was on the chip before
flashing it so I may have to buy a second to actually move forwards with any
speed</p>


Rust Manchester meetup
2024-04-01T00:00:00+00:00
Goal</h2>
Increase Rust jobs/usage/knowledge in Manchester</p>
Why</h2>
I use and enjoy writing programs in Rust I would love to see it expand in my
home city!</p>
Where</h2>
https://rustmanchester.co.uk</a></p>
Current state</h2>
We run a ~monthly meetup at the moment alternating between talks and code
nights, please if you have a talk (and are happy to come to Manchester)
email us talk@rustmanchester.co.uk</a></p>


UpLine (internally FlowLine)
2024-01-06T00:00:00+00:00
Goal</h2>
Easy and simple way to log to influxdb</p>
Why</h2>
I wanted a way in input versions time series data, weight, PB’s,</p>
tools for displaying graphs from influxdb are easy to setup and I can run
complex queries to show what I like really fast, the slow part was getting
the data in when it cant be automated</p>
Where</h2>
Source code</h3>
https://gitlab.com/seam345/flow-lines</a></p>
App</h3>
Currently, it is available in open beta
 </a>
</p>
Current state</h2>
Actively worked on and in open beta, hopefully launched soonish</p>


Zigbee2MQTT types
2022-10-17T00:00:00+00:00
Goal</h2>
Generate Rust structs for all the Zigbee2MQTT devices</p>
Why</h2>
While creating Skipper</a> I found myself being lazy with
how I was defining my structs to consume MQTT payloads and given they are
already defined in Zigbee2MQTT, so I went looking for a way to generate them
programmatically.</p>
Where</h2>
https://gitlab.com/seam345/zigbee2mqtt-types</a></p>
Current state</h2>
Unmaintained... I found a lot of bugs in them at some point they need fixing</p>


Skipper
2022-09-28T00:00:00+00:00
Goal</h2>
Automate as much of the electronics in my boat, don't ask me why I don't use
home assistant (it would be easier)</p>
Why</h2>
Fun</p>
Where</h2>
https://gitlab.com/seam345/skipper</a></p>
Current state</h2>
Not staying on the boat frequently enough to keep this maintained :/</p>


ESP32 Rust
2022-07-22T00:00:00+00:00
Goal</h2>
Make something useful with an ESP32-C3 and learn writing bear-metal Rust</p>
Why</h2>
Always wanted to do more low level coding, I've done some in the past with
Arduino's and would like to practice with Rust</p>
Where</h2>
https://gitlab.com/seam345/esp32-rust</a></p>
Current state</h2>
Mostly an abandoned project at this point, but I do use it as an
accelerometer sensor in my boat :D</p>


GPS fixer
2022-07-13T00:00:00+00:00
Goal</h2>
Basically replace Google timeline</p>
Using Geo tracker</a>
I have years of GPX files that would be great to look back on</p>
But I need a nice way to Correct and simplify GPX files.</p>
Things to correct</h2>

GPS drift when in same location without additional date like satellite count</li>
Loss of gps when on repeated routes</li>
</ul>
Where</h2>
Think its technically living here atm https://gitlab.com/seam345/rawgpx-to-influx</a>
a previous version was https://gitlab.com/seam345/gpx-fixer</a></p>
This is a project I keep starting but haven't defined my solution properly
or bite off more than I can chew in the spare hours I give it</p>


Photo dater
2022-07-13T00:00:00+00:00
Goal</h2>
I have a lot of photos that have incorrect dates either due to the photo being a
scan, somebody has shared it with me on another date and meta data was stripped,
or incorrect date on the camera.</p>
I want a way to fix these mistakes</p>
Feature ideas</h3>
After attempting this proble once or twice I need</p>

a way to bulk edit date on a group of photos</li>
easy ways to make a group photos, some ways to suggest could be

By folder</li>
by scene</li>
by location</li>
by persons face / maybe age</li>
</ul>
</li>
</ul>
Where</h2>
my past attempts are too old a new repo needs to be made</p>


Nixos Config
2022-05-10T00:00:00+00:00
Goal</h2>
Configure all my computers and RPI's</p>
Why</h2>
Used to run Arch (because it worked when iI followed the instructions) but
started managing many other headless computers/RPI's and NixOs helped me
keep everything in order, maybe the repo is not very well ordered though :D</p>
Where</h2>
https://gitlab.com/seam345/nixos-config</a></p>
Current state</h2>
I should really maintain the config more but "it just works"</p>


Rustkey
2021-11-08T00:00:00+00:00
Goal</h2>
Providing a simpler interface to unlock the FDE on my computers using a
YubiKey as 2FA</p>
Why</h2>
I hit a bug in the previous implementation I was using and somebody
recommend I replace it with Rust :D</p>
Where</h2>
https://gitlab.com/seam345/rustykey</a></p>
Current state</h2>
No longer maintained after nix dropped support for the bash script version</p>


3D printing Greater Manchester wards - from GeoJson to STL
2019-01-01T00:00:00+00:00
</p>
Converter</h2>
The end result is this tool</a></p>
The Goal</h2>
To turn this wonderful map visualisation by Jamie Whyte (used to link to
twitter I'm not linking to X) into a real physical object using 3D printing.</p>
Additional Goal</h2>
To create a simple online converter that can convert from GeoJson to STL,
making it much easier for people to print their own map data. Feel free to
check it out at geojson-to-stl</a> or help me
improve it at GitHub</a></p>
Understanding the data</h2>
First I look at what I have, a GeoJson file.
</p>
The GeoJson may at first be overwhelming, but it is well organised in the
JSON format. Amazing diagrams that explain the structure here</a> 
and great online tools to make the format more readable using
indentation here</a>. 
</p>
With no knowledge of GeoJson but strong familiarity with JSON I can see that
we have an object with a huge list of features, 215 to be precise, I imagine
each one is a ward by looking at the first item that is expanded a little.</p>
The geometry object looks very useful, lets expand it …</p>
</p>
Ok it looks like the geometry object is a long list of coordinates. Looking
a little closer we can see that the first and last coordinate is the same,
so we have a list of 2D coordinates that loop round to form a complete shape
(a polygon</a> as the
type specifies in the file). Fantastic we can use these coordinates to
generate our STL files somehow just need to convert these coordinates (known
as Geographic coordinates</a>)
to X,Y coordinates (known as Cartesian coordinates</a>).</p>
Geographic Coordinates to Cartesian Coordinates</h2>
I had a look around for how to convert Geographic to Cartesian coordinates
and found this page</a>
from Wolfram MathWorld. I needed to map the sphere to a cylinder and
then roll it out, this is archived using this formula to convert the values;</p>
where λ is longitude and θ is latitude</p>
λ₀ is our first longitude point making x relative to our first point however
Y is currently relative to the equator which will distort our model, so we
need to subtract tan(θ₀) to also make Y relative to my first point. This
results in:</p>
X = λ - λ₀
Y = tan(θ) - tan(θ₀)
</code></pre>
Cartesian Coordinates TO STL</h2>
I now have a list of X,Y points, I now need to understand the STL format to
generate a correct file that Cura can understand and recreate my shape.
There are 2 formats STL</a>
can be, in ASCII or Binary. Given Binary’s only advantage is smaller file
size, I picked ASCII as it is just plain text, making it much easier to find
errors when things are not working correctly.</p>
To make a shape I need to start my file with</p>
solid name  (name can be any whatever I want)
</code></pre>
endsolid name  (name has to be the same as used at the start)
</code></pre>
Computers are very dumb, but they can do the same thing very fast this
results in almost all 3D computer graphics being stored as a huge number of
triangles, as any shape can be broken down into a number of triangles to
represent that object.</p>
STL defines a triangle in this format :</p>
facet normal ni nj nk
    outer loop
        vertex v1x v1y v1z
        vertex v2x v2y v2z
        vertex v3x v3y v3z
    endloop
endfacet

</code></pre>
I turned out that I could break the shape down into rectangles. As I walked
around the shape I take my current point and next point to determine the
width of the rectangle, then the height will be determined by a constant
value. These rectangles can then be split into 2 triangles by cutting
through 2 diagonal points.</p>
The STL format for the method above</p>
facet normal 0 0 0
    outer loop
        vertex point1X point1Y 0
        vertex point1X point1Y 0
        vertex point2X pointY2 height
    endloop
endfacet
</code></pre>
facet normal 0 0 0
    outer loop
        vertex point1X point1Y height
        vertex point2X point1Y height
        vertex point2X point1Y 0
    endloop
endfacet
</code></pre>
The facet normal is a bit more complicated to explain, without getting
mathsy, but thankfully after reading about it and testing it in Cura we can
safely ignore it and just put facet normal 0 0 0. **Note this is bad
practice and will not load in some STL viewers that are stricter than
Cura.</p>
I loaded the file into Cura to see a complete shape!!
</p>
Fantastic we have the perimeter done!! turns out we don’t need a top and
bottom face for Cura to generate the printing code, so I printed the piece.</p>
 </p>
Beautiful! Almost perfect except for the curling of the edges, I tweaked
some setting in the later prints to help reduce this. However, I had another
worry… Would they fit together, some of these angles are really small so I
tested it by printing out an area… Rochdale's wards have some interesting
interlinks (also doubles as my hometown) so I printed Rochdale.</p>
Tolerance</h2>

</p>
A wonderful print, with less curling this time!! However, my worry was
correct two of the pieces will not fit together! This is due to the plastic
having a thickness and the points have no gap to account for this, we need
to add some tolerance. How much tolerance was worked out later with some
trial and error later but for I needed a way to compute all the new X,Y
points with tolerance applied first.
</p>
My plan was to move each point into the shape by a set amount (tolerance).
The tricky part was to move the point in the correct direction. Originally,
I started out by using a lot of trigonometry and calculating way to many
angles (with many conditions) to work out what the correct angle was, then
calculate the line. Until I found this</a>
answer on a stack exchange site…</p>

"By definition, the sum of two vectors is equal to the diagonal of the
parallelogram spanned by the vectors.</em>"</p>
</blockquote>
I did however have to draw out what the person was saying to understand what
he meant.</p>
</p>
We get 2 vectors (lines) from a point of the same length ( I can normalise</a>
any vector so this is easy enough). I then stick the opposite vector to the
end of the other vector and to get a parallelogram</p>
</p>
Draw a line from our point to the opposite point, and we have a line with a
direction exactly half the angle! Now all that is left to be done is to walk
along the line by the threshold amount to get my new X,Y coordinates for
that point.</p>
</p>
There is however 1 flaw in this method, it only ever dissect the smaller
angle of the 2 possible angles, however there are times I needed the larger
angle (orange angle) but if I followed the green line then I would have gone
in the wrong direction… Thanks to all the trigonometry I did earlier I had a
nice method to calculate if I want the convex (large) or concave (small)
side, telling me which direction to go in.</p>
The obvious next question is what tolerance I should give the print I went
down the simple route of printing out a very thin version (to make it a
quick print) of the 2 pieces that wouldn’t fit together first with 0.1 then
0.2 and finally 0.3 millimeter tolerance.
</p>
left to right 0.1 mm, 0.2 mm</strong> and 0.3 mm</strong> tolerance.</p>
The 0.1mm didn’t fit at all you can even kind of see that the bigger cut out
doesn’t even fit together. 0.2mm could fit with some squeezing but was very
eager to pop itself back out, whereas the 0.3mm fit really nicely… So 0.3mm
it is!</p>
Everything is sorted and ready for the whole map now, stared with Rochdale
to triple check everything worked and then continued on with the rest of the
map</p>
 
Images of the Rochdale area this time in the correct colours and with the
tolerance applied, we can see the pieces fit together perfectly!</p>
Reflections</h2>
This was a great project (even if it was over a week of non-stop printing)
I’ve been overwhelmed by the reaction it has received. There are a lot of
extra improvements that I can think of making, but for a while now I’m going
to make the online converter work better and be more user-friendly.</p>
One last note I need to thank TIH</a> for letting
me use their printer, especially for 2 weeks of nearly constant use!</p>
I have also added a dead ends section bellow to highlight that there was a
few things that I spent a while on that was either just not used or made no
impact on the end product. The section is there to show that dead ends is
just a normal part of development and that they do usually provide something
useful, be that increased knowledge in the area or a nicer product at the end.</p>
Dead ends - rabbit holes (quick notes)</h2>
Using direction and magnitude to create the shape</h3>
Originally I was working out the parimeter from just calculating the
distance and direction from point to point, using the functions from this
amazing site https://www.movable-type.co.uk/scripts/latlong.html</a></p>
</p>
I did this knowing that it may be off a little because you cannot map a
sphere very easily to a flat 2D plane. However, I never knew that I would be
so far by my guess I was about 1KM (on my scale 1cm) out after spending an
hour or so making sure I was definitely moving in the correct direction at
every point.</p>
I couldn’t believe just how far out it was I expected me to be less than a
mm off and I would just snap the ends together somehow, so it was a complete
object. However, after seeing the gap it left I knew I had to do it the
proper way.</p>
Polygon triangulation</h3>
(loved the name but basically I’m putting a surface on the top and bottom of my
shapes)</p>
As mentioned earlier when I first created the perimeter of the shape, I
didn’t think Cura would add the top and base to complete the shape allowing
it to print, apparently the older versions didn’t but I couldn’t find any
word of it in the changelog</a>.</p>
So I ended up spending a whole day making this work, after some googling I
found the name for it was called “Polygon triangulation</a>”
and found that the easiest algorithm to implement was probably ear clipping
admittedly this was really fun to implement, a great YouTube video to
visualise how it works here</a>. 
Even though it wasn’t needed I shall still be using it with my online
conversion tool because it makes the models look significantly better when
rendering, despite it making no difference in the print.</p>


GeoJSON to STL
2019-01-01T00:00:00+00:00
Goal</h2>
Have an easy way to covert GeoJSON to STL</p>
Why</h2>
I wanted to print out a cool map</a></p>
Where</h2>
Source</h3>
https://github.com/seam345/GeoJsonToSTL</a></p>
Working tool</h3>
Bellow these headings :D I do love that with a nice web JS tool I can just
embed it :D</p>
Current state</h2>
It works, not very fancy, your millage may very I don't ever see me updatin
this any further</p>
The tool</h1>
Please select a GeoJson file from your pc, then select the value you would
like to use for height and what to group the files by (group shall add the
files into folders with the group name) then click Generate STL.</p>
Please note this is a very early version, there is no loading spinner to
signify it is working, it takes a few seconds to start downloading when I
run it, no error messages are displayed either. Also you will be downloading
a zip file I found that chrome will say it is harmful, you can just click
the arrow and tell chrome to keep the file.</p>
Other than the initial loading of this page and 2 javascript packages jszip</a>
and FileSaver</a>, no network is
required to convert the STL files and I don't send back any data to the server.</p>
You can let me know something went wrong on the contact me page, or on
github at GeoJsonToSTL</a>, feel free
to submit issues or pull requests.</p>





</p>
</p>
Tolerance: </span></p>


Number of features in GeoJson: N/A</span></p>
</p>
</p>
</p>

  </div>
</div>

Sean Borg

TB: Wrapper manager

TB: Euler diagram of rust week talks

TB: Build a nix pkgs out of nixpkgs

TB: Rust Result

All the Rust Tutorials

Rust learning list

Goal</h2> Make a nice and easy way to search all of Rust's learning resources by cataloging every Rust learning resource out there!</p>

Structuring code in a multi-page Crux app

The model</h2> The internal data struct</code></p>

Screen mod.rs</h3>

Full file</h4>

Function files</h3> Tiny subset of the function files to see how everything works.</p>

Global events / Screen common</h3>

Pros</h3> The majority of my time is spent in just a single folder working on 1 screen</li> good separation of functions for testing</li> simple naming scheme to follow</li> </ul> Cons</h3> not 100% how this will work if I swap from multi screens to 1 large screen and multi panes</li> </ul>

Cons</h3> not 100% how this will work if I swap from multi screens to 1 large screen and multi panes</li> </ul>

Websites

Goal</h2> Make websites for Me / Rust Manchester / Track a Train</p>

UpLine Privacy Policy

Privacy Policy</h1> Your privacy is critically important to us. Your data is your own. We make no claims to it and will only use it according to the policies outlined below.</p>

Protection of Certain Personally-Identifying Information</h2> Any Personally-Identifying Information entered is only sent to the InfluxDB server you have specified when using UpLine No Personally-Identifying Information is transmitted to external locations when using UpLine.</p>

AI Boat

Goal</h2> Make a self-driving canal boat</p>

Why</h2> Because it sounds like an awesome fun project</p>

Woodchopper

Goal</h2> Split logs from logcat without a device accessible.</p>

Yoto

Goal</h2> Run a Yoto with custom firmware so it doesn't need a cloud connection, ever</p>

Rust Manchester meetup

Goal</h2> Increase Rust jobs/usage/knowledge in Manchester</p>

Why</h2> I use and enjoy writing programs in Rust I would love to see it expand in my home city!</p>

UpLine (internally FlowLine)

Goal</h2> Easy and simple way to log to influxdb</p>

Why</h2> I wanted a way in input versions time series data, weight, PB’s,</p> tools for displaying graphs from influxdb are easy to setup and I can run complex queries to show what I like really fast, the slow part was getting the data in when it cant be automated</p>

Where</h2>

Zigbee2MQTT types

Goal</h2> Generate Rust structs for all the Zigbee2MQTT devices</p>

Skipper

Goal</h2> Automate as much of the electronics in my boat, don't ask me why I don't use home assistant (it would be easier)</p>

Why</h2> Fun</p>

ESP32 Rust

Goal</h2> Make something useful with an ESP32-C3 and learn writing bear-metal Rust</p>

Why</h2> Always wanted to do more low level coding, I've done some in the past with Arduino's and would like to practice with Rust</p>

GPS fixer

Goal</h2> Basically replace Google timeline</p>

Things to correct</h2> GPS drift when in same location without additional date like satellite count</li>

Photo dater

Goal</h2> I have a lot of photos that have incorrect dates either due to the photo being a scan, somebody has shared it with me on another date and meta data was stripped, or incorrect date on the camera.</p> I want a way to fix these mistakes</p>

Where</h2> my past attempts are too old a new repo needs to be made</p>

Nixos Config

Goal</h2> Configure all my computers and RPI's</p>

Why</h2> Used to run Arch (because it worked when iI followed the instructions) but started managing many other headless computers/RPI's and NixOs helped me keep everything in order, maybe the repo is not very well ordered though :D</p>

Rustkey

Goal</h2> Providing a simpler interface to unlock the FDE on my computers using a YubiKey as 2FA</p>

Why</h2> I hit a bug in the previous implementation I was using and somebody recommend I replace it with Rust :D</p>

3D printing Greater Manchester wards - from GeoJson to STL

GeoJSON to STL

Goal</h2> Have an easy way to covert GeoJSON to STL</p>

Current state</h2> It works, not very fancy, your millage may very I don't ever see me updatin this any further</p>

Goal</h2>
Make a nice and easy way to search all of Rust's learning resources by cataloging every Rust learning resource out there!</p>

The model</h2>
The internal data `struct</code></p>`

Function files</h3>
Tiny subset of the function files to see how everything works.</p>

Pros</h3>

The majority of my time is spent in just a single folder working on 1 screen</li>
good separation of functions for testing</li>
simple naming scheme to follow</li> </ul>
Cons</h3>

not 100% how this will work if I swap from multi screens to 1 large screen and multi panes</li> </ul>

Cons</h3>

not 100% how this will work if I swap from multi screens to 1 large screen and multi panes</li> </ul>

Goal</h2>
Make websites for Me / Rust Manchester / Track a Train</p>
Learn Zola</a> for easy website generation with Gitlab pages.</p>

Privacy Policy</h1>
Your privacy is critically important to us. Your data is your own. We make no claims to it and will only use it according to the policies outlined below.</p>
If you have questions about deleting or correcting your personal data please contact our support team</a>.</p>

Protection of Certain Personally-Identifying Information</h2>
Any Personally-Identifying Information entered is only sent to the InfluxDB server you have specified when using UpLine No Personally-Identifying Information is transmitted to external locations when using UpLine.</p>

Goal</h2>
Make a self-driving canal boat</p>

Why</h2>
Because it sounds like an awesome fun project</p>

Goal</h2>
Split logs from logcat without a device accessible.</p>

Goal</h2>
Run a Yoto with custom firmware so it doesn't need a cloud connection, ever</p>

Goal</h2>
Increase Rust jobs/usage/knowledge in Manchester</p>

Why</h2>
I use and enjoy writing programs in Rust I would love to see it expand in my home city!</p>

Goal</h2>
Easy and simple way to log to influxdb</p>

Why</h2>
I wanted a way in input versions time series data, weight, PB’s,</p>
tools for displaying graphs from influxdb are easy to setup and I can run complex queries to show what I like really fast, the slow part was getting the data in when it cant be automated</p>

Goal</h2>
Generate Rust structs for all the Zigbee2MQTT devices</p>

Goal</h2>
Automate as much of the electronics in my boat, don't ask me why I don't use home assistant (it would be easier)</p>

Why</h2>
Fun</p>

Goal</h2>
Make something useful with an ESP32-C3 and learn writing bear-metal Rust</p>

Why</h2>
Always wanted to do more low level coding, I've done some in the past with Arduino's and would like to practice with Rust</p>

Goal</h2>
Basically replace Google timeline</p>
Using Geo tracker</a> I have years of GPX files that would be great to look back on</p>
But I need a nice way to Correct and simplify GPX files.</p>

Goal</h2>
I have a lot of photos that have incorrect dates either due to the photo being a scan, somebody has shared it with me on another date and meta data was stripped, or incorrect date on the camera.</p>
I want a way to fix these mistakes</p>

Where</h2>
my past attempts are too old a new repo needs to be made</p>

Goal</h2>
Configure all my computers and RPI's</p>

Why</h2>
Used to run Arch (because it worked when iI followed the instructions) but started managing many other headless computers/RPI's and NixOs helped me keep everything in order, maybe the repo is not very well ordered though :D</p>

Goal</h2>
Providing a simpler interface to unlock the FDE on my computers using a YubiKey as 2FA</p>

Why</h2>
I hit a bug in the previous implementation I was using and somebody recommend I replace it with Rust :D</p>

Goal</h2>
Have an easy way to covert GeoJSON to STL</p>

Current state</h2>
It works, not very fancy, your millage may very I don't ever see me updatin this any further</p>