#robmartinson.me #pinned

This is a work in progress at the moment. Don't expect anything amazing or interesting here, I'm just trying to get the basics working. Who am I? Go read some things about me.

#robmartinson.me

When we first bought our building we cleaned out a lot of old garbage but one thing we stumbled upon was an old pay phone. We’ve since wired it up to a voip adapter and hung it in the main dev room. Cool stuff.

#robmartinson.me

Have you been to our space? It’s pretty awesome. Check it out.

#robmartinson.me

In the 90s, having the webmaster@ email address was a status symbol. I was killin' it!

#robmartinson.me #flutter

I’ve been on a kick lately sucking up all of information I can about Flutter. Lots of interesting projects and entities using it including large enterprise stuff like Toyota’s in-dash ui. I’ve gone down the path of a variety of different cross-platform mobile and UI tools including things like Xamarin, ionic and even Delphi (I love Delphi!). Flutter definitely feels much more established and accepted than many and I like that it makes it to machine code. May start a ui client for the blog site as a learning project…..

#robmartinson.me

If you know nothing about Go, here are a few key or interesting points that make it a great tool for our toolbox:

• It is statically typed and compiles to machine code so it is very fast.
• Compiling Go code is very fast, even for large projects. The Go compiler itself is written in Go.
• It has built-in support for concurrent programming with goroutines and channels.
• The standard library comes with everything you need to build web servers, handle HTTP requests, work with databases, and all of the usual tasks.
• You can write code on any platform and compile it for any other platform.
• It can be statically linked, which means you can create a single binary that contains everything you need to run your application without any external dependencies.
• There is a huge ecosystem of libraries and frameworks available for Go, making it easy to find tools for your specific needs.

A few things that you might use every day that were built with Go include things like: Docker, Kubernetes, Terraform, Prometheus, Grafana, Caddy, Ngrok, Minio, Etcd

Documentation and Other Resources

• Go.dev - Official Go site
• Awesome Go - A curated list of Go frameworks, libraries, and software.
• r/golang - A subreddit for Go developers.
• Gophers Slack - A Slack community for Go developers.

Installing Go

To install Go, use brew:

brew install go

Starting a New Project

To start a new Go project, follow these steps:

1. Create a new directory for your project.
2. Initialize a new Go module by running go mod init <module-name> where <module-name> is the name of your project. Note: The module name is usually the repository URL but can be any name such as myapp or gitlab.com/limelyte/client/myapp
3. Create the recommended project structure as shown below.

Project Structure

In general, Go doesn't care how you structure your project and it can be as simple as having a single main.go file for small utility applications. That said, when creating a new Go project it is important to follow a consistent structure, especially for larger projects. Here is a recommended project structure for a Go application that follows best practices and works well for most applications:

myapp/
├── cmd/               --> Main binaries for this project under cmd. You can have multiple binaries in a single project.
│   └── myapp/
│       └── main.go    --> Entry point of this binary. This will be the "main" package.
│    └── myapp2/
│       └── main.go    --> Entry point of another binary. This will also be the "main" package for this binary.
├── internal/          --> Private application and library code specific to this project
│   ├── handlers/      --> HTTP request handlers or controllers. If this is package "handlers" it will be referenced as "myapp/internal/handler"
│   ├── models/        --> Data models: package "models" referenced as "myapp/internal/models"
│   ├── service/       --> Other business logic, services, etc. referenced as "myapp/internal/service"
│   ├── templates/     --> HTML templates
│   └── util/          --> Utility functions: referenced as "myapp/internal/util"
├── pkg/               --> Public application and library code that can be used by other projects 
│   └── mypackage/         This may not be used in all projects
├── configs/           --> Configuration files
│   └── config.yaml    
├── go.mod             --> Go module file,  this is auto-generated
├── go.sum             --> Go module dependencies, this is auto-generated
├── .env               --> Environment variables
├── Makefile           --> Makefile for build automation
└── README.md          --> Project documentation / readme

A simple command line application structured similarly could omit the internal, pkg, and configs directories if they are not needed as outlined below:

