mozey

Yeah, I used Bootstrap for a long time, and got used to how it works.

I wanted to like Tailwind, but it seems a bit disingenuous. It's like using inline style tags, just with shorter names.

From time to time I've made an effort to learn how CSS works, but after a while I forget the details. It's more productive if I can browse a catalogue of visual examples, with concise markup that is easy to copy and paste.

Bulma seems like the more "modern" take on Bootstrap: https://bulma.io/

> I tend to use the 'questioning level of thoughtfulness' (QLOT) of my discussion partner as the signal

That's easier to do if participants have aligned interests and desires. Harder when communicating with someone that is very different from yourself. In that case it's productive if the discussion is approached with patience as a learning experience. Without suspicions that the other person is only learning about you so their tribe can use it against you later.

> philosophers never change their minds: they occasionally do. But not as a result of arguing! It's usually more self-correction than other-correction

So, as a rational philosopher you're not trying to express an absolute truth that is generally applicable. Rather, you're iterating towards the most accurate and appropriate expression of yourself. Hmm, I think I've heard that philosophy before... existentialism?

"People mistakenly see optimism as an excuse for inaction. They think that it’s pessimism that drives change, and optimism that keeps us where we are. The opposite is true. Optimists are the ones that move us forward"

Exactly, it's not binary. Some pessimism is healthy, "the ones that speak truth to power". However, complaining without offering solutions is pointless. Good on you for following up, and trying to be optimistic about some of your solutions.

Few people attempt this... Here is one: Ladybird https://awesomekling.github.io/Ladybird-a-new-cross-platform...

Requires tight coupling and dependency injection

Congrats on getting this far, your time tracking tool looks slick and marketable! I also like keeping text with tasks and time-tacking. My approach is to use a vim plugin and markdown files. Keyboard shortcuts let me start a timer, and calculate totals. There is also two scripts to export to JSON or CSV, I then use those to generate invoices. The result looks like this https://github.com/mozey/vim-timetracker#example My plan with using markdown files was to have some kind of UI to display the time sheets, but I never got that far.

The "cross platform" part, which is maybe less of an issue these days?

> they're intentionally making me wait for their convenience

Lol, it's definitely possible to do this with text too "typing..."

Because it's not so easy to setup and manage? Maybe it will become more popular with tools like https://github.com/gravitational/teleport

Highly recommend the "Alternative finger positioning" as mentioned here: https://typingsoft.com/typing.htm. It works with any qwerty keyboard! Simple solution, don't bend you wrists, change your home position and keep them straight.

For an app that displays positive or negative, wouldn't it be cheaper/easier to use image processing to detect lines on the test?

Years ago I wrote some VBA that exports all the VBA in an Excel file. I ran this script manually from time to time so I could add my code to version control. Excel should make it easier to separate the code from the data. For the former you probably want the entire commit history, for the latter you usually only want the current state.

"Debugging is twice as hard as writing the code in the first place. Therefore, if you write the code as cleverly as possible, you are, by definition, not smart enough to debug it."

