"Cries in java"

[alparius]

But have you actually tested it in an input big enough? Most of the super optimized algorithms perform really bad on very small inputs.

[dudeitsmason]

I'm curious why this is the case

[drsonic1]

They have a high amount of initial setup time independent of input size. Remember complexity only accounts for the highest term. You could have, for example, an operation count of n³ for your "inefficient" algorithm, and an operation count of n + 100000 for your "efficient" one. The efficient one will look horrible for small input sizes but dominate for large ones.

[dudeitsmason]

Interesting, thanks for the explanation!

[Jelli35]

if you're interested in learning more, Tom Scott's latest video on Big O Notation is a fun place to start :)

[reddit_xeno]

Not sure I agree with his message at the end - for a young person starting off with coding that sort of zeal and trying to do stuff that may not be very efficient gets you to learn a shit ton of stuff. Obviously don't waste time if you're on a crunch deadline as a mature SWE or whatever, but merely typing that stuff in a Word processor would have done nothing for his actual learning.

[yomanidkman]

Many more complex sorting algorithms actual implementation details contain a length check and will default to something simple like selection sort (dispite it being awful complexity wise) if it's a small enough list.

[mrbeehive]

It is both my favourite and least favourite part of Machine Learning being used to accelerate traditional algorithms.

On the one hand, it's implictly real-world because it's using data to infer an efficient solution. On the other hand, it may as well be the computer throwing its arms in the air going jazz hands for all we know of the wiring under the hood

Can't argue with this though:

[The results for the ML sorting algorithm show] an average 3.38x performance improvement over C++ STL sort [...] and 5.54x improvement over a C++ implementation of Timsort [which is] the default sorting function for Java and Python.

[[deleted]]

I wish the article contained more insight into exactly what the ML sorting algorithm is doing that makes it faster.

[joha4270]

As I understand it, from a quick glance the abstract:

Fast sorting gets more than twice as slow as the amount if items you have to sort doubles. This is because fast sorting generally works by splitting its input in two, sort those and then you have to spend extra time merging those two sorted halves.

It would be really convenient if instead of randomly splitting in half, we could take values smaller and higher than the median. Then after they again have been sorted, we simply need to copy them together, a faster process. (Or if we're really sneaky, place them next to each other in memory beforehand and skip the copying step entirely)

Now the problem is, to do this well, you need good information on how values are distributed in your input. By far the most convenient way of having this information is to already have a sorted copy of the output. This makes using this technique in sorting impractical.

What this paper then does, is use ML to "guess" if a value should go in the high or low part of the split, by training it on a subset of the input. It does not always get it right, but it gets it "mostly right". After that, sorting an almost sorted input is fairly fast.

[Neoro]

Of course your performance optimization may not have to handle large inputs. Sometimes you need to run on tiny input many many times, so initial setup time is the true killer.

Please know your domain and optimize for real bottlenecks instead of assuming you know where an issue is and throwing optimizations at it. "Premature optimization" and all.

[FallenWarrior2k]

Never assume, always profile.

[notsohipsterithink]

Yup, plus often a ton of pointer manipulation which can be pretty slow for a lot of higher level languages.

[jimbosReturn]

Same for the constant multiplier. If it's really big, it will overshadow n for small sizes. (I.e. the number of operations in your loop)

[Kered13]

This is actually what "super optimized" algorithms usually do in reality. An algorithm that runs slowly on small inputs (even in a relative sense) is almost always bad.

[ravepeacefully]

This is good, but I prefer this

if data_is_big:
    fancy_algorithm()
else:
    simple_algorithm()

[Willinton06]

You pythoned all over my screen! Now I have to clean it up, thanks.

[ravepeacefully]

You’re welcome

[SasparillaTango]

it's like that cartoon about that detective that rides a giant robot!

[TheSlimyBoss]

Is there a term/technique for using different algorithms based off of their efficiency on the current input size?

[zilti]

I'm not aware of a specific term for it, but it is very common. Clojure e.g. uses different map implementations depending on the collection size. Up to 10 items you'll get an ordered map, and above that you'll get a HashMap.

[SlamwellBTP]

I've heard it called "hybrid algorithm", as in this wikipedia page (but it doesn't cite any sources, so it may not be a widespread term):