myapp/
├── cmd/
│   └── myapp/
│       └── main.go
├── go.mod
├── go.sum
└── README.md

Running the Application

To run your Go application in the above structure, you can use the following command from the root of your project:

go run ./cmd/myapp/*.go

This will build and run the myapp binary and will ensure that all dependencies are included.

Adding Packages and Dependencies

To add a new dependency to your Go project, use the following command:

go get <dependency>

A few of my favorite Go packages, tools and libraries

• Gin Gonic - A web framework for Go and provides features like routing, middleware, and more.
• Gorm - An ORM library for Go that provides a simple and powerful way to interact with databases.
• Cobra - A library for creating powerful command-line applications.
• Go Dotenv - A library to load environment variables from a .env file.
• Casbin - An authorization library that supports access control models like ACL, RBAC, and ABAC.
• GJSON - A library for parsing JSON with a simple syntax and fast performance.
• SJSON - A library that provides very fast JSON manipulation.
• ModernC Sqlite - A SQLite driver for Go that is easy to use and integrates well with the standard library and does NOT depend on CGO (meaning you can build it statically without C dependencies).
• TinyGo - A Go compiler that is designed for small places, like microcontrollers and WebAssembly.
• Gobot - A framework for robotics, drones, and the Internet of Things (IoT).
• GoReleaser - A release automation tool for Go projects.

#robmartinson.me

After 30+ years in the software development industry with 20 of those working primarily on a Mac workstation, here are my top must-have tools for every software developer or technologist working on the MacOS platform. Although I constantly try out new tools and experiment with different workflows, it takes something pretty solid to remain in consistent use.

• TablePlus: Lightweight, fast database tool that supports all the necessary drivers, stores queries and connections in iCloud and ships for iOS too.
• VSCode: Nothing to say here. Add CoPilot and whatever language extensions you want (for me it's Python, Go, HTML, CSS, makefiles and a few others.)
• Wezterm: Fantastic and extremely configurable terminal written in Rust and scriptable with Lua.
• Hammerspoon: Lua scripting to automate your Mac desktop.
• RapidAPI for Mac: Excellent API client that supports all of the necessary functionality and has cloud storage of projects.
• Wireguard: Secure connectivity to the office (or home, or clients' or...). We deploy a WireGuard endpoint on a Raspberry Pi for the ultimate client -> server style VPN.
• BearApp: I write notes and outlines constantly and have for years. This serves as my dumping ground and storage facility for all of it. Plus, you can write exports and do things like push to a blog. How do you think I write this content? 
• Fantastical: A powerful and intuitive calendar app that integrates seamlessly with various calendar services and offers natural language input for quick event creation. This is found a home instead of the default Mac calendar and task list for me. 
• MimeStream: Native Gmail-based email in a real app. Multiple accounts, great searching, all of the normal Gmail must-haves.
• IstatMenus: A comprehensive system monitoring tool that displays CPU, memory, network, and other vital system information right in your menu bar.
• Git Tower: A user-friendly and powerful Git client for Mac, offering features like interactive rebase, submodules support, and conflict resolution helpers. If you’re every day, workflow is just the standard commit push, you can stick with tools in VS code, etc. But if you are doing a significant amount of branching and merging work, this is a great tool to see all history. 
• Kaleidoscope: An advanced diff and merge tool for developers, supporting various file types and integrating well with version control systems.
• Panic Transmit: sets the standard for simplicity, reliability, and user interface as a file transfer tool. Supports all the needed things such as FTP, STP, Web, S3 buckets, etc.
• ngrok: A tool for exposing local servers behind NATs and firewalls to the public internet over secure tunnels, great for testing and sharing your work.
• Sublime Text: Not much to say here, if you need a rocksolid text editor this is the one.
• jj: A command-line JSON processor that allows for quick and easy manipulation of JSON data.

These tools have proven invaluable in my day-to-day work writing software working with API’s and all other manner of problem-solving. Whether you're a seasoned developer or just a geek, these are all worth a look and can make a noticeable difference in your effectiveness.

#robmartinson.me #blog

Summary

First revision of the blog / feed application is up and running. Companion Bear.app connector script that pushes notes containing a certain tag out to the post API every few minutes.

So far, I like it! It syncs from a certain tag or tags from Bear. It allows me to quickly publish and/or adjust content. It’s an easy way for me to quickly push notes or content out to different folks and I think it will be a good feed aggregation point.

Current State

• Infrastructure
  • Caddy reverse proxy
  • go backend using Gin
  • SQLite storage
  • Running on raspberry pi 4 with 8GB ram
• Functionality
  • Generic “post” entry that has a source and source ID to allow for different source feeds.
  • Supports viewing posts by slug or UUID
  • Supports filtering posts by tags and all tags are clickable
  • Correctly parses tags out based on Bear style regex
  • Api to add and manage posts
  • Initial post type of “bearnote”
  • Companion python script to push notes from bear to api.
    • Setup on 5 min cron from home workstation
    • This currently only syncs notes that contain a specific tag (for now, #robmartinson.me so all notes MUST contain at least this tag and/or others to be pushed.
    • Script supports deleting of old posts and correctly sends a DELETE for any trashed Bear notes
    • Currently pushes all posts and attachments on every cycle.
    • Correctly marks any items flagged as pinned in Bear as pinned posts which automatically move to navbar. Note: may want to remove pinned notes from the main listing.
      • Although this works well when viewing posts within a tag in Bear, it could be annoying to have all of the nav posts pinned to the top of the main Bear list. I may want to adjust this to use a tag instead. Probably better.

How tags work

• ’robmartinson.me’ is required for bear_sync.py to pick up the note at all and push to API. No other processing happens with this on server-side
• ’pinned’ should be sorted first, before updated date so these items always float to the top of the feed list
• ’nav’ items should be added as navigation items
• ’hidden’ items shouldn’t be listed in the main feed, but are still accessible via their direct link. You can combine ‘hidden’ and ‘nav’ to make nav only links.

Needs / Todo

• Next connector:
  • Try a simple inbound feed such as Twitter/X or Threads. Free X API has limits but may allow reading my own posts a few times a day, need to dig into this.
• Allow linking between notes using Bear’s IDs. Will need to translate bearID to postID. Check the [[About]] page. I should be able to do this just by slugifying bear note links like [[ this ]]
• Move all specialized link, tag and image rendering into the goldmark markdown processor, currently using a quick and dirty approach parsing needed things (like hashtags) outside of the markdown processor.
• Add paging to post list, should maintain state with filters
• Add api endpoint to return all unique tags (to be used for a tag search or list )
• Add smart search by tag and/or text
  • Search by tag or tags and auto-filter
  • Search by text and auto filter
• Adjust card header/post title to prevent line breaks and allow either scrolling side to side or… When viewed on mobile or smaller screens
• Add google analytics token

Ideas and Pondering

• Threading functionality, this is a new thought. Essentially have the ability to view posts in a thread style timeline (oldest first) where a certain tag matches. So if you look for /threads/ it lists oldest first, then displays a connector between each subsequent post. This could further be filtered with ?tags=,
• Allow it to serve from different urls. Each URL can have its title and templates and can filter content to those with a set of tags.
  • For example, currently the bear script filters all posts and only pushes those containing the #robmartinson.me tag to the API. But I could also have it push tags for a different site like #martinson.shop. From the web side, if a user requests content from the robmartinson.me domain, the system would serve all posts tagged there (regardless of tags). Similarly if the user requested from the martinson.shop domain, it would serve content with that tag. A post with both tags, would be visible in both places.
  • Things to consider:
    • How does this work for things that aren’t Bear notes, like twitter, instagram or other inbound feeds. Maybe domains configure specific content as well, like source: bear tags: robmartinson.me or source: x.com/robmartinson tags: any, source: x.com/limelytedotcom tags: any and so-on.

#robmartinson.me #martinson.shop #Limelyte Technology Group Inc# #robotics

Levi and Tanner came up with a great first challenge for our robotics cars. The general idea is to autonomously navigate from the Buchanan building east entrance foyer, through the dev room, up the ramp to the lab, out through the Star Wars hallway, down the stairs (there will be a ramp), past the bathrooms and all the way through the west hallway to the east entrance foyer.

General rules

• Use any language you want
• Your bot must navigate autonomously, you cannot provide user controls while it’s navigating.
• You can use any sensors on the existing bot. You cannot draw on the floor for the grayscale sensor. You must be able to navigate the every day environment (except for the ramp down the stairs)
• You must be able to avoid or generally navigate around objects in its path (desks, chairs, etc).

Thoughts…

From Luke: this is essentially doing what a Roomba does. You will likely need to create and/or store a set of boundaries or map that you navigate within so your car has an outline to remain within.

#robmartinson.me #Limelyte Technology Group Inc# #martinson.shop #shopnight

#robmartinson.me #robotics #raspberrypi

Ordered a couple of these guys a few weeks ago and they just showed up. Pretty slick running the RP 2040 which is becoming a favorite microcontroller for me. Going to see what we can come up with to deploy some client code to this one.

#robmartinson.me# #blog

For several years I’ve had a loose idea in my head about a 2 way content aggregator to act as sort of a blog or feed. I tend to create content in a variety of different places without a solid focus in one single area and I would like a way to capture all of that and make it useful. For example, I may post intermittently on the @themartinsonshop instagram page, or the @robmartinson twitter/X account, or the @rob.martinson threads account. I also make a ton of notes and brain dump outlines in Bear.app and sort of use that as my central information collection spot. I create meeting notes in Bear and also to a variety of different Google accounts. Some of these variety of outlets are business related, lots are personal hobby style things and many are just vents or rants in my head that may sometimes be useful to others.

Anyway, the idea is to create an online application feed aggregator that works in both directions to sort of collect and distribute data to the different places but also keep a central record of it all and allow readers (probably mostly me) consume it and filter it by its source and/or its destination or subject matter. What if I could post content on any one of the services or tools above (twitter, instagram, threads, slack, whatever) and a record of that made it back to my personal website. Likewise I could post my mini brain dumps, ideas and rants in Bear.app and by applying some known tags, it would be collected on the personal website and available to others, but also may post to one of the other spots too. I think this is sort of like what Pixelpipe used to do, but with a receiving aggregator as well.

The primary storage point for most of my personal content, notes, ideas, etc. is Bear.app so I should start there.

Goals

• Learn and experiment with different languages and technologies
• Write / develop content
• Create a reusable useful tool
• Push content to all of the places
• Pull content from all of the places

Misc

• Golang backend
• Blog backed by dynamo? Sqlite?
• Evernote api
• Thinkorswim api
• Bear api
• Insta feed
• What I’m listening to

Infra

• cheapest / fastest / simple and learn new stuff
• Fastapi + Jinja + sqlite
• Golang + html templates + sqlite

Deployment

• Raspberry pi (4 or 5) ?
  • Hosted at the martinson shop? Limelyte?
  • Replicated and/or load balanced?
• VPS?
• SQLite + Litestream?
• How to make it so cheap, free, easy

Activity aggregator

Micro blogging / activity aggregating platform. Log events of a certain type in time with tags.

Brain Dump!

• Outbound: If I post content on the site, it pushes that content to different places based on the tags it contains. #threads #martinson.shop etc
  • Maybe use bear as the creation point and create an integration to push content. Can it host inbound content too? How to deal with 2 way sync?
  • Outbound Channels: - some of these can be groups (like robmartinson) that flow to multiple destinations. You can mix and match, for example robmartinson (all robmartinson channels) and threads/themartinsonshop (only the martinson shop threads account). Inbound messages would be tagged with specific source locations
    • robmartinson - group, goes to threads, Facebook, other?
    • threads - goes to rob.martinson
    • martinson.shop - goes to website? Goes to insta/threads? (This is like a group tag)
    • instagram - goes to all accounts
      • instagram/themartinsonshop
      • instagram/rob.martinson
    • Facebook - goes to all accounts
    • X / Twitter
    • Youtube
• Inbound: If I post content somewhere else (fb, threads, whatever), that content is brought into the site and tagged according to source.
  • If an inbound content entry has relevant tags, should it be posted back to other outbound channels? In other words, if I post a tweet on robmartinson that has the #threads/robmartinson tag, should that be cross-posted to the threads account? I think maybe so. Interesting!
• Website:
  • fastapi, lambda, jinja, tailwind?
  • golang, html/template, bootstrap?
    • Can content be stored in static formats like markdown?
    • maintaining state: need to make sure we don’t push outbound multiple times. Each entry needs a hash and some backend to track whether it’s been processed or not
    • First, let’s just work on inbound micro blog posts
  • nav bar
    • Home
      • Last entries?
    • Feed
      • All entries
      • filter by tag or tags
        • has tag(s) and/or doesn’t have tag(s)
    • About?

Event Types / Connectors

• Google Docs (push from bear to google docs)
• Bear (push from bear to website, article, docs, whatever)
• Email
  • Link w Gmail or others, auto index and tag to, from, cc, subject this replaces copper
  • Receive a forwarded email via an inbox email address to add to timeline
• Photo
  • Link w iPhoto or google stream?
• Blog entry
  • Link w Wordpress or support micro blog format? This is covered by the Bear integration
• X/TWitter?
• Insta?
• Web event / log?
• Fb post?
• Audible events? What book(s) am I reading, etc.
• GPS Location / checkin
• Telegram?
• Ability to view any tag or combination of tags or all events in an interactive timeline format. This will be extremely useful to see the relationship between different events in time.
• Events can have an optional length in seconds. If an event has a length of zero it is just a marker to a point in time if it has a length longer than zero it lasted that long from inception to end
• Ability to print any timeline view in different formats. When printing, one view might be timeline with numbered events (1,2,3) and separately full event details printed per sheet at the end so to easily link event details with timeline. Also pretty print option to generate photos, etc
• Ability to manually create an event of any type
• Ability to link entries to other entries to create context
• Ability to follow a tag or set of tags
• Ability to make a tag or set of tags public or private. Explicit private overrides public when both on a same event
• Ability to edit tags later
• Ability to view tag/filter subscribers
• Ability to publish a tag/filter list to another website (as a blog or feed w rss)
• Useful for tech log, timeline of build (house, app, other), timeline of client interaction (case building, Ernesto) storytelling, blogging, writing a book, collecting research, traveling, journaling
  • Activity table
    • Id
    • Timestamp
    • Type - blog, url, Twitter, instagram, audible, podcast, sonos, YouTube publish, YouTube watch,
    • Tags - used to categorize feed w type
    • Content - JSON doc with all relevant data for entry
  • Publish as RSS?
  • Webhooks to receive data or initiate a request to get data when another system changes
  • Comment system? Signing as GitHub, google, x/twitter, insta, whatever
  • Ability to subscribe to a filter
  • Full REST endpoint to manage content
  • Urls:
    • /feed - all available here
    • /feed/{type} - all filtered by type
    • /feed/{type}/{slug} - specific type entry or friendly url
    • /feed/{guid} - specific entry
    • ?tags=[one,two,three] - filtered by tags, contains all

Subscriptions / Permissions

• Each type and tag can be public or private by default. If public, anyone can see or subscribe. If private, they must be approved or be invited.
• Once a consuming / following user finds a good set of filters, they can subscribe to that filter (rss?)

Integrations

• Bear
  • Search for blog tag and published tag and send to posting
  • Export to md and push
  • How to deal w images/assets? Push to s3
• Activity stream micro blog with manual posts or events from different services like audible, Sonos, Instagram, Facebook, Twitter, Reddit, word press, etc. etc.
• types
  • blog entry
    • id
    • date/time
    • status (published or not)
    • title
    • content
    • tags
  • url
    • id
    • timestamp
    • url - of original
    • content (cache all items from URL once posted)
• Add comments

[[The ultimate notes app and workflow]]