Funny, couple of years ago I thought someone should create something for JSON similar to what [XSLT](https://en.wikipedia.org/wiki/XSLT) is for XML. See example here https://www.w3schools.com/xml/xsl_intro.asp

Then I found out about jq because awscli was using it in example docs.

I guess `htmlq` makes sense if it has the exact same syntax as `jq`, and the user is already familiar with the latter?

> Shipping a Python application is an exercise in itself

This, good cross platform support and single file executables. I use https://www.py2exe.org, and it works great once you've figured out how to set it up. However, doing the same thing in go is simply `GOOS=windows GOARCH=amd64 go build ./cmd/...`

Doing it the other way around makes more sense, i.e. write SQL to generate code. See https://github.com/kyleconroy/sqlc, why aren't more people following this approach?

> At boundaries between our code and calls out to external packages, make an effort to always wrap the result with xerrors.Errorf. This ensures that we always capture a stack trace at the most proximate location of an error being generated as possible

I've been doing something similar for a while, using `errors.WithStack` from https://github.com/pkg/errors

The error can then be logged with https://github.com/rs/zerolog like this `log.Error().Stack().Err(err).Msg("")`

For human readable output (instead of the standard JSON) use a console writer, see https://github.com/mozey/logutil

Maybe, but I regularly go two days on battery now. That's something I've never experienced with a laptop before. Notwithstanding inefficient software

I was using the ARM version, by slow I mean I can see the splash screen for a couple of seconds. Whereas VSCode starts up instantly. I've got `alias c='code .'`, typically I open the editor from iTerm2 the same way I would use vi. IntelliJ is still more advanced in many ways. I guess the point I was trying to make is that Electron looks like a better platform for cross platform apps compared to JVM.

Also, many NeoVim plugins are using component from VSCode, and the other way around.

Recently switched to VSCode from Jetbrains IDEs on MacBook Air M1, amazed at how much faster my editor boots up, and generally also more responsive. Haven't noticed any memory issues either, I only have 8GB RAM

> And ORMs have the advantage of abstracting this SQL away for you allowing that you to work across databases if you need to

In theory, in practise my experience is the oppose. It's easier to understand and tweak the SQL to work across DBs. You can easily diff and compare the SQL files. The ORM is another moving part, it adds convenience for simple queries, and complexity for anything advanced or non-standard.

Lambda because pricing, I don't have to pay the per hour fee if the service is not used every hour/day/etc. By using apex/gateway I can easily move the code to ECS if that becomes the better option.

I've been using the same IDE for the last 10 years because that is what my colleagues use. Over the last decade the UI has changed significantly. Not only that, the keyboard shortcuts also change, and often don't work the same across different IDEs in the suite. For example, the shortcut to vertically select a column of text has changed at least twice. I like Jetbrains, but considering switching to something simpler that changes less often. Might miss out on some advanced features, but I don't use those often, and maybe I don't need it anyway

I write Lambda functions in golang. In dev I run the function as local http server. In prod I map a custom domain to the lambda, routing is done internally to the function. API Gateway is only used for the top level route. This workflow is enabled by https://github.com/apex/gateway

In principle I try to avoid Amazon Web Services that lock me into the platform. So, for my dev stack I run a few other containers to give me the equivalent of the prod environment, RDS (MySQL or PostgreSQL), ES (OpenDistro), S3 (Minio), and SES https://github.com/mozey/aws-local

Dev is easy because I can test everything locally, and the resulting code should be portable to any other cloud.

Obviously this approach might not be feasible if you choose to use AWS that do not have equivalent self-hosted options.

One thing that really annoys me about the GUI mindset is that developers think it's ok to just change stuff. With CLIs they expect people are using it for automation so changes are done with care. Often when I update my GUI I have to look for info in different places, click somewhere new, or learn new shortcuts. That sucks

> dependencies between containers

This is the part I don't understand. I use Docker as a light weight alternative to say VMWare or Virtual Box, just Dockerfiles work well for this use case. The point is to not have dependencies

Docker is not for production (most of the time), it's a dev tool.

Ignore docker compose (and swarm and whatever else), because you don't need it. The basic Dockerfile format is simple, it reads like a bash script without logic, basically it's a list of dependencies. Then you need to understand the difference between images and containers, and you're good to go.

If you're lucky enough to be developing on Linux, then docker is just a name for a bunch of stuff that's mostly already built into the OS.

Oh wow, never thought of that before. Now I'm feeling a little creeped out. Kind of makes me think of the difference between disk and RAM when rebooting a computer

If it's only this that is shared, "whether you communicate with a business by phone, email, or WhatsApp, it can see what you’re saying and may use that information for its own marketing purposes, which may include advertising on Facebook. To make sure you’re informed, we clearly label conversations with businesses that are choosing to use hosting services from Facebook", then it makes sense.