Isn’t it delightful when you come in to a large project to discover that they have a large underlying core that no one wants to touch but everyone relies on.

Quickly perusing the code you realize that the base was clearly created by someone who found their first tutorials for Java, but were previously a c developer.

It’s funny cause this code is of course from ~20 years ago and in different sections you can tell they were a C developer, a business admin, a Db admin, a junior conforming to pressures from others.

I recently looked at the deep rooted abuses of Java beans, and this entire internally created state management engine that serves no purpose but to create contrived complexity.

The use of propriety tools, that they paid lots for that perform incredibly simple tasks that have long since been solved by the open source community. Many of which are long defunct.

And the constant focus is on monkey patching the engine to solve small issues, which bloat the time to deal with issues. Since everything needs to be tested by their methodologies.

The inability to understand that the underlying structure is the issue and that tackling that, rather than just shifting the entire solution to new languages will suddenly solve the problems(or other underlying systems).

It’s just sad.

Because of cache split brain issue I have to invalidate cache every 5min. I've said to lead dev about this hack and we both agree to solve it asap.

This was 3 months ago...

Temporary fix becomes production solution. And it only took me 10min to add cron entry to every prod srv.

So productive!

Btw you should see users faces when page referesh changes page completely because of load balancing xD)

(I'm not completely sure of what I'm saying here, so don't take this too seriously)

Settling on a language to write the api for ranterix is hard.

I'm finding a lot of things about elixir to be insanely good for a stable api.

But I'm having a lot of gripes with the most important elixir web framework, phoenix.

Take a look at this piece of code from the phoenix docs:

defmodule Hello.Repo.Migrations.CreateUsers do
use Ecto.Migration
def change do
create table(:users) do
add :name, :string
add :email, :string add :bio, :string
add :number_of_pets, :integer
timestamps()
end
end
end

Jesus christ, I hate this shit.

Wtf are create, add and timestamps. Add is somehow valid inside the create, how the fuck is that considered good code? What happens if you call timestamps twice? It's all obscure "trust me, it works" code.

It appears to be written by a child.

js may have a million problems. But one thing I like about CJS (require) or ESM (import) is that there's nothing unexplained. You know where the fuck most things come from.

You default export an eatShit() function on one file and import it from another, and what do you get?
The goddamn actual eatShit function.

require is a function the same way toString is a function and it returns whatever the fuck you had exported in the target file.

Meanwhile some dynamic langs are like "oh, I'll just export only some lang construct that i expect you to specify and put that shit in fucking global of the importing file".

Js is about the fucking freedom. It won't decide for you what things will files export, you can export whatever the fuck you want, strings, functions, classes, objects or even nothing at all, thanks to module.exports object or export statement.

And in js, you can spy on anything external, for example with (...args) => debugger; fnToSpyOn(...args)

You can spoof console.log this way to see what the fuck is calling it (note: monkey patching for debugging = GOOD, for actual programming = DOGSHIT)

To be fair though, that is possible because of being a dynamic lang and elixir is kind of a hybrid typed lang, fair enough.

But here's where i drop the shit.

Phoenix takes it one step further by following the braindead ruby style of code and pretty DSLs.

I fucking hate DSLs, I fucking hate abstraction addiction.

Get this, we're not writing fucking poetry here. We're writing programs for machines for them to execute.

Machines are not humans with emotions or creativity, nor feel.

We need some level of abstraction to save time understanding source code, sure.

But there has to be a balance. Languages can be ergonomic for humans, but they also need to be ergonomic for algorithms and machines.

Some of the people that write "beautiful" "zen" code are the folks that think that everyone who doesn't push the pretty code agenda is a code elitist that doesn't want "normal" people to get into programming.

Programming is hard, man, there's no fucking way around it.

Sometimes operating system or even hardware details bleed into code.

DSLs are one easy way to make code really really easy to understand, but also make it really fucking hard to debug or to lose "programming meaning".

I created pull requests for some open source js projects to fix issues with monkey patching Object.Prototype, as I used it heavily in a current project. All of them were accepted and merged.

A couple of weeks later I realised how retarded that was and refactored all monkey patching to separate modules.

Love all lambda functions from c#, oh and extension methods. They make life way easier in c#.

From PHP: file_get_contents/file_put_contents. It does a simple job but allows many-many sources and protocols (like HTTP) to be used as sources.

Other than that - monkey patching in Ruby, wish every language had that, because there are a lot of closed-for-extension scripts out there, and when you need to override a specific thing in the code you cant.

If I got a dollar for every minute I was trying to work around vague library errors...

How many of you prefer monkey patching vs minor release??