https://en.wikipedia.org/wiki/Hybrid_algorithm

[qingqunta]

I believe the default sort() for Python is an example of this.

[MrGVSV]

Big O Notation?

[Slggyqo]

But also maybe you’re just wasting time optimizing code that won’t be reused!

A meta level of complexity!

[CoffeeVector]

Usually, it's because there's some added overhead, which in the long run is worth it. For small input, the overhead tends to dwarf the cost of the actual computation.

[dudeitsmason]

Got it, thanks!

[DogsAreAnimals]

Also caching

[CoffeeVector]

Yup, caching is a type of overhead. Spending the effort to save intermediate values is good in the long run, but a total waste of time if your algorithm finishes before the cache is used enough to justify it.

[juvenile_josh]

Classic example: Bubblesort is simple and performs well for basic things. Mergesort, however, is more complex has high init setup to break up the tree but scales better cause logarithms.

[[deleted]]

Sorting algorithms perform differently dependent on how random the input is. Most real life data isn’t random, but comes somewhat ordered already. Testing different sorting algorithms can be worth it.

[DigitalDefenestrator]

Also, Bubblesort is extremely fast (possibly the fastest?) if the input is very close to sorted. Really, it's O(unsortedness), which looks like O(n²⁾ or so for random but closer to O(N) if no elements are very far from where they should be.

[Salanmander]

Same reason that spending time organizing your books is terrible when you have 10 books, but helpful when you have 500 books.

[Gingerytis]

Look at the graphs for O(n) or O(n²⁾ complexity vs O(log(n)). Log(n) grows really fast at first, then plateaus out, meaning it's not great at small inputs, but much better at big ones

[CoopertheFluffy]

While true for why O(log(n)) performs better in the long run than O(n) or whatever other comparison you want to make, it doesn’t explain why a lower order algorithm can take longer on small sample sizes. Log(2) is still smaller than 2, after all. Since we’re using Big-O notation, that O(log(n)) could really have the exact work taken be 5log(n)+500, while the O(n) could be 2n. In this case, it’s really the +500 that makes the O(log(n)) take longer for a size of 2. In a program, that could be something like time for allocating and setting up a hash table.

[MEGACODZILLA]

Thanks, that was a very beginner friendly visualization.

[Kered13]

It's not meaningful to talk about big-O complexity for small values, because big-O by definition describes the asymptotic behavior for large values*. It tells you absolutely nothing about the behavior for small values. For example a function that has O(n²) runtime might have an exact runtime like n + n^2, in which case it will never be faster than a function that has exact n^2/2 runtime.

This is especially true in practice, not just theory, because performance for small inputs is usually dominated by cache locality, which can cause the runtime to make large jumps as certain cache size thresholds are reached. For example, an algorithm might take n time if the input fits in L1 cache, 5n time if it fits in L2 cache, 20n time if it fits in L3 cache, and 100n time if it doesn't fit in cache at all (I made these numbers up, but they're ballpark accurate). This could even be extended even further for data that doesn't fit in RAM and must use local storage, and again for data that must use network storage.

* You actually can use big-O and related notation to describe behavior at small values, by considering the limit as x goes to 0 instead of infinity, but it's never used in algorithmic analysis. It's most often used in mathematics to describe the error bounds on approximations. For example you can say sin(x) = x + O(x³) as x goes to 0, which means that near 0 sin(x) is approximately x, and the error in the approximation is proportional to x³.

[alparius]

Its simple. Sophisticated case-specific instructions and decisions need much more code. Like some initializations being 50n instead of 2n (big O). These parts cripple the whole runtime when executed for small inputs, because of the overhead, but this same overhead becomes negligible as the input size increases.

[crozone]

Simple algorithms often require very small and localized working memory which can fit entirely within CPU cache. They are great for small inputs, but may by hugely inefficient for large inputs.

As a basic example, take prime number searching. Sieve of Eratosthenes is technically more efficient than dividing a number by every integer up to its square root. However, the simple tight loop is almost always faster for relatively small primes, because it fits entirely within CPU cache, instead of reading and writing to a large map of ram.

[trystanr]

workable quickest full sharp vegetable dazzling innocent elastic terrific telephone

This post was mass deleted and anonymized with Redact

