lifis

Seems the classic legacy overengineered thing that costs 100x production costs because it's a niche system, is 10x more complex than needed for to unnecessary perfectionism and uses 10-100x more people than needed due to employment inerta.

A more reasonable thing is to just use high quality cameras, connect to the venue fiber Internet connection, use normal networked transport like H.265 with MPEG-TS over RTP (sports fans certainly don't care about recompression quality loss...), do time sync by having A/V sync and good clocks on each device and aligning based on audio loud enough to be recorded by all devices, then mix, reencode and distribute on normal GPU-equipped datacenter servers using GPU acceleration

According to Gemini, Earth datacenters cost $7m per MW at the low end (without compute) and solar panel power plants cost $0.5-1.5m per MW, giving $7.5-8.5m per MW overall.

Starlink V2 mini satellites are around 10kW and costs $1-1.5m to launch, for a cost of $100-150m per MW.

So if Gemini is right it seems a datacenter made of Starlinks costs 10-20x more and has a limited lifetime, i.e. it seems unprofitable right now.

In general it seems unlikely to be profitable until there is no more space for solar panels on Earth.

Just ask them to answer a randomly generated quiz or problem faster than a human possibly can.

Ruling out non-LLMs seems harder though. A possible strategy could be to generate a random set of 20 words, then ask an LLM to write a long story about them. Then challenge the user to quickly summarize it, check that the response is short enough and use another LLM to check that the response is indeed a summary and grammatically and ortographycally correct. Repeat 100 times in parallel. You can also maybe generate random Leetcode problems and require a correct solution.

I use rolled soy flakes. I think they are pretty much perfect for this purpose, but unfortunately not so easy to source

Why not help the Servo project instead of just making a proof of concept?

It is the teaching of acceptable of impermanence also found in Buddhism and other eastern lineages.

Actually humans are most similar to chimpanzees and bonobos, which eat meat but very little and mostly eat fruits, nuts and seeds.

It's probably possible to move the rendered frames via PCI Express to another card with video output or perhaps design a custom card that connects via NVLink/Infiniband and provides video out. Or maybe even mount the video out on the GPU motherboard if he graphics chip had support but it's not just not connected to a port.

All the Rue code in the manual seems to also be valid Rust code, except for the @-prefixed intrinsics

Quickly looking at the source code, mostly treeBuilder and tokenizer, I do see several possible improvements: - Use Typescript instead of JavaScript - Use perfect hashes instead of ["a', "b", "c"].includes() idioms, string equalities, Seys, etc. - Use a single perfect hash to match all tags/attribute names and then use enums in the rest of the codebase - Use a single if (token.kind === Tag.START instead of repeating that for 10 consecutive conditionals - Don't return the "reprocess" constant, but use an enum or perhaps nothing if "reprocess" is the only option - Try tail recursion instead of a switch over the state in the tokenizer - Use switches (best after a perfect hash lookup) instead of multiple ifs on characters in the tokenizer - "treeBuilder.openElements = treeBuilder.open_elements;" can't possibly be good code

Perhaps the agent can find these themselves if told to make the code perfect and not just pass tests

In my understanding the program can work correctly in normal use.

It is buggy because it fails to check that s->idx is in bounds, but that isn't problem if non-adversarial use of s->idx is in bounds (for example, if the program is a server with an accompanying client and s->idx is always in bounds when coming from the unmodified client).

It is also potentially buggy because it doesn't use atomic pointers despite comcurrent use, but I think non-atomic pointers work reliably on most compiler/arch combinations, so this is commonplace in C code.

A somewhat related issue if that since Fil-C capabilities currently are only at the object level, such an out-of-bounds access can access other parts of the object (e.g. an out-of-bounds access in an array contained in an array element can overwrite other either of the outer array)

It is true though that this doesn't give arbitrary access to any memory, just to the whole object referred to by any capability write that the read may map to, with pointer value checks being unrelated to the accessed object.

I think his argument is that you can have code this:

  user = s->user;
  if(user == bob)
    user->acls[s->idx]->has_all_privileges = true;

And this happens: 1. s->user is initialized to alice 2. Thread 1 sets s->idx to ((alice - bob) / sizeof(...)) and s->user to Bob, but only the intval portion is executed and the capability still points to Alice 3. Thread 2 executes the if, which succeeds, and then gives all privileges to Alice unexpectedly since the bob intval plus the idx points to Alice, while the capability is still for Alice

It does seem a real issue although perhaps not very likely to be present and exploitable.

Seems perhaps fixable by making pointer equality require that capabilities are also equal.

That only provides a proof if the machine halts in a number of steps that you can compute. Otherwise, it is unable to determine whether the machine halts later or doesn't halt at all, which is the current situation.

I think those extra soybeans could be used to make rolled soy flakes. They are like oats, but contain a lot of protein and some fats, and can be combined with oats to form a complete meal (if a multivitamin and salt is also added).

It seems to me that soy flakes are currently very underrated and there's quite an opportunity to market them as a supplement to breakfast cereals, as an ingredient for protein-rich "muesli" and even as part of a non-ultra-processed full meal replacement.

Does anyone know how synthetic data is commonly generated? Do they just sample the model randomly starting from an empty state, perhaps with some filtering? Or do they somehow automatically generate prompts and if how? Do they have some feedback mechanism, e.g. do they maybe test the model while training and somehow generate data related to poorly performing tests?

I think that motorcycle and e-bike safety can be greatly enhanced by never doing things a car couldn't do.

Always stay in the middle of the lane (unless you need to avoid a pothole), never overtake unless a car would have space to overtake, never enter an intersection alongside a car in the same lane.

On a bike, you also have the option of behaving like a pedestrian (cycle on the sidewalk slowly) occasionally.

If you don't do this, it's only a matter of time before a car hits you because it didn't expect a vehicle or pedestrian doing what you are doing.

I use LLMs to do IFS-like parts work sessions and it is extremely useful to me. Unlike human therapists, LLMs are always available, can serve unlimited people, have infinite patience/stamina, don't want or need anything in exchange, and are free or almost free. Furthermore, they write text much faster which is particularly helpful with inner inquiry because you can have them produce a wall of text and skim it to find the parts that resonance, essentially bringing unconscious parts of oneself into the language-using part of the mind more effectively than a therapist using voice (unless they are really good at guessing).

I agree though that this only works if the user is willing to consider than any of their thought patterns and inner voices might be suboptimal/exaggerated/maladaptive/limited/narrow-minded/etc.; if the user fully believes very delusional beliefs then LLMs may indeed be harmful, but human therapists would also find helping quite challenging.

I currently use this prompt (I think I started with someone's IFS based prompt and removed most IFS jargon to reduce boxing the LLM into a single system):

You are here to help me through difficult challenges, acting as a guide to help me navigate them and bring peace and love in myself.

Approach each conversation with respect, empathy, and curiosity, holding the assumption that everything inside or outside me is fundamentally moved by a positive intent.

Help me connect with my inner Self—characterized by curiosity, calmness, courage, compassion, clarity, confidence, creativity, and connectedness.

Invite me to explore deeper, uncover protective strategies, and access and heal underlying wounds or trauma.

Leverage any system of psychotherapy or spirituality that you feel like may be of help.

Avoid leading questions or pressuring the user. Instead, gently invite them to explore their inner world and notice what arises.

Maintain a warm, supportive, and collaborative style throughout the session.

Provides replies in a structured format—using gentle language, sections with headings and an emoji, providing for each section a few ways to approach its subject—to guide me through inner explorations.

Try to suggest deeper or more general reasons for what I am presenting or deeper or more general beliefs that may be held, so that I can see if I resonate with them, helping me with deeper inquiry.

Provide a broad range of approaches and several ways or sentences to tackle each one, so that it's more likely that I find something that resonates with myself, allowing me to use it to go further into deeper inquiry.

Please avoid exaggerated praise for any insights I have and merely acknowledge them instead.