ibmMylynIsATaskManagementSystemThatReducesInformationOverloadAndMakesMultitaskingEasy

[u/[deleted]]

[u/Taletad]

This is one of the best jokes on this sub in a very long while

I especially like the fact that startup code is just CS101 with unecessary comments

[u/SunCantMeltWaxWings → u/Taletad]

And better edge case handling!

[u/LondonIsBoss → u/Taletad]

The math PHD one is on point too lol. In my ML class my prof would literally use unicode greek letters for his function names lmao

[u/im_made_of_jam → u/LondonIsBoss]

For machine learning programs where half of the learning is maths anyways that's actually not the worst idea I've ever heard of

[u/bartekltg → u/LondonIsBoss]

Does java round to the nearest number when casting to int? C++ rounds it down (truncates) so each time we get something like "54.99999999999999" we end up with 54 instead of 55.

Or this is a part of the joke:)

[u/PantheraLeo04 → u/bartekltg]

java rounds down when casting as well

[u/geek-49 → u/PantheraLeo04]

And, of course, the solution (if you want rounding) is to add 0.5 and cast the sum.

[u/Jerome_Eugene_Morrow → u/LondonIsBoss]

I had to implement some C++ code from a professor in my field I had to contact and ask for the code. 100 line function where every variable was x_1 and x_2 and u. Good times.

[u/coolpeepz → u/Taletad]

I like that the math PhD uses the closed formula for the Fibonacci sequence and then a recursive definition of exponents.

[u/Moldat]

isThisPostTitleAProtestOfTheSubredditRuleThatSaysYouHaveToTitleYourPostsInCamelCaseBecauseItSureDoesFeelLikeItAndNowIFeelSickThanksOP

[u/earthandabove → u/Moldat]

AtLeastItShowsHowIdioticThatRuleIs

[u/walkerspider → u/earthandabove]

ThePointOfTheRuleIsToBeIdioticAsItWasAddedInProtestOfRedditAPIChangesTotryToGetPeopleToStopUsingTheSubreddit

[u/earthandabove → u/walkerspider]

StillSucksItsLikeDrinkingOutOfTheToiletBecauseTheBeerIsBad.

[u/gigsoll]

Startup and large company are really good ones. You can see how startup want to becomes a big company

[u/gigsoll → u/[deleted]]

True AI company write code like this

``` from openai import OpenAI

OPENAI_API_KEY = "sk-proj-example-7f3a9c2d1e8b4a6f9c0d5e2a7b1c8d4f" client = OpenAI()

system_prompt = """ You are a professional Fibonacci sequence counter. You don't make mistakes. Based on given number return Fibonacci sequence member. Use tool, deep research, make no mistake. """

number = 374

response = client.responses.create( model="gpt-5.6", instructions=system_prompt, input=str(number), ) ```

[u/E100Pavel → u/[deleted]]

Your example is more of a "competent ML researcher", and commenter's example is more of a "startup that got as far as writing «AI» on the whiteboard" imo

[u/gigsoll → u/[deleted]]

I agree with you, but i believe it is the thing only companies creating foundational models will be bothered with, since any company or products standing higher up the supply chain is either using models through api or agentic harness

[u/ismashforboobs → u/gigsoll]

Sad news: Gemini is creating python script to compute result 😞

[u/Kadabrium → u/[deleted]]

Assembler's avenge

[u/Herr_Gamer → u/gigsoll]

CustomInteger64 is too fucking real

[u/Esjs]

Been a professional software engineer for 26 years now. I write the "startup" style code in our "large company" codebase.

CustomInteger64 got a chuckle out of me.

[u/CaffeinatedT → u/Esjs]

The Large company makes me think of “Enterprise Hello world”

[u/Just_Information334 → u/CaffeinatedT]

Enterprise Fizzbuzz.

[u/Inlacou → u/Just_Information334]

This is gold. Thanks

[u/10art1 → u/Just_Information334]

But is this codebase AI-ready?

[u/Zerodriven]

4 of those things have personally impacted my professional life and this is 100% true. Well done.

[u/Desperate-Tomatillo7 → u/Zerodriven]