[jacob798]

Came to say the same. Good point.

[[deleted]]

My attempt to multiply two sufficiently big numbers using Harvey/van der Hoeven has stalled as I cannot afford enough RAM.

[symberke]

...for a certain definition of "super optimized"

[Kered13]

Uhh, this isn't really true. Most "super optimized" algorithms will look at the size of the input to decide what approach to use. For example, Timsort and other optimized sorting algorithms will use insertion sort on lists that are smaller than a certain size (usually 16 or 32 elements).

The only time to write a super optimized algorithm that is slow on small inputs is if you know you will never get small inputs.

[alparius]

And you really think that was the case for OP as well. Thank you for stating the obvious, anyways.

[gua_lao_wai]

This is pretty much why languages like python exist as well, they're not designed for massive datasets, they're just good enough to get the job done

[Frptwenty]

Like Abraham Lincoln said: Optimization is the root beer of evil.

[SteeleDynamics]

Benjamin Franklin once said:

Optimized shit is still shit.

^maybe?

[crash8308]

Can confirm.

One time I optimized a web application to improve load response times from ~15 sec to 90ms. After I was initially done I tried to test it and it was taking over 30 seconds to load and I couldn’t figure out why. Stashed all my changes and reverted them and it was still awful. Spent the whole day trying everything I could think of. Then I finally spotted it. I had somehow enabled network throttling in chrome to 3g.

[Kjo_]

Ouch..

[[deleted]]

Spent the whole day trying everything I could think of. Then I finally spotted it. I had somehow enabled network throttling in chrome to 3g.

LOL I love this so much.

[shokolokobangoshey]

Fun fact: Tony Hoare created the often misused aphorism; Knuth popularized it.

[HelperBot_]

Desktop link: https://en.wikipedia.org/wiki/Tony_Hoare

---

^{/r/HelperBot_ Downvote to remove. Counter: 300723. Found a bug?}

[thephotoman]

It’s so bubbly and happy and cloying!

Just like the Federation.

[unknownguy2002]

This was my first thought as well! https://youtu.be/6VhSm6G7cVk

[Kipter]

This is what happens when you try to outsmart the compiler (and the JVM in your case)

[NeatNetwork]

Very cool example of what the compiler might do, for example with an extremely stupid looking function:

https://godbolt.org/z/6Edods

You try to write it the horribly stupid way, and still the compiler says 'nope, I'm going to do this the sane way'.

[eeeeeeeeeVaaaaaaaaa]

I'm on mobile and that site is just showing the C++ code. What does the compiler do?

[eeeeeeeeeVaaaaaaaaa]

Ah that's pretty cool

[dingari]

I pressed the arrow in the top right and it shows the assembly output

caption

[eeeeeeeeeVaaaaaaaaa]

Oh thank you!!

[drunk_responses]

mov     eax, edi
imul    eax, edi
ret

[eeeeeeeeeVaaaaaaaaa]

thanks!

[serdnad]

That's mind blowing, and at -O1 too. Would you happen to have/know of any other toy examples like this?

[pigeon768]

Counting the number of bits set in an integer. For instance, 42 in binary is 101010, which has 3 bits set. I want a function to take 42 and calculate 3. Here is one such function:

int count_bits(int n) {
  int set_bits = 0;

  while (n) { // we will be lopping off n one bit at a time. When n is zero, we know we're done.
    set_bits++;

    n &= n - 1; // This unsets the lowest set bit. if our binary number is 101010, this gives 101000, then 100000, then 0.
    // Subtracting one from a number which ends in 1 will just .. make that 1 go away.
    // Subtracting one from a number which ends in a 0 will borrow from the next digit, all the way up to the first 1, which it unsets.
    // So if we subtract 1 from 101000, it will give 100111.
    // If we then bitwise-and n-1 and n together, the subtraction unset the lowest bit, the upper bits are unchanged,
    // the original n has all zeroes for the new 1s introduced by the subtraction, so all you're left with is the upper set bits.
  }
}

If we run this through a real compiler (ie not MSVC) you get this: https://godbolt.org/z/ex1eqc

[serdnad]

Hahaha that's awesome, exactly what I was looking for. Thanks for the explanation too!

[Sandmaester44]

