When we wanted to hire a few mid-levels at my company this is the exact thing the two non-technical managers fawned over to no end. You're absolutely right, it's every Muhammed, Ranjeet and Xanjuai that stuffs their GitHub profiles like tissues in a bra. You scratch the surface and it's all trash. Gatekeep, gatekeep, gatekeep.
Not exactly that, no, but there is also the jeetery of having 6 gorillion repos, all of which are forks and filling their calendar with commits to private repos.
Eh, I mean, I enjoy programming and I enjoy it as a hobby as well as a day job.
I like big backends and I cannot lie.
Not the way I expected this to end, tbh. I had assumed a lot bounties would dry up due to code review becoming trivial with LMMs, but it makes sense that they're getting jugaad'd to death. This is essentially taking all the existing problems in most bug bounty platforms and multiplying them by 100.
It's been a while since I've thought about this so my reasoning is going to be less than airtight, but let me try. Keep in mind that I speak from the perspective of someone who's interested in designing concurrent systems. Coroutines have other uses besides enabling concurrency -- see for example "generators", as in Python's.
Moderately off topic, but what’s the deal with microservices? I’ve heard people justify them by comparing them to the Unix shell and its utilities. However, when you use the shell to build a script, mostly you’re using utilities that you didn’t have to write, but in every project I’ve seen that uses microservices, they end up writing their own for each of the services. That’s kinda like writing your own shell just to write a single script.
The more common, legitimate use case is when you're working on a big corporate web app and you run into tasks that really deserve special attention because scaling will get messy. You can have a whole separate team handle it and only coordinate over a shared protocol, and not actually have to be balls deep in each other's code.
Oh dear lord that is an amazing find. I had no idea that even existed. And it's entirely an user-space construct? No syscalls needed to switch between execution contexts or to set them up?
It’s also removed from POSIX and neither glibc nor musl impliments it.
Yes, this, except from a slightly more insidious angle. Like in the corporate push for the object-oriented paradigm, the actual motivation behind divide-and-conquer microservice design is to arrive at a service backend which is composable and scalable by adding these paint-by-the-numbers lego blocks, which are at an idealized level of simplicity for enabling a cookie-cutter development process where you can just schedule N interchangeable developer hours to each as needed.
Still shows up in the glibc docs though, it's where I first heard about it
I will never stop being mad about this. They deprecated it with no fucking replacement whatsoever and said "just use threads lmao" as if that's the same thing. If I remember correctly, the only reason they deprecated ucontext.h is because of the type signature of makecontext(). They could have just fixed that instead.
Reminds me of my first programming job, where I was to rewrite a ~10 kloc VBA script (all in a single function) into C#. Not so fun* times lol, though still better than the development hell that followed...
So I'm still working on this.
enum Status {
unknown @0;
submitted @1;
pickedUp @2;
succeeded @3;
failed @4;
canceledPrePickup @5;
canceledPostPickup @6;
}(define (Job.Status->number value)
(case value
((unknown) 0)
((submitted) 1)
((pickedUp) 2)
((succeeded) 3)
((failed) 4)
((canceledPrePickup) 5)
((canceledPostPickup) 6)
(else (error "bad Job.Status value" value))))
(define (number->Job.Status value)
(case value
((0) 'unknown)
((1) 'submitted)
((2) 'pickedUp)
((3) 'succeeded)
((4) 'failed)
((5) 'canceledPrePickup)
((6) 'canceledPostPickup)
(else (error "bad numeric Job.Status value" value))))
(define +Job.Status-to-number-alist+
(list (cons 'unknown 0)
(cons 'submitted 1)
(cons 'pickedUp 2)
(cons 'succeeded 3)
(cons 'failed 4)
(cons 'canceledPrePickup 5)
(cons 'canceledPostPickup 6)))
(define +number-to-Job.Status-alist+
(list (cons 0 'unknown)
(cons 1 'submitted)
(cons 2 'pickedUp)
(cons 3 'succeeded)
(cons 4 'failed)
(cons 5 'canceledPrePickup)
(cons 6 'canceledPostPickup)))(define (capnp:generate-enum req enum-node)
(let ((type-sym (string->symbol
(capnp:node-trim-shared-prefix req enum-node))))
`(begin
(define (,(symbol-append type-sym '->number) value)
(case value
,@(map (lambda (enumerant)
`((,(string->symbol (capnp:enumerant-name enumerant)))
,(capnp:enumerant-code-order enumerant)))
(capnp:node-enumerants enum-node))
(else (error ,(format #f "bad ~s value" type-sym) value))))
(define (,(symbol-append 'number-> type-sym) value)
(case value
,@(map (lambda (enumerant)
`((,(capnp:enumerant-code-order enumerant))
',(string->symbol (capnp:enumerant-name enumerant))))
(capnp:node-enumerants enum-node))
(else (error ,(format #f "bad numeric ~s value" type-sym) value))))
(define ,(symbol-append '+ type-sym '-to-number-alist+)
(list
,@(map (lambda (enumerant)
`(cons
',(string->symbol (capnp:enumerant-name enumerant))
,(capnp:enumerant-code-order enumerant)))
(capnp:node-enumerants enum-node))))
(define ,(symbol-append '+number-to- type-sym '-alist+)
(list
,@(map (lambda (enumerant)
`(cons
,(capnp:enumerant-code-order enumerant)
',(string->symbol (capnp:enumerant-name enumerant))))
(capnp:node-enumerants enum-node)))))))`(a (list here) and 3 plus 3 is ,(+ 3 3)) evaluates to (a (list here) and 3 plus 3 is 6). The comma is "unquote" and it selectively evaluates the expression. The comma and the @ symbol in the enum code above is unquote-splice, which expects that the expression will return a list, and it expands the list inside the parent quasiquote.struct Job {
struct Metadata {
id @0 :UInt64;
status @1 :Status;
union {
processVideo :group {
inputKey @2 :Text;
}
archiveVideo :group {
id @3 :UInt64;
}
}
}
}pointer->value = whatever. But if you want to set a text field, that's complicated. I can probably support setting pointer values if the new replacement value is the same size or smaller than whatever was in the struct when you originally parsed it. But if I want my setters to support completely arbitrary replacement values, that'll get complicated if I want to balance efficiency and usability of the generated API.(defstruct wrapped-Job.Metadata blob byte-start byte-length resize?)
(define (blob->Job.Metadata blob #!key (byte-start 0) byte-length resize?)
(let ((byte-length (or byte-length (blob-length blob))))
(make-wrapped-Job.Metadata
#:blob
blob
#:byte-start
byte-start
#:byte-length
byte-length
#:resize?
resize?)))
(define (make-Job.Metadata)
(error "todo finish implementing make-Job.Metadata"))
(define (Job.Metadata-id obj)
(error "todo finish implementing Job.Metadata-id"))
(define (Job.Metadata-id-set! obj val)
(error "todo finish implementing Job.Metadata-id-set!"))
(define (Job.Metadata-status obj)
(error "todo finish implementing Job.Metadata-status"))
(define (Job.Metadata-status-set! obj val)
(error "todo finish implementing Job.Metadata-status-set!"))
(define (Job.Metadata-processVideo-inputKey obj)
(error "todo finish implementing Job.Metadata-processVideo-inputKey"))
(define (Job.Metadata-processVideo-inputKey-set! obj val)
(error "todo finish implementing Job.Metadata-processVideo-inputKey-set!"))
(define (Job.Metadata-archiveVideo-id obj)
(error "todo finish implementing Job.Metadata-archiveVideo-id"))
(define (Job.Metadata-archiveVideo-id-set! obj val)
(error "todo finish implementing Job.Metadata-archiveVideo-id-set!"))