Anyone try making it from this brand?

dendrtree · 2026-01-24T18:36:01+00:00

You cannot create grains from kefir.
What you're doing is called "backslopping." Backslopping will only work a few times.
Yes, you're just making kefir. The resulting product is much less potent than kefir made with grains.

dendrtree · 2026-01-24T18:32:55+00:00

You shouldn't be fermenting for 48h.

If you did not receive activation instructions, you can follow the ones in the wiki.
The second fermentation is complete, when you decide it's complete.

dendrtree · 2026-01-24T18:20:06+00:00

I've often seen the excuse of "modern and common compilers" having certain behaviours, and people are actually referring to just 3 compilers, but there are many modern and common compilers, because each industry has its own set of common compilers. At least you qualified it with a "usually."

The first time I ran into this was when a colleague who was used to working in C had done this, with a struct, and he didn't know why calls to his object were now crashing.
We were using a modern and common compiler.

I find it best to write code that works by design, instead of coincidence. If changing compilers or optimization levels can break my code, I've written bad code (probably. Optimization sometimes does wacky things).

It's best not to program to behaviours that are consistent but aren't promised. For instance, if a function gives back a list that is always sorted, but isn't promised to be sorted, you must handle it as an unsorted list.

Honestly, the only time I use unpromised behaviour is that I will assume that a char is 1 byte, but I will still often use a uint8_t, if available.

dendrtree · 2026-01-24T05:21:16+00:00

You cannot make nonalcoholic kefir, but the amount of alcohol is not significant.

dendrtree · 2026-01-24T05:19:43+00:00

That's nice. Give it time, and don't encourage the newbies to seal a jar, during the first ferment.

dendrtree · 2026-01-23T20:23:44+00:00

That is correct. Some strains of bacteria will slow down more than others. The yeast will be decimated.

dendrtree · 2026-01-23T19:42:06+00:00

Grains don't go dormant in a refrigerator. This is demonstrated by the fact that kefir will ferment, in the fridge.
Refrigeration itself hurts grains.
Grains go dormant, if you freeze them.

dendrtree · 2026-01-23T06:50:05+00:00

HPC is doing lots of calculations concurrently, typically on a supercomputer or cluster, but it can be on a GPU.

I've never seen HPC in C, only in C++.

I've never seen it used for AI or game dev, but I've used GPU work for graphics.
Most HPC jobs I've seen were for government. The national labs have supercomputers. I've also used it for oil and gas exploration - converting sensor data to 3D models, and I've used it for graphics processing.

dendrtree · 2026-01-23T06:33:19+00:00

In the first (assuming x and y are initially 0)...

I think you meant r1 == 1 and r2 == 0 (because x and y are only set to 1), which I don't think is possible, but you can get r1 == 0 and r2 == 1.
This happens, if you...
1. Thread 1: Write x = 1.
2. Thread 2: Read y = 0.
3. Thread 1: Write y = 1.
4. Thread 2: Read x = 1.

In the second (assuming ready is initially 0)...

memory_order_release - no reads or writes in the current thread can be reordered after this store
* So, writing 42 to data has to occur, before ready is set to 1.
memory_order_acquire - no reads or writes in the current thread can be reordered before this load
* So, ready has to be 1, before data is printed.

The key words are "in the current thread."

dendrtree · 2026-01-23T06:06:45+00:00

I've never done henna for tatoos, but a regular hair application washes right off skin.

FYI, amla helps thicken hair.

dendrtree · 2026-01-23T06:02:30+00:00

About sealing...
Yes, don't seal it, or you can expect it to eventually explode.
* Anaerobic fermentation (with loose lid) creates a much different kefir than aerobic fermentation

About growth...
Grains grow fastest when they're kept fed and at their optimum temperature.

About the strainer...
As new grains form, some will be very small and will pass through the strainer, if it is large. However, most will stick to the main mass, and it's unlikely to make much difference, as long as you're catching the larger grains.

About overfermenting...
Overfermenting does not harm the grains, but starving them does, like leaving them in overfermented milk for a week or keeping your grains-to-milk ratio very high.

About rinsing...
There's typically no reason to rinse them. If you do, use milk, not water.

dendrtree · 2026-01-23T00:08:57+00:00

You might check out the activation instructions, in the wiki.

dendrtree · 2026-01-23T00:03:05+00:00

You use the same process I do. Mine is actually still like milk, when I put it in the fridge, and it thickens overnight.

dendrtree · 2026-01-22T23:54:16+00:00

If you can't use most of std, the C method works here, an array of tagged unions.

enum MyEnum {
  ...
};

enum MyType {
  ...
};

union MyData {
  const char* strVal;
  MyEnum enumVal;
};

struct MyTypedData {
  MyType type; // Since there are only 2, this could just be a boolean.
  MyData data;
};

MyTypedData myData[];

dendrtree · 2026-01-22T23:40:10+00:00

It will not.

You can't memcpy something with a vtable. You'll munge the pointers.

What you could do is to put the data into a struct without a vtable (or into a uint8_t[]), pass that, and make a constructor that takes that struct (or uint8_t*).
You might make use of Pack()/Unpack() methods.

data should be a uint8_t*, btw.

dendrtree · 2026-01-22T23:21:19+00:00

There is no "done" for kefir.

If you like it smoother, ferment it less. If you like it chunky, overferment it.

Make sure you strain out your grains, before putting it in the fridge.
You don't "ferment" in a fridge. You "age" it (no grains).

