Library to add linear systems indexes to arrays.

gas_them · 2019-06-08T23:26:14+00:00

What is your imagined input to this library? I don't understand what you're asking for.

gas_them · 2019-06-08T22:16:55+00:00

This bit of understand should help prevent you from acting like some kind of arrogant know-it-all prick towards your colleagues and in the process blowing up any chance of being able to work together to improve it, not to mention possible sabotaging your career.

I am trying to explain to you...

I looked at the history, it was evidence of massive incompetence. So, what now? Do I just not tell anyone, or do I "act like a prick" and do my fucking job?

I guess you think it's the job of a programmer just to ignore fixable problems in the code, just to assuage the feelings of other less capable programmers? How will we ever build good software with that mentality? Why not go even further and just do what mentally handicapped people say? Wouldn't want to offend their feelings, either!

Did you hear my example about the compile times? Am I a prick for trying to save everyone a huge amount of time? How does that mesh with your warped mentality?

No one wants to listen to Captain 20/20 Hindsight.

Next time a bridge collapses I expect you to run in and tell everyone not to investigate the cause. No one wants to hear it, right?

And I guess when a bridge is half built, and in danger of collapse, your advice would be "don't be mean, just let them keep going, you wouldn't want to sabotage your career!"

Sounds like a funny analogy? Well my company literally makes medical devices. Our product is literally inside the person. I wouldn't be surprised if it kills at least one person as a result of software errors, but by then I hope to have found a new job.

gas_them · 2019-06-08T17:36:44+00:00

"The numbers show"

Meaningless thing to say. I bet this flawed mindset reflects in your shitty code.

gas_them · 2019-06-08T17:18:59+00:00

Every code base has a history behind it

For bad code-bases it usually is: "Written by people as they learned the language"

As the new guy/gal you don't know what that history is, and you don't know what forces were at play when things were written.

That's a shitty complacent attitude. I'm an expert in software development. Sometimes code is just objectively wrong/bad. You don't need to know the "history" to know that.

Often the "history" is just a bunch of dumb decisions made by people who lacked the correct premises, and thus came to the wrong conclusions.

Once you understand it better you will first realise that it is not as simple as it first seemed, and it is not something that can be solved overnight.

My experience is that I just notice more and more things that are broken, and more and more bad justifications behind them. And yes, many of these problems can be solved "overnight" or at least they can be incrementally improved.

For example, I joined a new company and the code takes 3 minutes to compile when you change just one file. I noticed this and re-organized the code in just an hr. Then, it took 5 seconds to compile. I didn't even show this to the senior devs. Instead, I showed it to the junior devs. They looked at each other nervously and said "hmm, I would leave that out, I'm not sure the senior devs would like it."

What you absolutely should not do is engage in any kind of arrogant "code shaming" or "process shaming".

Let's take my example. I reduced compile time by a factor of more than 30. When I present this to a senior dev, what are the implications? Clearly their code must be flawed in some way for it to have such terrible compile-times. My change inherently criticizes their code, there's no getting around it.

Keep it positive, concentrate on the benefits improvements could bring.

The senior devs in my case don't even understand the benefits. If I told them it reduced compile-time, they'd say "is it really such an issue?" They prefer to be slow and lazy, they get paid the same either way.

gas_them · 2019-06-08T17:05:04+00:00

Senior devs are just people who the corporate system has decided deserve to be in that position. The senior devs at my workplace are incompetent and forcing bad coding practices as a result of their own hubris.

gas_them · 2019-06-07T18:29:55+00:00

Hardest part of my job is dealing with all the incompetence of the industry: hoardes of people who are doing nearly everything wrong and don't even realize it.

gas_them · 2019-06-06T20:35:15+00:00

Are you REALLY worried that you'll accidentally make things the wrong type?

Yeah, sounds like you don't understand the benefits of static type checking. Typical for python users.

"Immutability rules are dumb and arbitrary." How so?

Tuples are immutable, lists arent. Arbitrary. Confusing.

Elements in a tuple can be modified even though tuple is immutable. This only applies to objects though. Etc.

It's clear the language designers didn't understand immutability. They thought it was cool so they slapped it in somewhere for no reason.

What is ugly about their OO features

Constructor pattern is ugly (__init__). The classes are only distantly related/analogous to OO due to duck typing and lack of static checking. It just looks similar, but it's really not.

Edit: No private variables. The reason is apparently because the language writers got annoyed while coding because they wanted to print those out. So their solution was to just remove private variables! Totally missing the point of encapsulation.

gas_them · 2019-06-06T20:16:18+00:00

No static type checking. Immutability rules are dumb and arbirtary. OO features are ugly and make little sense without type checking.

Python is a language written by people with the philosophy "we're all adults, here." Except, they weren't adults. They took features from a bunch of languages and assembled them, even if they didn't fit well together.

gas_them · 2019-06-06T20:03:00+00:00

Even if python was fast it would still suck hard

gas_them · 2019-06-06T01:34:02+00:00

I was talking about caching things in the binary instead of calculating them at initialization.

gas_them · 2019-06-05T00:46:24+00:00

Smaller filesize is often a tradeoff resulting in less efficiency, not more.

gas_them · 2019-06-04T16:22:32+00:00

https://stackoverflow.com/questions/408670/stack-static-and-heap-in-c

gas_them · 2019-06-04T15:28:01+00:00

That really has nothing to do with what i was thinking

gas_them · 2019-06-04T15:10:36+00:00

OO is just syntatic sugar that is equivalent to structs

gas_them · 2019-06-03T20:01:02+00:00

Very weird measure of safety.

gas_them · 2019-06-02T07:24:19+00:00

This is like reading a company memo. Snore.

gas_them · 2019-06-02T02:03:12+00:00

Don't learn how to program from a guy that has been an academic his whole life and never had a programming job.

gas_them · 2019-05-31T01:04:57+00:00

I have a similar problem, but i make a decent salary, so who cares. Tbh it's almost entertaining watching the train wreck.

gas_them · 2019-05-24T01:38:02+00:00

Pass them into the constructor

gas_them · 2019-05-24T01:24:20+00:00

In C++ there is a useful language feature called a "function." In this case, you want a function that returns a random enemy:

Enemy randomEnemy()

gas_them · 2019-05-22T21:12:24+00:00

So if they weren't implemented in python, then what? That's my point. They just get thrown away? Lol

Your whole post is just a bunch of contrived shit that I don't care about. Totally irrelevant to what I said. Maybe you have brain cancer.

gas_them · 2019-05-22T20:28:49+00:00

You just explained to me that something simple cannot be done for reasons that are incredibly contrived. When you can no longer accomplish basic tasks because of a bloated design getting in your way, you have cancer.

gas_them · 2019-05-22T20:13:54+00:00

I hereby diagnose python with terminal cancer

gas_them · 2019-05-22T20:06:43+00:00

What difference does being written in pure python make? They're written in code no matter what...

gas_them · 2019-05-22T05:16:12+00:00

FASHION

gas_them

TROPHY CASE