#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 #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