@heyheni one of us

this is annoyingly relatable

@shoop
Hahaha.

Only in an annoying way, sometimes I set up a buffer where I can write data to from the GPU and then read it on the CPU. This works alright until you fuck up the buffer setup because you're annoyed and you get to debug THAT first. And also everything on a GPU is multithreaded so you get raise conditions in your debugging buffer.

Fun times.

@NeatNerdPrime
It's a surprisingly mundane stack really.
I develop exclusively for 'consumer' cards (very high-end ones though think RTX 2080TI), on account of not being able to afford Quadro...

I use OpenCL to get the GPU to compute stuff. The way this works is that you write the GPU code in a C dialect and ship the source code with your application. OpenCL then figures out what machine language the GPU uses and compiles the code for it every time the programme starts(there are ways to have the GPU code precompiled but that's the easiest way).

I write the rest of the application in C++, as it is my prefered language and because it gives you controller over memory which makes getting all the data from your CPU to your GPU easier.

I then use super common libraries for UI stuff and whatnot, QT in my current project.

@hitko @AlmondSauce
Don't get me wrong. I know how it works and what it does, I was in the room when the data structure was agreed upon and did some of the maths to find the constants.

I'm mad because there is no fancy reason as to why the index is so unintuitive, we do it because the data on the CPU is structured in an object-oriented way and it is faster to build the array(s) in this way than one that makes the indices nicer.

It would be beneficial to readability and performance(reducing cache misses greatly) if we would structure the data on the CPU differently, but NO we rather do this as a quick fix.

@endor
And the only explanation is one comment that gives the formula and states
"; using the sum of an arithmetic series."

smh....

Speak fluently, 2: German, and English

Understand, 4: German, English, French, and Latin

@Maer It is one of those things where one gets used to the behavior of the library and can guess at whats wrong pretty reliably.

@Benedikt It does sound like that, I don't disagree.
The name properly referes to the concept of eigenvectors, eigenfunctions, and so on....

This is alternative syntax that is there so one can write normal functions in the same style that one writes lambdas. To specify lambda return type you go: [] () -> int {}. It makes sense to give the option to write normal functions in the same way imo, even though I find it rather ugly.

@ScriptCoded Because electron builds the user interface?

One of the lucky 10 000! 🍀

@S-falken Super!!
Thanks for the reply.

How does the battery hold up? I'm considering getting one....

The compiler allows there to be no return statement in a none-void function, BUT the value the function returns is not defined i. e. some compiler make them return zero and for some others it is practically random (on x86 the current value in eax but that's not relevant to you right now).

My iPad stopped charging for a while after updating. So I guess no....

0xff00abea

@HnDev I dont think so, but I am not to sure. At the end of the day type script just gets turned into Javascript, which is what the engine sees. Also one can write type script in a way where one isn't strict about typing, so the engine cant assume types to be definite anyways....

The reason electron requires so much ram is the Javascript Engine's (V8) optimisations. To make Js faster the engine creates optimised versions of the code in multiple stages, each stage assuming more about types, branching, etc. The problem is that when these assumptions are broken, for instance by calling a function which was previously only called with floats with a string as an argument, the engine needs to revert to a more general form of the code. To do that the engine will keep copies of that code in ram, which eats up all of it.

CERN is absolutely stunning.

I had the pleasure to get a tour from my Physics teacher who worked on CMS.

@EdoPhoenix
Yes that's true. But we are working on a physics simulation so it's not like Maths is an optional skill.

Are you American?

Nah that's good.

@beegC0de
nope they are not

xps 13

#ifdef is a compiler preprocessor, it needs to allways be followed by some symbol. (e. g.
#ifdef MY_SYM) A ifdef block is ended with a #endif .

It does the following. Let's say we have this code:

#ifdef WIN64
... my c code...
#endif

Then `... my c code...` only gets _compiled_ if the symbol `WIN64` is defined. The symbol `WIN64` is defined when using some windows compiler on a 64bit system. The purpose of this is to allow one codebase to contain the code for many systems.

There also are the directives:
#elifdef
#else

These work as you would expect.
Here one longer example to show how these work. (NOTE: I am making up the symbol names as this is dependent on the compiler you use)

#ifdef WIN64
... c code for 64bit windows...
#elifdef WIN32
... c code for 32bit windows...
#elifdef LINUX64
... c code for 64bit linux...
#else
... c code for 32bit linux...

#endif

@jotamontecino
Lightweight?

Google's V8 Engine might keep around _four_ versions of specific parts of the JS source.

Original Source, Ignition Bytecode, Speculative Assembly, and Highly Optimised Speculative Assembly.

What about this is lightweight?

yes.
cry.

Pick up karting or any kind of racing. Helps with focus and keeping calm, while being bloody fun.

@metamourge
@grumpyoldaf

Well mainly windows update's delightful "feature" of fucking up GRUB