Yes, and failure to reinvent the wheel is why we have a competency crisis. It's not only important to reinvent wheels while learning how to program, it's also useful to be picky about the wheels you choose.
If you would like to get a job, C# is a very commonly used language in business and if you know it and the associated ecosystem well you'll never be unemployed. Of course, it's not the only ecosystem.
The MERN stack (MongoDB, Express, React, Node) is very easy to work with and uses Javascript everywhere, so you don't need to juggle multiple languages.
PHP 9 might be a breakthrough, or it could be terrible. Depends on what the PHP developers decide is wrong today.
${var} interpolation syntax.You can't go wrong with a LAMP (Linux-Apache-MySQL-PHP) stack to start with, it's still very popular. Nowadays you'll find MariaDB is often the "M" there, it's mostly a drop-in replacement and doesn't have Oracle's sticky fingers on it.
I think this is just good coding practices
I don't know go, but structs are your friend. Properly packed. You'll find it's a trade-off between alignment performance and size. Network packets have a given overhead so a byte or two that improves CPU performance is worth it, 500 extra bytes, probably not. Also, minimize copying of data, and REALLY minimize anything that involves moving elements around one at a time. That is to say the in-memory struct should be the network wire struct. Don't do "net.health = internal.health; net.xp = internal.xp...."
If endianness isn't an issue, sure. I don't know if Go is handholdingy enough to stop you from doing this, on the grounds that it's technically UB (in C).
I'd always give the compiler the opportunity to make the optimization, even if it doesn't take it.
struct Players{
struct Player
{
std::array<3, float> xyz;
uint16_t id;
uint16_t health;
uint8_t ammo;
};
std::vector<Player> players;
struct Player &getPlayer(int i )
{ return players[i]; }
};struct Players{
struct Player
{
float &x
float &y
float &z;
uint16_t &id;
uint16_t &health;
uint8_t &ammo;
};
std::vector<float> x;
std::vector<float> y;
std::vector<float> z;
std::vector<uint16_t> id;
std::vector<uint16_t> health;
std::vector<uint8_t> ammo;
struct Player getPlayer(int i )
{ return {x[i], y[i], z[i], id[i], health[i], ammo[i]}; }
};It probably depends on if you enjoy working with PHP.
This is a very common practice in embedded systems work. Just be mindful of memory alignment when packing small types into structs. The CPU will always read at its word size, so reading unaligned bytes means the more expensive reading of the multiple words your data lies between.
Don't bother. You're painting yourself into a corner where the compiler would probably do a much better job than you would by hand.
Main appeal of classes in JS is that they're familiar to devs coming from other OOP languages. Last time I checked, prototypes were better in terms of performance.
The main thing that classes give you, other than that they're nice to use, is private and static fields. You might be able to achieve this with some bastard arrangement of global variables, or define them in a closure somewhere so that they're not accessible to the outside, but classes will just package them in naturally.
class MyClass {
#privateValue;
getValue() {
return this.#privateValue;
}
setValue(val) {
this.#privateValue = val;
}
}MyClass object will have get/set functions that access the private #privateValue field that won't be accessible outside otherwise. You could use private fields to store aspects of the object's internal state in a way that wouldn't be meaningful to the outside, or you can use private fields which are methods to perform internal stuff that you'll only need to call from other class methods.MyClass had a defined static #staticValue; then any class method could access MyClass.#staticValue, but only class methods could access it. Note that any instance of the class could access the static value, and it'd be the same value. You could do something like have the class keep track of how many instances of it have been created (or are "active").