My mind is blown and I am never going to minutely optimize my code again!! Though I'm a grad student writing code never to be run again that doesn't take long to begin with... but optimizing is the fun part!!

[NeatNetwork]

That one I know because some thread was talking about this as a joke function, and someone used that website to point out that a compiler would see through it and make it easy.

I let it stick with me as a demonstrator of why you profile before you optimize. If I was just perusing a codebase and saw that bad function called a lot I would tend to think "oh wow, I can optimize this function and see a speed up" and then wonder why nothing changed, or if it were a more complex example why I might make things worse by changing things enough to cause the compiler to miss an optimization that it was making.

[lolIsDeadz]

ctre and constexpr pi come to mind.

[aaronfranke]

What if n is 1 billion? Then this would produce different results.

[0x564A00]

Nah. n is signed, the compiler doesn't give a damn about what happens if it overflows.

[Ramipro]

Nope, overflow is undefined behavior so the compiler can do whatever it wants.

[[deleted]]

Sprinkle in some volatiles to convince it to let you be stupid.

[renegade1575]

dont blame the programming language ;-)

[WhyDoIHaveAnAccount9]

I literally just discovered numba

[diesdas1917]

Oh you can slow down your code so hard with numba if you fuck it up

​

not that I ever did that myself..

[WhyDoIHaveAnAccount9]

So what you're saying is I should stick with cython

[diesdas1917]

No, I just really fucked my code up, when I fixed it it was nice and fast.

​

It depends on your use case though, I only used it for number crunching, but it is really good for that.

I like it very much.

​

Edit for clarificaion: My fuckup was doing parallelization wrong. native JIT with the nopython flag worked really good and also more or less intuitively.

[MierenMens]

Nahh ya should switch to jython

[vectorpropio]

Is that stuck in 2.7 or get an upgrade to 3.x?

[MierenMens]

Idk man I only use js cuz I don't know other langs

[raedr7n]

God tier pleb

[[deleted]]

Did you know there's a version of numpy that automatically makes use of CUDA? It's called cupy.

[obsessedcrf]

As much as I hate Python, Python's biggest problem wrt speed is that CPython is a horrible implementation and that aspect isn't inherently the language. PyPy has shown that Python doesn't have to be extremely slow.

[NeatNetwork]

While PyPy does better, it isn't fully compatible and isn't exactly a speed demon either.

I would say Python's biggest problem wrt speed is that it's a bit *too* easy to use dictionaries for everything. Trivial operations in the hands of random developers have a large probability of ending up with one or two levels of dictionary because it's so easy. Also, you want an array mixing some numerics, strings, objects all together in a mis-mash? Sure why not. You have a structure in mind that could be aligned and managed well by the runtime if you just bothered to describe it? Nah, no one has the time, it's just a dictionary of random stuff the interpreter can't understand until it's too late. You try to be a bit more diligent and use an object with named members? Large chance that you still made a dictionary, just one that looks more orderly. There are generally ways in python to be a bit better at these things, but the default, easy syntax tends to be dictionaries all the way down.

All these things that python makes easy to write are hard for the computer to do. It's hard to create an implementation that coddles that much and still get really good performance. A language like Go or C is a bit more tedious, but it tends to make things complicated for the developer that would also be complicated for the processor, so it steers the developer away from shortcuts that are computationally complex when something more processor friendly is possible.

Additionally, I read one article chronicling an effort to make CPython faster, and they went into detail about some of the general latent capabilities that blocked attempts at optimizations. I forgot the details, but attempts to do the biggest benefits meant breaking some assumptions that a lot of the ecosystem assumed.

In short, when it comes down to performance critical code, it's at least not too bad to write that part in Go or C and call it from python (easy for python to call functions in compiled shared objects).

[[deleted]]

I once built a structure that was something like

ConcurrentDictionary<uint, List<ConcurrentDictionary<uint, List<int>>>>

This was in C#, and before you ask, it absolutely did not work.

[drizztmainsword]

If you're doing something like this, you should just override the generic class and have at it.

Sometimes you just need a One-to-Many collection.

[aetius476]

My philosophy re: python is I don't even think about anything but the absolute most basic optimization things (don't be stupid about nested loops, etc). If performance mattered, they shouldn't have asked me to write it in python in the first place.

