At least you get capital loss carryovers for a decade, but it's so shameful that companies dump on their own employees. What a dark world.
287 karma · joined September 8, 2014
At least you get capital loss carryovers for a decade, but it's so shameful that companies dump on their own employees. What a dark world.
Perhaps this is also widely unpopular, but it's the parallelism that needs to be treated with care and the additional caution, as often the parallelism itself is the terrible idea.
Concurrent code often has unpredictable performance due to cache behavior and NUMA, unpredictable lock contention, and the fact that often there is no measure of whether the bottleneck is CPU or I/O.
What most people want from concurrency (like computing the response to independent HTTP requests) can be done by separate processes, and the OS can abstract the issues away. As another reference, the entire go language is designed around avoiding shared memory (and using message passing -- even though it doesn't use processes for separation it encourages coding like you did).
But also sharing memory between processes can be handled with care via mappings and using the OS.
For example, global variables have drawbacks, but so does re-writing every function in a call-stack (that perhaps you don't control and get callbacks from).
Or if you are building a prototype, the magic of being able to access "anything from anywhere" (either via globals or context, which is effectively a global that's scoped to a callstack), increases your speed by 10x (since you don't have to change all the code to keep passing its own abstractions to itself as arguments!)
Functions with long signatures are tedious to call, create poor horizontal (which then spills over to vertical) code density. This impacts your ability to look at code and follow the logic at a glance, and perhaps spot major bugs in review. There's also fewer stuff for say copilot to fill in incorrectly, increasing your ability to use AI.
At the end, every program has global state, and use of almost every programming construct from function calls (which may stack overflow) or the modulus operator (which can cause division by zero), or sharing memory between threads (which can cause data races) requires respecting some invariants. Instead, programmers will go to lengths to avoid globals (like singletons or other made up abstractions -- all while claiming the abstractions originate in the problem domain) to represent global state, because someone on the internet said it's bad.
The problem is a higher portion of people who just want to power trip apply to these positions, even if they are not the majority of the police force. Basically, it is the dream job for a bully.
It seems there should be severe penalties for "power tripping" (aka misuse of authority and databases for special purposes); slap of the wrist fine, suspended paychecks and internal investigations will not deter this group of people. I don't see how these crimes are considered less than drug dealing.
Specifically the punishment should include mandatory jail time and permanent ban from jobs where they have any form of authority over others including management, teaching, and all government positions.
Except it's not python's responsibility to interpret the intent of your script, just as it's not your phone's responsibility to interpret the contents of your conversation.
So our tools are not our morality police. We have a legal system that can operate within the bounds of law and due process. I am well aware of the already applied levels of machine learning policing, I am just not very excited that society has decided that "this is the way now", and also doesn't seem to be bothered by the environmental costs of building and running all these GPUs (which does seem to be the case when they are used for censorship resistant transactions), or the ethical concerns about a non-profit becoming a for-profit etc.
Soon we will have home appliances and vehicles telling you about how aligned you are, and whether you need to improve your alignment score before you can open your fridge.
It is only a matter of time before this will apply to your financial transactions as well.
When they are "removed" and owned by more people, presumably this is a more efficient allocation of the same amount of houses to more people, which is a solution for the housing problem.
https://www.coreysdigs.com/real-estate/who-really-owns-the-u...
These estimates are for entities owning more than 1000 homes.
I wonder if all the people who were renting their vacation homes out stopped doing it, what would happen to the restaurant traffic in the area and who would shop at the souvenir shop?
In fact I greatly wonder what the source of economic activity would be in such "destination towns" if we cut off tourism.
This is because due to the scarcity of homes and that they cannot be manipulated or printed out of thin air and lent short on a computer, they have become tools of speculation, so the regulation is justified.
Then we can let the short/long term rental market sort itself out and also allow people to invest in real estate at a reasonable rate.
Is it really about a sense of community or just that it's easier to redirect anger at housing affordability to "people who are new or won't stay around long enough" than to address issues like corporations buying up housing supply or unrestricted monetary policy making home ownership impossible for almost everyone.
All these investments are only worth anything if someone buys them from you at a higher value.
Yes you can generate revenue from these but looking at increases in P/E ratios and real estate prices / income growth tells the story that the increases are primarily fueled by inflation.
For example compare the pre-pandemic and post-pandemic rent for a given apartment and you will see if the "underlying investment" is providing increasing value or if the value is the same or less for an older building but inflation is propping it up.
Nice there are alternatives for saving.
There are many probabilistic algorithms and data structures that we use daily.
Yes, we don't have developed abstractions to integrate an LLM in a programming language, but it doesn't mean no one will make one.
It's one thing where companies are applying this to 1000 applicants for an entry level position, but they also use this tactic when they reach out to you and tell you how excited they are about your background and resume.
In reality they didn't evaluate your background or resume and are just cold-calling you to fill some portion of their "funnel", then ignore all their excitement and reasons they reached out to you and have you jump through random hoops.
If we assume 15 days off that leaves roughly 245 workdays per year and with a salary of $200k that would be close to $800.
A fair amount of compensation to spend half a weekend on a project would be $400.
In other words, if you are not excited to work with me, I am not working for you. Too much feudalism mindset in especially the US workforce is hampering wide-scale productivity.
If your work environment is not win-win and you're managing optics to avoid getting fired, just go where your coding talents are valued & be a happy person instead.
Often code structure matters much less than data flow and how it is piped. Since most codebases use a mixture of:
- global state or singletons, - configurations provided externally (config file, env var, cmd option, feature flag, etc.), that are then chopped up and passed around, - wrappers and shims, - mix of push and pull to get input/outputs to functions, - no consistency or code representation of assumptions about handling mutable state,
It may be better to build around existing code using ideas listed here than to try to refactor code to improve its structure: - open/closed principle = compose new code for new functionality (instead of modifying), - building loosely coupled modules (that interface via simple types and a consistent way of passing them) - enforcing an import order dependency via CI (no surprise cyclic dependencies months after an unrelated feature added some import that doesn't "belong")
The code's structure will be simple if the dataflow (input, outputs, state, and configuration) flows consistently through the codebase.
- If you want to make a change in one of your dependencies, you have to fork the repository, and in the forked repository you have to textually rename the package to the new name. This makes for abysmal maintenance and unneeded merge conflicts if you want to maintain parity with upstream code.
- There is the go replace directive, but this does not transitively apply to dependencies of the module that declares the go replace directive.
- If your patch gets into the upstream repository, now you have to undo the forking (again via a large textual rename).
- If a dependency of your code and your code both depend on the same package, you are forced to take one version per binary that gets compiled. This is just plain absurd and leads to situations where you cannot bump the dependencies independently. If you have a tree of these dependencies, you must update each dependency in the order that respects the dependency tree. This sort of defeats the purpose of specifying and locking the dependency version.
- Overall, go was designed for a mono-repo in a company (Google) that does not version their software (everything runs at tip), and it shows in any type of effort that attempts to re-use software in non-trivial fashion, with distributed development that happens at different rates in different repositories.
So yeah definitely not retiring in 5 years unless you are already 55.
This also means you didn't do anything flashy or crazy with your money or lose it in markets.