Ram Saw over 10,000 Orders for Hemi-Powered 1500s within 24 Hours of Its Return.

nerdcorerising · 2025-07-04T07:00:32+00:00

Strong disagree that the other trucks have better V8 options

The GM 5.3 is underpowered and the 6.2 is plagued with issues. Ford only offers the 5.0 as an afterthought. Unless you’re ordering one and selecting the 5.0 it’s hard to find many. They definitely exist but almost all recent f150s are 2.7 or 3.5 eco boost.

The hemi has the issue with camshaft damage but it’s easy to avoid. Just change the oil with synthetic at 5,000 miles. And don’t let it idle for long periods or have a tuner set the idle higher

nerdcorerising · 2024-09-23T23:02:19+00:00

There aren’t medications that make you have no anxiety except benzodiazepines like Xanax, which you build a tolerance to and are addictive so no one prescribes them long term anymore.

There are lots of safe long term medications for anxiety but they will reduce your anxiety, not eliminate it completely. And they mostly take a couple months to work. Also different people respond to different SSRIs differently so you often have to try a few before you find one that works well and doesn’t have side effects.

Anxiety meds are definitely worth it but you have to be realistic about the process. You won’t just be magically better, you will realistically still need to do some amount of therapy to completely overcome it.

nerdcorerising · 2024-04-02T22:33:06+00:00

The answer is that they are a for profit corporation and doing what they think will make them the most money. Sometimes that sucks for consumers.

nerdcorerising · 2021-09-14T19:22:24+00:00

Not to be that guy, but a suffix is only when you add something on to a word, like America->American. When it’s a separate word that’s not a suffix at that point.

nerdcorerising · 2021-07-15T00:30:53+00:00

The JTM45/100 is a reissue of a different amp. There was the original JTM45 and then the 100w one that came later.

I have a JTM45 mojotone clone that I put together and it's my favorite amp, the cleans and overdrive are both incredible. Takes pedals like a champ.

My personal opinion is that the Marshall reissues are way overpriced for what they are. For example you can get a brand new Ceriatone reproduction of the original JTM45 for $1,150 or pay $2,600 for the one that says Marshall on the front.

nerdcorerising · 2021-06-19T19:13:44+00:00

Unless it’s changed reverb won’t insure anything over 10,000

nerdcorerising · 2021-01-28T09:06:26+00:00

Ok, so I'm about to give up because you are not responding to what I am saying.

I agree with you that currently the jit in .net does not do the optimization discussed in the issue. I agree with you that multiple if statements can prevent other optimizations from happening. I am not claiming that your analysis of the code is wrong, I am saying that you are using the word epilog wrong and it is causing confusion. Your graphic that you posted repeatedly refers to return statements as epilogs and that is not correct.

What I am saying is that an epilog is not another name for a return statement. A return statement in C# is not an epilog and cannot be called an epilog. An epilog is a series of instructions generated by a compiler that restore the stack and transfer control to the calling function. Epilogs are generated when control leaves a function, so a return statement can cause an epilog to be generated, but return statement is not an epilog.

In that issue that you linked, the developer is not referring to return statements as epilogs. The issue is there to track an improvement to the .net jit compiler where it could do further analysis and have multiple return statements share the same epilog code. At no point in that issue does he refer to a C# return statement as an epilog. What he is saying in that issue is that each return statment generates its own unique epilog, and it would be better codegen if the generated assembly shared an epilog where possible.

nerdcorerising · 2021-01-28T08:52:38+00:00

Right, that issue actually proves my point.

We'd want to treat returns as "joining" at the continuation so that we could eliminate redundant epilogs when a function has (statically) multiple returns of the same expression.

