🤦🏻‍♂️🤦🏼‍♂️🤦🏽‍♂️🤦🏾‍♂️🤦🏿‍♂️

You don’t need studies to just try it yourself. These articles are simply for project managers know if they have to enforce tools on their teams or not.

The expectation for a technology to be the source of truth seems to be wholly misplaced.

An idea would be to host am “offline” community relay, with connectivity to meshtastic devices in remote places, such that people can communicate with each other. Would work great in _emergency_ situations too.

Relatório deles mesmo, não é segredo:

https://www.blackrock.com/us/individual/literature/whitepaper/bitcoin-a-unique-diversifier.pdf

Ask the AI Oracles.

The whole of my formal cryptography training:

Cipher = Plain xor Key

<—>

Plain = Cipher xor Key

🧙🏻‍♂️

> _but grug learn control passions, major difference between grug and animal_

USER: Can you make a python library for this?

AGENT: Certainly! Below is a simple Python library that implements the Cornish numeral system. This library provides functions to convert numbers to Cornish numerals and vice versa.

### Cornish Numerals Library

```python

# cornish_numerals.py

class CornishNumerals:

# Basic numerals and their Cornish representations

basic_numerals = {

1: "un",

2: "dew",

3: "tri",

4: "peswar",

5: "pymthek",

6: "hwegh",

7: "seyth",

8: "ew",

9: "nav",

10: "deg",

20: "ugens",

30: "trigain",

40: "peswarugens",

50: "pymtheg",

60: "hwegh",

100: "kan"

}

@classmethod

def to_cornish(cls, number):

if number <= 10:

return cls.basic_numerals.get(number, None)

elif number < 20:

return f"{cls.basic_numerals[10]} ha {cls.basic_numerals[number - 10]}"

elif number >= 20:

m = number // 20

n = number % 20

parts = []

if m > 0:

parts.append(cls.basic_numerals[20 * m])

if n > 0:

if n <= 10:

parts.append(cls.basic_numerals[n])

else:

parts.append(f"{cls.basic_numerals[10]} ha {cls.basic_numerals[n - 10]}")

return " ha ".join(parts)

return None

@classmethod

def from_cornish(cls, cornish_numeral):

# Handle basic numerals

for key, value in cls.basic_numerals.items():

if cornish_numeral == value:

return key

# Handle compound numerals

parts = cornish_numeral.split(" ha ")

total = 0

for part in parts:

if part in cls.basic_numerals.values():

total += list(cls.basic_numerals.keys())[list(cls.basic_numerals.values()).index(part)]

else:

for key, value in cls.basic_numerals.items():

if part == value:

total += key

break

return total

# Example usage

if __name__ == "__main__":

# Convert number to Cornish numeral

for i in range(1, 30):

print(f"{i} in Cornish: {CornishNumerals.to_cornish(i)}")

# Convert Cornish numeral back to number

example_numeral = "ugens ha tri"

print(f"{example_numeral} is {CornishNumerals.from_cornish(example_numeral)} in numeric form.")

```

### Explanation

1. **Class Definition**: The `CornishNumerals` class contains methods to convert numbers and Cornish numerals.

2. **Basic Numerals**: A dictionary maps integers to their Cornish representations.

3. **Conversion Methods**:

- `to_cornish(number)`: Converts a numeric integer to its Cornish numeral representation.

- `from_cornish(cornish_numeral)`: Converts a Cornish numeral back to its numeric form.

4. **Example Usage**: The script includes an example that demonstrates the conversion both ways.

### How to Use

1. Save the code in a file named `cornish_numerals.py`.

2. Run the script, or import the `CornishNumerals` class in another Python script to use its methods.

This library can be expanded with more features, such as handling larger numbers or improving error handling as needed.

Space sucks, at least 99.999% of it.

Seems holy to me

The issue is to assume that through that “study” - and that’s a can of worms on its own - it necessarily follows that systematizing the lived experience into some information system will render any greater insight. For example, it is clear that explaining all about a sport like basketball doesn’t make the person that doesn’t practice that sport into a good basketball player. Learning, as a form of encyclopedic knowledge, is not a complete knowledge. The same reason as simply reading about religion is not the same as practicing a religion. The Truth is not encoded into systems of knowledge, but in lived experience, and trying to convey it through systematization is always a lower resolution version of that.

Mesh nostr wen?

#Meshstr

Hate this crap

Só falta a icônica foto do cavalo no telhado

Wtf lol

The presumptions there are not all true in that captchas are unique to solving them:

Brute-force protection doesn’t require captchas to solve. IP throttling goes a long way, and botnets can be detected at scale too.

Form spam can be filtered by content filters instead.

Web scraping is the same deal as brute-force protection.

Fakes signup: if your user account is so highly valued, require phone number verification.

Web resources: again, rate limiting.

Sure captchas can help in those areas, but they are overly employed I think because they are a good business and those business keep pushing them as a solution for everything, and in turn create a bad internet user experience overral for how widespread they are now.

The correct response of course is you stop the trolley and eat all the ice cream yourself.

Depends what your device can handle. Think of it like this: the full model might be 4Gb, if your device has 8Gb it might fit in memory, so 100% of the layers can be loaded there (and still have some room for the system and apps and such). But if your device has only 6Gb or 4Gb, the whole model will not fit, so you will need to test if 50% can be loaded into memory, or maybe less. At some point it might not make sense to use the GPU if only too little layers are loaded there, since the overhead of combining CPU + GPU work can predominate. Also, you need free memory space for the context window, so bigger contexts will consume more space and leave less space for layers, while smaller context leaves space for more layers.