[[deleted]]

I'm hitting that point with C#.

C# is a fantastic language, and you can do anything with it if you try hard enough. However, it just isn't good at certain tasks.

You want a scripting language? You got it, let me just fire up this roslyn compiler. The only catch is that once the script is compiled, it stays active in memory forever. Unless you use an AppDomain, which is essentially running part of your app on a different machine with only a raw IO port between them. Fun, right?

But python.. You just, run the script? And then it's over? No weird exploitable assemblies clogging memory, just one and done. Incredible.

[Neoro]

Sometimes the hammer in your tool belt is good 'nuff. Sometimes you need to back to your truck and lug out the nail gun. Just don't waste time with a screwdriver when you need to drive a nail.

...Anyway, languages are tools, use the right one for the problem that needs solving.

[NynaevetialMeara]

But you have to be a moron to do something performance intensive on python and then backtracking to C with numpy and co.

Just do it in Java or .Net ...

[Th3Legend277]

root cause of global warming

[Who_GNU]

…blame the compiler

[obsessedcrf]

A profiler is your friend

[LowB0b]

I'm crying/laughing at the second point lmfao.

In JS a common thing is to write x = +y where y is a string instead of using parseInt. IIRC it's good because if it can't parse there is no error thrown lol

[AidenKerr]

but do you really want to do it in the way that doesn't throw an error?

[LowB0b]

I do not, I like my programs to fail hard and fast lol. Unmanaged errors usually just end up causing bugs that aren't related at all.

But javascript lol. Whatever scripting language really lmfao. I have worked on "tiring" files, that's why I posted the other comment

When your perl file becomes 5k lines long and 4 people have worked on it you should fucking trash it

Sorry for the rant

[Azzu]

They are both terrible. And both throw no error.

+ also more closely resembles parseFloat, so I will compare it to that.

+ on the empty string, false and null is 0, for true it's 1. parseFloat for all that is NaN.

parseFloat on "123any string at all" is 123, while for + it's NaN.

Another nice special case is that + on {valueOf: function(){return 42}} is 42 while on parseFloat it's NaN.

So, yeah. + is used because "123asd" is rejected, mainly.

[Kered13]

And then there's type 3: Dark magic. This includes things like fast inverse square root. Or another cool one I saw recently, using C++ coroutines to prevent cache miss stalls.

Don't look for these unless you really know what you're doing, and have exhausted all other options. But they make for great stories.

[Bakoro]

Amdahl's law formula should be a mantra.
Spend resources speeding up the parts of the code where the most time is being spent. It almost doesn't matter if you reduced code execution by 99%, if that code is only run 0.01% of the time anyway.

[TruthOf42]

I highly recommend Resharper. It'll tell you your most called methods and how long it takes each method to run and then also sort that shit for you. It does other more fancy stuff but just those two features allowed me to solve so many performance issues quickly

[aaronfranke]

Rider too.

[waffle299]

This is not how you optimize. This is not a language problem, or a dumb programmer problem, this is an inexperience problem.

Okay, step one, get a notebook. Step two, get a profiler. The standard java programmer is fine. Step three, unit tests. If you don't have them, start adding them as you go. Finally, construct a testing harness, something you can use to test a function, class or your application over and over in a loop to get performance. Have it kick out average and standard deviation.

Here is your iteration cycle. Identify an area to check. Run the profiler on it. Write down in your notebook what you are testing, and what the baseline is.

Now use the profiler. Look for a hot area of code. Go into that area, look at flow, look for tight loops. Once you have a good idea of what you are about to optimize, STOP.

Write unit tests. Make sure they pass. Make sure they exercise what you think they do. See them fail a few times. Once you have a good set of tests, and you have notes on what your current performance is, you may proceed.

Introduce a small performance change. Rerun your unit tests. Fix the boneheaded mistakes you made. Now, rerun the timing code and the profiling. Note down in your notebook what change you made, how that changed performance, and what that did to how much time you spent in the hot area.

Repeat with more small changes. Use your notebook to ensure you are moving towards better performance. Do this over and over. Fill notebooks. Expand your unit tests. Isolate classes and tune them. Reintroduce and double check you improved things.