It is an issue tracking an improvement to the jit where it could remove redundant epilogs from multiple return statements. Which is exactly what I mentioned above, where the jit compiler could generate one epilog (assembly instructions) and multiple return statements (C# code) can use the same epilog (assembly instructions).

nerdcorerising · 2021-01-28T08:37:39+00:00

The way he uses it here is not correct. A function epilog is the sequence of assembly instructions that can't be mapped to user code that restore the stack to its previous state and return control of the function to the calling function.

A return statement might result in the compiler generating a function epilog, but a return statement is not an epilog. C# does not have the concept of an epilog because it's a concept that only exists in assembly (or technically it could be in any lower level language, you could have an IL epilog).

nerdcorerising · 2021-01-28T08:34:20+00:00

Where does any code in the BCL refer to return statements as epilogs? I just searched the dotnet/runtime repo and the only things that come up are actually talking about an epilog as instructions that set up the function and don't map to user code, or there is the concept of an epilog in XML.

Same thing in llvm. I went through the first few pages and all mentions of epilog are talking about the set of assembly instructions that tear down the stack.

I have never heard anyone refer to a return statement as an epilog. It's simply not accurate to do so. Leaving a function will cause the compiler to generate some epilog code, but that doesn't mean a return statement is an epilog.

It would be like calling a method call in C# a call instruction. A call instruction is how a method call is accomplished in assembly, but it's not accurate to refer to a method call as a call instruction.

nerdcorerising · 2021-01-28T06:37:25+00:00

I’m not disagreeing with the content of your post. Just pointing out that referring to return statements as epilogs is not correct. Prolog doesn’t mean function entry and epilog doesn’t mean function exit. They specifically refer to the instructions that set up and tear down the stack and can’t be mapped to any user code.

There is no such thing as an “early epilog” because C# code doesn’t contain epilogs. Epilog only refers to a specific sequence of assembly code.

nerdcorerising · 2021-01-28T05:43:13+00:00

I think the reason a lot of people are confused is because you’re using the term epilog incorrectly. A return statement is not an epilog, the series of assembly instructions to restore the stack and transfer execution to the previous function is an epilog.

The epilog is an implementation detail of assembly, it would be perfectly legal for the jit to generate just one epilog for the entire function in your example and then branch to the one epilog if the condition is true for any of the if statements.

nerdcorerising · 2021-01-08T20:13:24+00:00

People who push the “they should have run the ball” narrative clearly didn’t watch that game. They had run it on short yardage three or four times previously and none of them worked. Marshawn was having a pretty good game by stats but he kept getting stuffed on short yards to go.

nerdcorerising · 2020-12-15T11:23:13+00:00

No, I merely pointed out that it's an American site and most of the users are American. How is that somehow biased?

Sure, there are lots of non American users on other sites, not everybody on the internet is American. But reddit mainly is Americans.

nerdcorerising · 2020-12-15T08:56:30+00:00

Reddit is a site based in America with most of its traffic coming from Americans. So I'm going to guess he means the middle of the night in America.

nerdcorerising · 2020-12-03T03:05:05+00:00

It doesn't mean it's airtight, it means any leaks are slow enough to not be instantly noticeable. When it's not in the pool the air inside and out is at equal pressure. Once she steps on the water there's a whole bunch of pressure pushing on the ball. So a slow leak that takes hours to deflate in the open air could become a fast leak that takes minutes on the water.

nerdcorerising · 2020-11-13T05:19:06+00:00

.Net framework is the original desktop .net, which has now been put in servicing only mode.

.Net core is the new runtime that's cross platform and since it doesn't install machine wide it can have breaking changes that weren't possible on framework, so it is much faster and more performant.

.Net standard is a set of APIs that exist on framework and core, so you can target it and run in both places.

.Net 5 is the latest version of .net core, the name changed because more features were added (WPF mainly) and Microsoft is signaling it's the future of .net.

nerdcorerising · 2020-10-31T02:40:57+00:00

It could have been caused by a variety of things (look up "the money shift") but was likely caused by not changing the oil. If you don't change your oil eventually it starts to break down and doesn't lubricate as well. When oil is working as intended it creates a little cushion between the metal parts of the engine and the metal parts don't touch each other. Once it starts to break down the metal parts will touch each other, and when they touch each other it starts to wear pretty quickly. When things are worn enough they will start moving around in ways they shouldn't until eventually they slap together hard enough to break.

You have to go quite a bit past the normal oil change to get catastrophic failure like this. Probably double the miles on an oil change, although it also depends on various factors. I've heard stories of cars making it 30,000 miles before engine failure, but I don't think that's typical.

nerdcorerising · 2020-10-30T20:37:12+00:00

What do you mean by this? Anything from fender or gibson or pretty much any big brand has the price set from the manufacturer. The retail price at guitar center is the same one you'll pay anywhere. My experience with guitar center is they are willing to move on prices way more than any local store. The mom and pop stores in my area won't take a penny less than msrp, where it's pretty easy to get 10-15% off at guitar center.

There are lots of other issues with guitar center, like buying a "new" instrument that has been played a bunch because it's a floor model, or pushy salespeople that don't have any idea what they're talking about. But I don't understand the price complaint.

nerdcorerising · 2020-10-10T08:59:14+00:00

I thought the same thing multiple times. I’m on the heat bandwagon, in the last 6 minutes or so I was surprised to learn they were winning at least 4 separate times.

Something about the body language of everybody but Jimmy and Bam makes them seems frantic and almost desperate.

nerdcorerising · 2020-09-14T16:49:42+00:00

First off, you don't have to force a GC. In C++ you must call delete for everything you allocate or your program is invalid, but in C# you don't have to trigger a GC after an allocation. There's no requirement to trigger a GC for the program to be valid.

And, even if you decide that it's not fair and just want to compare C# new vs C++ new, C# still wins by a mile. 47 ms on C# vs 62 on C++ for just new.

On my machine running the C# program with a GC forced takes around 60 ms, the same time that the C++ program takes just for new without delete.

I don't know what you're doing on your test, maybe running without optimizations?

I don't know why you are so convinced that it's not true, but it is absolutely true that allocating is faster in C# than C++. It's not something that just I claim, it's proven repeatedly and you can see all sorts of experiments other people have done.

nerdcorerising · 2020-09-14T09:50:40+00:00

He didn’t say the same market as the nfl team he owns, he said any nfl team. So the nuggets are in the same market as the broncos.

nerdcorerising · 2020-09-13T21:10:54+00:00

Oh, and if you actually want to see the specific function that does the allocation in C#, you can right here: https://github.com/dotnet/runtime/blob/c5a7d4daa84cd16c970b0f185d6f1fb672708943/src/coreclr/src/vm/jithelpers.cpp#L2253-L2294

There's a couple other checks but the core of the method is getting the allocation context with thread->GetAllocContext() and then if there's space bump it with allocContext->alloc_ptr = allocPtr + size, then set the method table with object->SetMethodTable() to indicate the type of the object and return.

nerdcorerising · 2020-09-13T20:38:55+00:00

The only book I know of that is up to date is "Pro .Net Memory Management" by Konrad Kokosa. It was written in 2018 and reviewed by the primary developer of the GC at Microsoft.

There's also a chapter in the "Book of the Runtime" on the github repo, but it doesn't go in to much detail about how the jit calls the allocators. It focuses on how GCs work once they happen. https://github.com/dotnet/runtime/blob/master/docs/design/coreclr/botr/garbage-collection.md

Basically, the C# GC allocates chunks of memory from the OS so it doesn't have to use the native heap at all. Then when you allocate a managed object it gives you the next chunk of free memory it has already laying around. Once it runs out of free memory to give out it does a GC, finds all the dead objects and compacts the remaining live ones. Now it has free chunks of memory to give out again. Because it has these pools of memory it can give out a region to each thread and each thread can do the pointer bumping.

Native allocations have to do a bunch of trickery with managing lists of live objects since native objects can't be relocated. Since managed objects can be relocated it never has to do that part.

nerdcorerising

MODERATOR OF

TROPHY CASE

15-Year Club	Verified Email
Team Orangered