To some degree it was warranted because when we were in crunch time 2 weeks off from a key developer would kill the project.

However there were definitely dead times and they still just had this aversion to giving out 2 weeks - probably because they were afraid it would catch on.

It was only a few months old. Windows 10 machine. Super cheap - cheapest you could get, but it was an HP - so brand name anyway. Hard-drive failed.

That's my crappy laptop, not the desktop. It's starting to fail now too. It's from around 2008 - windows 7. Was a cheap computer then too.

I'm going to try to limp along with the laptop until I'm willing to spend $1000+ on a new one.

Sounds like a lot of you work for ****ty employers and/or managers?

I left a pretty decent place for an even better place. I took 7 weeks last year at my old job if you count all the random days off I took as well as normal vacations.

I plan to take 5-7 weeks at new job now as well. I’ll still get as much or more done than coworkers at the same level as me.

Yes, many people won’t use the policy effectively. I definitely plan to use it.

One other positive is that a lot of my coworkers came from my old employer as well and are used to the flexible policy and I think everyone plans to use it.

Dude seriously? Take more time! Nothing will happen to you and you will probably end up being a more effective employee after some much needed recharge time. Take the whole week of Christmas and those first couple days of New Years week off.

I balance it by showing up at 9:30 and leaving at 4:30.

On top of flexible vacation, our company is closed every year for 1-2 weeks around xmas and the new year.

We close week of Christmas. Used to close week of the 4th of July as well.

3 weeks vacation and two of them were mandatory shut down weeks.

So you think you're doing a free, but that something isn't actually being freed? A common cause of this is when you are storing a pointer to memory, and that is holding pointers to other memory. If you free the outer level pointer, the inner level won't get freed.

See if you have to use vacation during these mandatory shutdowns then it's kinda BS. But mandatory shutdowns + "unlimited vacation" is golden.

Lol memory allocation and cleanup. Only time I ever had to mess with that was old iOS programming in the late 00s. It was like 90% of my debugging effort and drove me nuts.

EVENTUALLY stuff is being freed. But not at any point that makes sense logically. But I do think what you just described is happening

Everything you use relies on this stuff, you’re just abstracted way above it

With Macs there aren't really super cheap versions so upgrading is really a pretty low key event. I've had 2 or more Macs for the last 10ish years and only been super giddy over speed improvements a couple of times and don't expect to be again until I'm able to get a super iMac pro. With Window's wide price points it seems you can be all over the place price/performance wise.

std::unique_ptr >>>>>>>>>>> C memory management

Related-ish, we're using an SDK that hands every resource imaginable around in shared pointers and I've spent the last two days trying to figure out where something is holding on to one last shared_ptr reference thus preventing the underlying object from being freed when it should be, which is convincing me that you should never use shared_ptrs without some kind of wrapper class that tracks reference creation in debug builds (but would thus never be transportable across SDK boundaries, so...welp)

You say that like it's a bad thing...

SSD are imo the most important feature of any personal computer, I'd consider it insane to buy anything without (or without an immediate plan to fit one).

I am sort of confused how something is being freed but you're winding up crashing the server eventually. Maybe I am not understanding well enough.

I mean I can understand how memory is not being freed properly but without garbage collection wouldn't the memory be orphaned indefinitely? Is your program running on an OS that might perform that garbage collection?

The only memory I can think of that would be freed automatically is memory allocated on the stack when a function leaves scope. I am no expert though just really curious now haha.

Everything you use relies on I/O buses and logic gates, you're just abstracted way above it.

I guess my boss wins here because she just has to tell me a few sentences and a program appears.

I have a server process, and a client process. The client request to connect to the server and gets a pointer back that’s supposed to be like a file descriptor to the server.

As the client I will close this handle with our software API. Client side it seems like all memories being freed properly, but somewhere in the server process, the server is holding onto some memory from this operation, because memory usage slowly creeps up until a crash.

Eventually, if you spam open/close API from the client side youll crash something. But if the server exits normally, it properly frees up whatever has been hogging memory, and valgrind reports no leaks.

Am i explaining it right? Sorry, i am not good at this stuff

It's really not uncommon. Let's say you have, I dunno, a user record. There's like a session object that's holding a pointer to the user record. But there's also a login manager or something, that's holding pointers to several user records.

So you free() your session object but you forget to free the data pointed to in the session. Later on the session object frees all the user records so in the long term there's no leak. But in the shorter term you're accumulating user records in memory. If the session object goes a long time between freeing it's user records you could accumulate a lot of them.

This is exactly what’s happening. Some struct somewhere holds a pointer to some other struct which in turn holds pointers. It’s a mess to try to dig through the src and see where.

Ah yea the client/server stuff was where I was getting confused. Was thinking all memory was local. Makes total sense to me in that context.

No @jmakin you were explaining it well enough I just don't work as regularly with these things as most people itt.

Edit: Thanks @RustyBrooks for taking the time to explain.

Pfft, everything you use relies on silicon wafers that are doped with progressive electron densities, you're just abstracted way above it. (This is the lowest level I personally know how to deal with, probably to a physicist there are lower ones)

You bet your ass - we're talking quantum tunneling through a potential charge barrier. We actually learned about it in physics but that's all I remember.

https://physics.stackexchange.com/qu...tors-and-silic

Well duh. I mean it seems so obvious in retrospect.

This actually gibes with the way we learned it and is mostly understandable:

Meh, once you get away from neuro transmitters and inhibitors it’s all abstractions anyway...