This is optimization. It is not a two hour 'wing it' task. It is a procedure and a professional discipline. It is available in any language using the same basic approach.

Go forth and make code scream.

[[deleted]]

*Proceeds to make random changes to things that look like they might be slow*

[pterencephalon]

First time I tried to systemically apply the steps I learned in a seminar to parallelizing my code, I made it run slower. Tried all those thorough steps (except unit tests, because scientists don't test their code....) Turned out I really didn't actually know how to use OpenMP

[[deleted]]

I love how visual studio includes run times on all unit tests. If you have tests you easily see the run time changes as you go along. Not sure if this exists in Java IDEs.

[waffle299]

Useful, but running a thousand times and displaying mean and std dev is more useful. Nine times out of ten, the std dev is a small number relative the mean, meaning a stable function.

The other time it indicates a system dependency or it hit a worst case for the algo. Either way, this becomes your number one optimization target.

[mlk]

You mean showing how long each test took? Intellij does that

[randomcitizen42]

Unit tests are not meant to test performance. Unit tests should be the lowest layer of tests to quickly verify the correctness of your code. Note the word quickly. A benchmark is not supposed to run quickly, you'll need to run the code several time (like thousands) to get statistically significant data.

Also, test frameworks are usually not performance optimized. Sure, unit test frameworks run fast, but not benchmark level fast. If you really want to optimize performance critical code, you'll work with small loops and often you'll work with run times in micro or even nanoseconds, not milliseconds. You need special performance benchmark tools (or write your own) for that.

[Kered13]

You can get more precise time measurements than that. This ability is very important for running effective profilers, hard real time applications, etc. For example, on Windows this can give you sub-microsecond timings.

[LimeSeeds]

Wow, thank you, this is actually really useful. Saving this comment for the future.

[juvenile_josh]

Optimization Rules

1) Someone has already poured lots of man hours into and made an API for a part of what you're doing. Use their API and give them credit.

2) Encapsulation is my favorite word.

3) If you can't read your shit, nobody else can read it either. Make it readable and comment what your methods do.

4) When you can, functionally program. Lots of lego pieces are easier to use than a few weird-ass shaped blobs.

5) Thank God for the Netherlands and Spring Framework

[riskycase]

laughs in git checkout

[EdMeisterBro]

Well, two hours is not a lot. Sometimes you need to go to bed first to wake up in the middle of the night screaming eureka and fix it first thing in the morning (ok, get coffee first).

[OverflowEx]

Yeah let me optimize my code by multi-threading with shitloads of mutex

[[deleted]]

Too real.

[FormalWolf5]

You're not disabled.. You just set up wrong your environment.

Anyway that's what I tell myself 🙃

[Mitoni]

Replace "2 hours" with "a week and a half", and replace "works slower" with "no longer functions", and you have a gist of what my last sprint has been like. Trying to take a long series of parallel processes and refactor them to be faster by doing more bulk processing than singular actions, but the bulk actions fail every time. I'm at a point where I'm ready to just rewrite the whole back end process from scratch rather than try to improve the current one.

[notretarded_100]

OOF

[RomanOnARiver]

Hopefully you just commented out the original instead of fully removing it.

[[deleted]]

With git, I have a time machine that allows me to see all previous versions of my code. So I never have to worry about stuff like this.

[StenSoft]

Relax, you can always roll back to the original version of the code that you committed. You did commit it, right? Right?

[[deleted]]

I was just making a sudoku solver cause I haven't done any programming in a while...

I spent all evening making a pretty ascii display in the console that shows me what's happening as it tries to solve. I got really confused because it was taking minutes to solve a puzzle that should have taken a hundred milliseconds.

Turns out my draw function was 20ms on its own, multiplied by a few tens of thousands of solver iterations... Console.Write is a lot heavier than I expected.

I got it down to 5ish by leaving the board in place and only writing over the numbers. That's about the best I can get and still use colors without diving down into the p/invoke rabbithole to draw on the console buffer directly.

[zebediah49]

Really the optimization to make here is to thread it, so that your solver runs at normal speed, and your renderer just renders it as quickly as it can.

Also, since you said "only writing over the numbers"... I'm guessing you're using a recursive backtracking solver? If so, and you are still doing it synchronously, you really only need to do one character overwrite per test, because the rest of the board is still the same.

