is_taken

As usually the schematics were available in the manual it was not too hard to add some additional static ram. There were unused address lines available which could be used for chip select.

a) Do these inode issues also happen with the supplied (v4) kernel? b) Do these inode issues also happen with a rebuilded kernel which uses the original lib1 and lib2?

I once had strange effects on V6 if lib1 and/or lib2 were rebuild by me.

Should be not hard to test.

Seems to redirect to some online casino?

Jetbrain's CLion with the pico sdk. Yeah, that means C.

If you want to use multiple technologies in a single project you should not run Goland, PhpStorm etc. but IntelliJ with plugins. Then you don't need to switch IDEs.

You could checkout void and alpine.

Maybe wrapfs.WithModTime(... should not use time.Now() but get the mod time of the running binary?

Try this:

  find / -name '*core*'

Are you sure the memory in this system is ok?

As it dumped core, could be interesting to "gdb it" and get a stackframe.

Maybe this already helps: https://github.com/tldr-pages/tldr

Have a look at the Teensy 4.1, it comes with 7936K Flash, 1024K RAM and you can even add up to 2x8Mb PSRAM iirc. Of course it's a bit more expensive but not much.

Thanks for this. Actually helpful. Just cleaned my mbp.

Feature request: create a maximized window with as little decorations as possible using a black background so we can clean the display too.

I use

  - Alfred
  - Cheatsheet
  - Bartender
  - 1Password
  - iTerm2
  - Moom (you could also check Rectangle)
  - Some IDEs from Jetbrains

A PDP11/40 emulator for the Teensy 4.1 development board.

https://github.com/gounselor/Teensy11

Other code quality issue encountered on a quick review:

  - use of utils package
  - use of models package
  - naming of receivers (too long)
  - returning empty structs instead of (nil) pointers
  - too much log.Fatal scattered around the code
  - unhandled errors, inconsistent error handling
    sometimes handled twice a la log.Printf(..., err) then    return err
    consider error wrapping here
  - useless use of err2 variables
  - use of Must functions which will panic if fail, transition to err producing fns
  - stuttering (digger.DiggerConfig)
  - naming things ...Impl instead of naming the interface ...er || ..or
    This is done correctly in tf.go, not so good in locking.go

For a complete review i would need more time.

And i would actually rename cmd/digger/main.go to cmd/digger/digger.go (_test.go too)

Why? If you go build cmd/digger/main.go you end up with main, if renamed you end up with digger. Without using additional -o flags.

Also consider https://goreleaser.com/intro/

I recommend run a linter against your codebase.

https://golangci-lint.run

https://github.com/go-critic/go-critic

https://github.com/mgechev/revive

Interesting, but i don't get the difference between str and stur. To me it looks basically the same. Can someone ELI5?

Stopped after reading that CopySlice example, seems the author is unaware of

https://pkg.go.dev/builtin#copy but yeah let's reinvent that wheel. And an option type too.

I have the keyboard settings to use F1, F2 as standard fn keys. If i really need the mac functions (not so often) i can press Fn+F1 etc.

Forgot to mention https://rectangleapp.com

I agree that iterm2 password manager is great (i use it too).

I just wanted to mention the sudo-fingerprint feature for the local machine in case someone did not know.

I you want to try Alfred anyway, it has this multi clipboard functionality included.

On Macs with touch id, you can enable sudo via fingerprint reader for the local machine.

https://apple.stackexchange.com/questions/259093/can-touch-i...

One could consider using https://github.com/caarlos0/env instead of the hand-woven env var handling.

Have a look at https://github.com/caarlos0/env

Why not writing a small wrapper around time.Parse?

  func ParsedTimeOrNil(s string) *time.Time { 
   t1, err := time.Parse(time.RFC3339, s)
   if err != nil {
    return nil
   }
   return &t1  
  }

Would be interesting to see the performance difference if you undo that move-&-change and change the function signature from:

  func (r Ruleset) Match(path string) (*Rule, error)

to:

  func (r *Ruleset) Match(path string) (*Rule, error)

Release Notes: https://go.dev/doc/devel/release#go1.19.minor