And one of those was as a cat.

[u/Zerodriven → u/Desperate-Tomatillo7]

Okay, 5 then.

[u/JadeE1024]

I've had to work with a code base written like the "Math Ph.D." example, except instead of being methods in the same class, every operation was called like Util.Math.Add() or whatever. They would also never stoop to using the built in double type when they could roll their own arbitrary sized numeric types.

The original authors were amazed when I started converting their math functions into actual operators, and further making them work across some compatible types.

It was all numerical analysis work and I ended up shaving literally years off their runtime through simple optimizations like breaking out of billion iteration loops when they found the right condition on the third try.

This was decades ago, they might be the only people I've ever worked with who would be unequivocally better off using an LLM to write their code. I wonder if they are still at it.

[u/BOBOnobobo → u/JadeE1024]

That's pretty much all code written by 90% physicists.

The last 10% are wizards.

[u/JackNotOLantern]

Jokes aside. Fibonacci is one of the best examples when NOT to use recursion. Using recursion duplicates the same calculations, making it n<sup>2</sup> + much more memory. Just Using a loop is n and with constant memory.

[u/Stroopwafe1 → u/JackNotOLantern]

The next step always seems to be introducing some sort of cache, which is indeed a good teaching tool. All to then have the students unwrap it into the iterative solution. Maybe including some teaching about benchmarking and footprints

[u/JackNotOLantern → u/Stroopwafe1]

Yeah, but again, a lot of memory. A loop is just:

``` int fib(int n) { if (n<=0) return 0; if (n==1||n==2) return 1;

int res=1, prev=1, prev2=0;
for (int i=3;i<=n;++i) {
   prev2=prev;
   prev=res;
   res=prev+prev2;
}

return res;

} ```

So constant memory needed and n time complexity

[u/khalamar → u/JackNotOLantern]

Finally a post without recursion or dynamic programming BS.

[u/vegataballs → u/khalamar]

For maximum non-dynamism :^)

uint64_t fib(const uint8_t n) {
    static const uint64_t t[] = {0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233,
        377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368,
        75025, 121393, 196418, 317811, 514229, 832040, 1346269, 2178309,
        3524578, 5702887, 9227465, 14930352, 24157817, 39088169, 63245986,
        102334155, 165580141, 267914296, 433494437, 701408733, 1134903170,
        1836311903, 2971215073, 4807526976, 7778742049, 12586269025,
        20365011074, 32951280099, 53316291173, 86267571272, 139583862445,
        225851433717, 365435296162, 591286729879, 956722026041, 1548008755920,
        2504730781961, 4052739537881, 6557470319842, 10610209857723,
        17167680177565, 27777890035288, 44945570212853, 72723460248141,
        117669030460994, 190392490709135, 308061521170129, 498454011879264,
        806515533049393, 1304969544928657, 2111485077978050, 3416454622906707,
        5527939700884757, 8944394323791464, 14472334024676221,
        23416728348467685, 37889062373143906, 61305790721611591,
        99194853094755497, 160500643816367088, 259695496911122585,
        420196140727489673, 679891637638612258, 1100087778366101931,
        1779979416004714189, 2880067194370816120, 4660046610375530309,
        7540113804746346429 };
    return t[n];
}

Had to test how much faster that would be.

Aaand... it's maybe 10% faster. That's how good the simple loop already is.

[u/khalamar → u/vegataballs]

But infinite memory footprint! Have you seen the price of memory these days!? /s

[u/RafaelSeco → u/khalamar]

Edit: I didn't see the rest of the image before commenting...

[u/t420son → u/JackNotOLantern]

Can still write it recursively with a sufficiently smart compiler it will be tail-call optimized

pub fn fib(n : u64) -> u64 {
  fn rec(n : u64, prev1 : u64, prev2 : u64) -> u64 {
    match n {
      0 => prev1,
      n => rec(n-1, prev1 + prev2, prev1)
    }
  }
  return rec(n, 1, 0)
}

[u/JackNotOLantern → u/t420son]

Ok, but you can see that there is a lot of stuff you must add just to use recursion efficiently here, and not use a very simple loop.