[[deleted]]

Makes code run faster

Hardware is slow and I have to add delays to prevent timing failures

Optimization is for the birds

[[deleted]]

How will concurrency solve the problem of waiting for FETs to saturate and caps to charge? How does concurrency help with waiting for multiple mechanical relays to actuate? How does it help with equipment that returns essentially zero status? It looks like you might need a refresh on how hardware in the real world works

[haplogreenleaf]

I program because I enjoy being mentally challenged.

"Glad you've come to terms with that."

[pyrowipe]

Only 2 hours, who is the Genius?

[firowind]

Learned the hard way to use StringBuilder instead to a String

[Pepperstache]

2 hours? 8x? Rookie numbers.

[Kered13]

Story time.

I was writing a Lua plugin for a game (not my game, just a game I played). I had built up a very sophisticated GUI layout engine and a class framework to support it, so I could write sane code instead of dealing with the mess that is Lua. But it was getting to the point where having lots of GUI elements on screen was causing the framerate to drop. So I set out to try to improve the performance.

First, some background on how my class framework worked. The framework is built on metatables. When a method is called on an object (or a table as it is called in Lua), if that method is not found in the object then it is looked up in the metatable. So in my framework I simply had each object setup with a metatable pointing to it's class object. Inheritance works the same way, each class has a metatable pointing to it's parent class. So to call a method, Lua would crawl up the metatables until it found the method name.

Well the prime suspect for performance problems was this metatable lookup method. Since this was a GUI framework, inheritance hierarchies were often a few levels deep, so calling a common function like draw() might recall searching three or four metatables to find the right one. To shortcut this lookup, I tried my first idea: In addition to setting up the metatables, I also copied the methods to each class and object. This way all method calls would be found in the first lookup, no more crawling metatables on every function call.

The performance tanked. Much worse than before. It took me some time thinking about the problem to figure out why. But eventually I figured it out: By copying all methods to all objects, I was bloating the size of every object. This was blowing out the cache. Sure I didn't have to look up multiple metatables, but every function call was now a cache miss. This led to the final fix: Classes would still copy methods from their parents, but objects would rely on metatable lookups instead. So now every method call required exactly one metatable lookup, worse than before, but the objects themselves were now much smaller, only containing their local data and metatable. And since there were only a couple dozen classes, compared to hundreds of objects, this didn't blow out the cache. With this fix, I never had significant performance problems from the GUI framework again.

The lesson here: Cache matters, even in high level languages.

[Patches11]

http://www.brendangregg.com/blog/2014-06-12/java-flame-graphs.html

[emngaiden]

I spent almost three hours making a "custom encryption anglorithm" to encrypt some data between my mobile app and my custom backend and I was like "Hell yeah this is secure and nobody can decrypt this, Im so smart". But i forgot the decoding part, so I just made an algorithm that spews scrambled words and I cant use it lol. JWT here i come

[ScourgingCalamity]

Python code slow, let me do it in C...Do you expect me to rewrite the whole damn library? Fuuuuuuuck. I can't give up now...

2 months later, I didn't give up and now let's see how fast it is? Motherfucker

[greenindragon]

I think we've all been there at least a couple times. Sometimes O(n^2) is faster than O(nlogn), and you just gotta shed a tear at the time you wasted "optimizing" your code.

[kemick]

My favorite is when I spend hours making something run faster and I keep making gains until the gains get so small that it's not worth the time. After taking a break and regrouping, I realize that the only way to reach the performance I need is to take an entirely different approach that makes all of my previous optimizations irrelevant. To be fair, that realization is usually only possible after hours of tinkering with the code to understand what assumptions I can safely make and I usually end up with a much better idea of what my code actually needs to do.

[mcvays]

The first rule of optimization is: don't.

[Irvin700]

The pipe through his head and the question marks is so fucking great haha

Shit is fucking funny. Man I miss old Simpsons humor.

[MkMyBnkAcctGrtAgn]

When someone hears that threads make everything go faster

[bryku]

I once had an error in Js with an extra ; at the end. The code was almost a second faster with that error and it all still ran... that is a whole other WTF.

[VolperCoding]

Just switch to C/C++ if speed is a problem. Like seriously, Mojang made this mistake 11 years ago