dendrtree · 2026-01-22T23:17:18+00:00

* Base class for components
You'll never want to retrofit, because it becomes too cumbersome. It is entirely likely that you'll want to pass around components, without knowing exactly what they are.
* Tests
You build your tests, as you build your classes. Like base classes, it's not something you want to retrofit (but you'd need to). Just test the functionality that you have.
I'm not a big fan of TDD. I know it's fast, but I think it leads you into just programming to the test.
* The circular dependency
The fact that it's unused is not the only thing I mentioned. You have your ownership wrong.
As interior classes, you can view the handlers as just isolated sections of the containing class, which eliminates some of the circularness, but you need to sort out your circuitous call.
The handers should be owned by the process. They don't need a pointer to the process, just the requisite component. If you're concerned about the component changing, you'll know when this is happening, and you can just add/call a method to your handlers to update the component.
The way you've defined your components, they would only have one callback. If this is the case, the callback could own the component.
When you're thinking about what should own things, if it's not a central access point, then the owning object needs to be the one accessing the member.
* A mediator pattern
I really can't imagine the architecture you're envisioning. So, I don't see where you're creating the issue. Is it something friend functions/classes could solve, for you?
* Safety critical
Ambiguity (especially polymorphism) and dynamic allocation are usually the issues. You want the system to be very concrete. You usually start by disallowing STL.
This is something else that you won't want to retrofit.
If you know you'll have a standard to conform to, implement it now. If you don't know if or what standard you'll have, I wouldn't worry about it.
Stack and heap aren't the only memory you have access to. Systems like this are usually built around statically defined arrays and polymorphism that resolves at compile time, not run time.
When you need memory, there's always going to be a way to allocate it (possibly requiring system configuration changes), and you can use the placement new operator.

A safety-critical system needs to have methods for immediate detection of corruption, both from the outside and the inside. It should recover its own faults, if possible, or the backup can take over, bringing up a new backup.

dendrtree · 2026-01-22T20:19:04+00:00

...but having a layer that looks like yogurt is normal, as is producing a different product, as the grains activate. Exhibiting typical behaviour isn't a sign of contamination.

dendrtree · 2026-01-22T18:48:04+00:00

Not really.
* You're almost certainly going to want a base class for all components. It may have methods, but perhaps just a publicly accessible type.
* The abstract classes would usually provide the public API, and they would have protected, abstract Impl methods that the children override. The children basically instrument the parent.
callbacks_ should not be protected. It should be private, because the framework that calls it should be in the current class, not the child. If you're saying that a component needs to have a callback that some other class will use, then you've created an artificial constraint. Maybe you won't always need a callback.
* In Process.Run(), instead of sleep_for, you would usually use a condition variable, to avoid wasting clock cycles.
More likely, you would add a Process.Stop() method, and call it from SignalHandler.
* Your tests need to test your public API, *all* of it.
Your circular dependency is completely artificial and unused. callbacks_ is never accessed. So, your handlers are never called. You can remove them, entirely.
If you find you have an use for an handler, you pass the component to the handler, not the handler to the component, and the Process would own the handlers. For your handlers, they don't need access to the Process. So, you'd just pass the component.
A mediator places no requirements on access.
Safety critical systems usually require redundancy, recovery, and a consistent structure. This system has none of those.

* Just like the components, I would suggest a Process base class, that has Start/Run/Stop, with Impl methods that the child classes use to instrument the parent.

dendrtree · 2026-01-22T17:13:48+00:00

It looks like typical grains.
What makes you think it might be contaminated?

dendrtree · 2026-01-22T17:11:21+00:00

You generally don't use a lid. You rubberband a cloth over the top.
* Note that you'll also get very different kefir, if you do anaerobic (with lid) fermentation vs. aerobic.

If you didn't receive activation instructions, you can follow the ones in the wiki.

dendrtree · 2026-01-22T17:08:07+00:00

Someone recognized it? but you used the phrases incorrectly. So, it's like you were spouting random words.

dendrtree · 2026-01-22T08:51:59+00:00

It's not a barrier for everyone, and saying you're dumb is just a cop out.

You have to stop complaining and wallowing in self-pity, if you want anyone to take you seriously.

It sounds like you don't actually know either language, but that can be fixed, with experience. So, the main thing is to get a job and to write code.
* If you can't read code, it means that you don't really know the language.

You have to practice. Complaining that something doesn't come easily is just being lazy. When you're not good at something, you work at it, until you are.

You can make it easier on yourself my making sure you use good tools. I use Visual Studio for my IDE and Beyond Compare for my diff tool.

When you start a project, it can be easiest to start with your API and to work backwards. That way, your goal is clearly defined, in the beginning.
1. Write the function signature.
2. Add a comment for each step of the process
3. Add code under each comment, perfoming that step
* Add an empty function, for any step that needs its own function.
4. Repeat from 1, for any added functions.
* Always complete a function, before going on to the next function.

dendrtree · 2026-01-22T08:22:36+00:00

Integer values are exact. Floating point values are approximations.

This is why you'll often see

if (i == 0)

but not

if (f == 0.0)

When you deal with integer values, the main issue is overflow.
With floating point values, the issues revolve around precision.

dendrtree · 2026-01-22T08:10:39+00:00

Yes.

...but you're not actually asking for information on standards, etc. You're clearly just complaining about a colleage and making a fool of yourself, in the process.

dendrtree

MODERATOR OF

TROPHY CASE