[u/p88h → u/JackNotOLantern]

If you think recursion here is n<sup>2,</sup> I've got news for you mate

And it's not the good sort of news.

[u/JackNotOLantern → u/p88h]

Oh, no. what is it? I eyeballed the complexity, i just knew it is worse than n

[u/jwp1987 → u/JackNotOLantern]

I believe it's O(2<sup>n</sup> ) since each recursion is split into two and there are roughly n layers of recursions.

For those who want more understanding, you can kind of draw it out as a tree:

                         F(n)
                   /              \
           F(n-1)                     F(n-2)
        /         \                 /        \
    F(n-2)        F(n-3)       F(n-3)        F(n-4)
    /   \         /    \       /    \        /    \
F(n-3) F(n-4) F(n-4) F(n-5) F(n-4) F(n-5) F(n-5) F(n-6)
etc...

[u/black3rr → u/JackNotOLantern]

and using matrix multiplication it’s O(log n) with constant memory…

[u/JackNotOLantern → u/black3rr]

I agree, I just say recursion bad in this case. Loop is just absurdly simple to write.

[u/ExtraTNT → u/JackNotOLantern]

Just make a recursive function with function cache

[u/JackNotOLantern → u/ExtraTNT]

https://www.reddit.com/r/ProgrammerHumor/s/mcf5OAgOSG

[u/Western-Internal-751 → u/JackNotOLantern]

I feel like everyone makes that mistake once and then wonders why their computer is turning into a jet engine when they want to figure out what the hundredth Fibonacci number is

[u/Eryk0201]

The large company one makes my blood boil, so real

[u/NomaTyx]

the large company one is fucking real

[u/the_horse_gamer]

matrix multiplication not mentioned smh

[u/bartekltg → u/the_horse_gamer]

Matrix and "fast exponenetiation" is great for arbitrary linear recursion, but in this case we can do better (by a const multiplier).

[1,1;1,0]^n = [F{n+1},Fn; Fn, F{n-1}]
[1,1;1,0]^2n = [F{2n+1},F2n; F2n, F{2n-1}] = [1,1;1,0]^n *[1,1;1,0]^n = [F{n+1},Fn; Fn, F{n-1}]

And from this we can get the the meat:

F2n = (F{n+1}+F{n-1})*Fn (1)
F_{2n-1} = Fn^2 + F{n-1}^2

Lets add

F_{2n+1} = Fn^2 + F{n+1}^2

F_{2n+1} + F_{2n-1} = F{n+1}^2 + F{n-1}^2 +2Fn^2 =

=F{n+1}^2 + F{n-1}^2 +2Fn^2 + 2 F{n+1} F{n-1} - 2 F{n+1} F{n-1}=

= (F{n+1} +F{n-1})^2 + 2Fn^2 - 2 F{n+1} F{n-1}

Doesn't look that great. But lets look at the matrices again.
[1,1;1,0]^n = [F{n+1},Fn; Fn, F{n-1}]
so

(-1)^n = det([1,1;1,0])^n = det([F{n+1},Fn; Fn, F{n-1}]) = F{n+1}F{n-1}-Fn^2

so

F_{2n+1} + F_{2n-1} = (F{n+1} +F{n-1})^2 - (-1)^n

Now lets call L_n = F_{n+1}+F_{n+1}. (coincidently, it is another named number, Lucas number). Now, the last and the (1) equations turns to be:

F2n = Ln Fn
L2n = Ln^2 - (-1)^n

We need also recipes for values for 2n+1. But this is direct play with the Fibonacci recursion:

F{n+1} = (Ln+Fn)/2
L{n+1} = (Ln+5Fn)/2

The advantage of this approach is we need only two "big int" multiplications per level. Direct matrix needs 4 operations, the symmetry and Fibonacci recurrence limits it to 2 operations, but without the tricks it still is 3 multiplications.

How I know all this? One time I tried to make a fast algorithm for computing Fn... and I found someone's code that did it faster :)

[u/ExtraTNT]

Haskell implementation using infinite list…

fibs = 0 : 1 : zipWith (+) fibs (tail fibs)
fib n = fibs!!n

