ngalaiko

openapi is really meant to be either generated from code, or server-code is meant to be generated from openapi spec

especially combined with monorepo

amount of time people spend updating dependencies between internal services and libraries in a pursuit of semver for now reason is just absurd

> Tactile theme by Jason Long

and the format extension is .jsonl

[1]: https://en.wikipedia.org/wiki/Inflation_targeting

i was properly introduced only to oop, and grasped a little of fp here and there, especially learning go and javascript.

what i consider a 'click' for me is when i realised that all of these paradigms are interchangeable. like, an abstract method is just a function, or a function signature is the same as in interface with a single method.

after that i write code however it feels more appropriate for the situation i am in and don't think too much about fancy words and patterns. it really feels like programming languages are becoming 'native' for me.

> I've been painfully aware of spreading myself too thin trying to handle both feature development, CI/CD maintenance and DevOps-related tasks ensuring our cloud-based environments are deployed to and operate smoothly.

Reduce complexity.

This is false (and wrong). As a software engineer, you must understand and own what you do end-to-end, including:

* how to write your code

* software/hardware that your code relies on (databases, k8s, aws, whatever)

* protocols your software uses for communication

* 3rd party libraries that your software depends on

* how to build and deploy your software and environment for it (bare metal, clouds, mobile app stores - whatever necessary)

* setup testing + write tests for all of the above

* setup monitoring + monitor all of the above

at any company, at any scale.

one particular thing that tells that is the attitude to interfaces:

while in java (and most languages) interfaces are used to tell which contracts a class implements, in go it’s reversed. you must declare interfaces to _require_ certain contracts, for arguments in your functions

for example:

type interface Operator { Operate(int, int) int }

func IntOparation(a, b int, op Operator) int { return op.Operate(a, b) }

this is a major difference highlighting the ownership boundaries: * when I write a package and rely on a 3rd party contract, instead of referencing it and adhering to it, I will copy-paste parts that I need to my package and be independent

landing page doesn't have links, but the website contains some low quality blog posts that receive some traffic via google

it's a hugo website hosted on cloudflare pages. I've also made sure it looks ok without css and js

generics however are more available to an average gopher

i believe that such availability will eventually produce a go version of spring, or a typescript-like type system, or something even worse

introducing generics was a mistake. give it a couple of years and golang would be indistinguishable from java