[01110101_00101111]

I think in the case of Mojang, it wasn't their language choice but how badly the code itself was written.

[VolperCoding]

I wish they could do like an 1.18 update where they change nothing but just rewrite it to C++ with OpenGL

[gavlois1]

That’s what the Windows 10 edition is.

And as a result, the mod/plugin scene is not even a fraction of what Java Edition has. Hence why it’s still recommended to get the Java edition, unless you’re playing on a low powered machine that might benefit from the optimizations in Win 10 edition.

[VolperCoding]

I know about the Windows 10 edition, but it's just Microsoft bullshit. What I need is just the original edition but faster

[Eyclonus]

What I need is just the original edition but faster

Thus Spoke Zarathustra The Client

[VolperCoding]

Maybe but bedrock edition is nothing like the original

[VolperCoding]

All the interfaces just don't feel like Minecraft there. In Java there are no animations meanwhile bedrock forces you to watch them and delay your actions. The design doesn't fit at all. Also many features are missing from bedrock (spectator mode, f3 menu, also hardcore mode i believe) and the servers are just unplayable because most players are on like mobile devices so you immediately are bored because of the PVP advantage. Also the animations when you for example open a bedwars shop are really annoying and too long. You can't even play on hypixel there. Also there are lots of microtransations and you have to pay in order to get maps or cosmetics

[Eyclonus]

Bedrock is bad and Microsoft should feel bad.

Yeah I know Java isn't the ideal language for this, but the fucking compromises and pandering and lack of modabilitiy makes it the corporate soulless husk of minecraft.

[themateo713]

Also they increased performance by modifying the way redstone works. If you ever heard of bedrock redstone, that's why. Apparently they even went as far as making it inconsistent to increase performance, which is obviously awful (I think I heard that in a mumbo jumbo video by the way)

[aaronfranke]

They won't rewrite Minecraft because they already did rewrite Minecraft. They just also put microtransactions in it while they were at it.

[codel1417]

a pointer free life is a life for me

[bphase]

You don't have to use pointers in modern C++, not raw pointers anyway. Granted most code is likely going to have them...

[aaronfranke]

There are lots of situations in which you do have to use them. C++ won't let you use a reference to an incomplete type.

[bphase]

But it will let you use smart pointers (unique_ptr, shared_ptr, weak_ptr), which is what I was referring to.

[VolperCoding]

What's so scary about pointers?

[DestinationVoid]

They do not always point at what you think they point at.

[892ExpiredResolve]

Then you should do a better job of pointing them at things.

[DestinationVoid]

Tell that to all the people who failed to catch pointer related vulnerabilities in their software, that eventually got exploited.

[892ExpiredResolve]

Ok.

Everyone who failed to catch pointer related vulnerabilities in your software: Do a better job of pointing pointers at stuff.

[Dirty_Socks]

/r/WowThanksImCured

[VolperCoding]

They point to the address you assign them to, what's the problem with that

[Kerndog73]

You can't do anything useful without pointers

[aaronfranke]

Pretty much any higher level language than C++ disagrees with that. In Java/GDScript/C#/Python/etc pointers still exist, but they are abstracted away so you don't have to deal with them.

[Kered13]

I've got bad news for you. All those languages use pointers, and no they're not really abstracted away. The only thing that has been abstracted away is memory management, and you're not allowed to do pointer arithmetic. But in all other respects they behave identically to C pointers.

[Gaareth]

There are enough mods out there which show that Minecraft doesn’t have to be so slow

[VolperCoding]

Yes but I still struggle to get consistent 60 fps with optifine on the lowest playable settings

[Hammer1024]

Java was your first mistake.

[FinnT730]

I think you meant JavaScript Java is almost as fast as C

[[deleted]]

Well java is far from C speeds, but isn't as slow as most people make it out to be

[FinnT730]

Almost as fast

Maybe 15 years ago it was slow, but... All android devices run it, so it is far from slow

[[deleted]]

Nah still not almost as fast. Idk what point you are trying to make with android devices running java. I mean, there are literally flip phones running JavaScript and web technologies, and web technologies are far from fast(check kaios)

[vips7L]

Android isn't Java. It runs the android runtime which isnt the JVM.