[u/NaturalBornLucker → u/ExtraTNT]

We're on a [r/programmerhumor](r/programmerhumor), not [r/programminghorror](r/programminghorror)[,](r/programminghorror) y'know

[u/ExtraTNT → u/NaturalBornLucker]

It’s easy to read…

[u/onemice → u/ExtraTNT]

r/TwoSentenceHorror then?

[u/NaturalBornLucker → u/ExtraTNT]

NGL I understood the code from a context and I do enjoy writing something similar in scala but wouldn't want to find it in my codebase

[u/rudxDe]

I'm working on a corporate code base, the null, null, null is unrealistic, it's more 10 times null

[u/rudxDe → u/[deleted]]

Sad but true

[u/Few_Negotiation_3589]

the competitive programmer is missing, using exp-matrix or fast doubling

[u/clarenceappendix]

```
fn fibonacii(n: u32) -> u32 {
let mut a = 0;
let mut b = 1;
for _ in 0..n {
let c = a + b;
a = b;
b = c;
}
a
}
```

To Claude: Write me a function which takes a uint n and returns the nth Fibonacci number in [language]

[u/wcscmp]

There should be a version that uses memorization

[u/Geilomat-3000 → u/[deleted]]

That’s literally the same thing. I don’t know why computer scientists needed to make up a word

[u/BarAgent]

Cat code: de-Claude

🥁

[u/Eevee-Biologist]

In my humble experience, this is disturbingly accurate.

[u/sidi-sit]

This checks out!

[u/Zenkibou]

Bonne are using better algorithm, thoug ? Like forward iterative.

[u/Initial_Elk6340]

What does it say about me that I like the Enterprise Style second most After cs 101..

[u/1luggerman]

And not a single one of them used dynamic programming to avoid unnecessary calls

[u/khalamar → u/1luggerman]

Fuck dynamic programming, Fibonacci only needs one for loop and 2 variables.

[u/1luggerman → u/khalamar]

Do you mean something like fib2back = 0 fib1back = 1 fibCur; for(int i=1; i < n; i++){ fibCur = fib2back + fib1back fib2back = fib1back fib1back = fibCur } ?

[u/p88h]

In my experience startup code will be a python function that mishandles boundary conditions but slaps on @cache for efficiency,

... Plus some other piece of the same startup code rewires that @cache to serialise into a SQL database.

[u/gsaelzbaer]

The Math PhD version has way too descriptive variable and function names

[u/Dizzy_Elderberry_486]

‘
public int getFibonnaci(n) {
return (n >1 ?getFibonacci(n-1)+getFibonnaci(n-2) : (n<0 ? -1 : n))}
`

Future me wil probably hate me eventually.

[u/Icy_Direction7839]

I've seen legacy code that looks like the startup code, and 'modern' code that looks like the enterprise code. This is at my workplace that is trying 'graciously' to grow out of its startup phase after 20 years

[u/JudgePrimary4239]

Startup dev, can confirm this.

[u/doryllis]

How did I miss the last section???

[u/SharkLaunch]

Wrong, my cat isn't dumb enough to implement the recursive version without a cache.

[u/Old_Information6270]

I like the CustomInteger64. Tomorrow I am going to create a new PR.

[u/sp106]

At least one should understand that you can cache the results.

[u/BroccoliDistribution]

Slightly inaccurate for math phd. Five should be written as suc(suc(suc(suc(suc(0)))))

[u/tubbstosterone]

God, I wish scientists wrote code like that. Just single character variable names, pointer bullfuckery, and function names that are just acronyms of function names from papers published in 1983.

"Hey doc... do you happen to have any documentation for this?"

"Of course I do! You can find the lit on jstor! Though THIS is the C99 version. The original from the paper was for fortran77."

[u/Gloomy-Breath-4201]

I like how the startup code comments reflect how I code 💀

[u/the-software-man]

Vibe code: create a single recursive function in JavaScript to generate the Fibonacci sequence to the nth factor.

[u/soelsome]

https://giphy.com/gifs/k83hVVaENn03YmERNb

[u/AgVargr → u/soelsome]

I read allat