michidk

Is there any reason you could not self-host it?

Why invent a new file format when there is https://jsonresume.org/? Its also quite easy to customize and add more things as it does not prohibit extra values

fk lese(&selbst, schlsl: Zeichenkette) -> Ergebnis<Möglichkeit<&Zeichenkette>, Zeichenkette> { wenn lass Etwas(wöbu) = gefährlich { WÖRTERBUCH.als_ref() } { Gut(wöbu.hole(&schlsl)) } anderenfalls { Fehler("Holt das Wörterbuch".hinein()) } }

https://github.com/michidk/rost

see https://stabl.com/

those devcontainer are no vscode devcontainers though. they use the vscode remote feature

Yes, exactly this! We are actually spending soo much time deriving, thinking, formulating & refining OKRs from roadmap items that we could just declare as simple "Goals". We could get so much shit done during that time.

Most of the time as the quarter goes on, we then scrap those OKRs anyway because we didn't manage to do them or they were too specific and requirements changed.

I always had the feeling that what we are doing is bullshit. So great to finally hear it from someone else.

I wonder how many engineering companies actually use OKRs though.

okay, I didn't know that, thanks for the background. I wonder why the assembler would not optimize this though.

I noticed that I then could also shave of one byte more by using lea esi, [rel msg] instead of lea rsi, [rel msg].

Such a great explanation. Wish I would have had something like this back in my gamedev days.

I think your statement might only apply to 32 bit (one of the constraints mentioned early in the blog post was 64 bit).

But even if it was 32 bit, then we would't have to copy a 1, since the syscall number for sys_write would be 4 instead of 1.

I get the same total size with both variants in 64 bit mode.

  push 1
  pop rax
  mov rdi, rax

seems to be same in size as

  push 1
  pop rax
  push 1
  pop rdi

should be ... push 1 ; syscall: sys_write pop rax push 1 pop rdi

of course

Of course - you are completely right, an oversight in wanting to correct my mistake as quickly as possible.

With that fixed, is there any reason not to use push here?

Yeah I thought sth like this is possible, but (correct me if I'm wrong) this (ab)uses the ELF header and punts data in there, which goes against my requirement

It should be a ‘proper‘ executable binary according to the spec

Hehe a nice idea. But then it would not always print Hello World and you cannot execute it directly.

I was able to shave off one additional byte with this:

  ...
  xor rax, rax       ; = 0
  inc rax            ; = 1 - syscall: sys_write
  mov rdi, rax       ; copy 1 - file descriptor: stdout
  lea rsi, [rel msg] ; pointer to message
  mov rdx, 14        ; message length
  syscall
  ...

  $ nasm -f bin -o elf elf.asm; wc -c elf; ./elf
  166 elf
  Hello, World!

However, using the stack-based instructions as xpasky hinted at:

  ...
  push 1             ; syscall: sys_write
  pop rax
  pop rdi       ; copy 1 - file descriptor: stdout
  lea rsi, [rel msg] ; pointer to message
  push 14            ; message length
  pop rdx
  syscall
  ...

Thanks, that makes total sense. I was so focused on the ELF part that I didn't even consider optimizing the initial assembly further. Will fix it and edit the article.

A short introduction to the IMAP protocol.

There are actually IDE plugins which perform 'semantic line wrapping'. But that is besides the point. Of course, it can make sense to add manual line wraps, especially if the developer intends to make his intentions clearer by using line breaks at specific points.

But lots of developers use formatting plugins to force line breaks anyways - and they are no better then the IDE linewrapping.

It would perfectly if you enable line wrapping, which is basically a dynamic client-side character line limit!

https://github.com/michidk/vscli

It allows me to launch vscode projects and devcontainers I often work on very quickly. Saves me so much time!

And I want it to be able to handle lots of connections. One server might not be enough, so it needs to scale. The process could also take a while, so I need a queue. Yeah I could setup, AWS API Gateway, SQS, ECS with Autoscaling etc. But that's a lot of boilerplate.

https://www.reuters.com/world/us/16-mile-bridge-baltimore-co...

I turned it on.

Devenv in WSL is the way to go

Clearly not now ... :')

I used Colemak for one year. Now since 5 years I am using Halmak. I used to use custom softaware, but nowadays I use a programmable keyboard (Ergodox EZ).

Code is of course powerful, but I’ve found the restrictive nature of Terraform’s HCL to be a benefit with reduced complexity.

No way. We used Terraform before and the code just got unreadable. Simple things like looping can get so complex. Abstraction via modules is really tedious and decreases visibility. CDKTF allowed us to reduce complexity drastically while keeping all the abstracted parts really visible. Best choice we ever made!

This issue is very interesting, thanks for linking it! Hopefully this will change in future...

True, I added some more!

Divi Theme with Wordpress is great. Allows for quick prototyping but is used for many production websites as well.

We have them know: https://github.com/michidk/vscli/releases/tag/v0.1.7 Just not integrated into homebrew, since then we could not automatically update our formula anymore :/