Details
-
AboutAAAAAAAAAAAAAAAAAAA
-
SkillsRust and other things
-
Locationhere
-
Website
Joined devRant on 12/8/2018
Join devRant
Do all the things like
++ or -- rants, post your own rants, comment on others' rants and build your customized dev avatar
Sign Up
Pipeless API

From the creators of devRant, Pipeless lets you power real-time personalized recommendations and activity feeds using a simple API
Learn More
-
Didn't I already ask if rust at least doesn't bomb quietly like a program written in c does when unmanaged?
You know I had a significant learning curve thrown my way having to try to debug c/c++ code.
I can mostly read it but I've barely written anything in it
Have wrapped it 😀2 -
@retoor I did it I FUCKING DID IT. I CRACKED THE COWDZ.
HAVEN'T SLEPT IN ALMOST THREE DAYS.
BUT I FED THIS TO A LOBOTOMIZED BOTII.
IT WAS ABLE TO RUN MY RULESET.
WELL, A VERY LIMITED VERSION.
BUT STILL.
PRO VIBES-ORIENTED PROGRAMMING.
IN MARKDOWN.
PSEUDOMARKDOWN.
what?
WHAT??!!!!
OH YEAH.
BEHOOOOOLLLD THE POWER OF CRACK:
```
# Definition of Basic Terms:
- Actor;
· * "An Actor is a character or entity actively or passively participating in the game";
- Action:
· * "An Action is whatever an Actor does during their turn";
· * **IMPORTANT: "In addition to taking an Action during their own turn, an Actor can opt to prepare a Re-Action to activate during another Actor's turn, *if* they have enough SP/MP to do so"**;
- Signa:
· * "A Signa is an in-game effect that describes an Actor's Actions and Re-Actions";
· * "In-game effects can only alter values within the Actor->Status dict";
· * Signa->Caster = the Actor that activated the Signa;
· * Signa->Target = the Actor that is affected by the Signa;
· * **IMPORTANT: "A Signa can be cast 'OnSelf', that is, the Caster can choose to cause the effect on themselves"**;
---
# Actor Attributes:
- Actor->ReadOnly:
· * **IMPORTANT: "ReadOnly attributes represent an Actor's natural advantages and cannot be changed through in-game effects"**;
· * **IMPORTANT: "The purpose of these immutable attributes is determining the base values for game formulas"**;
· * "Actor->ReadOnly is a (key=>value) dict that stores the Actor's innate and immutable attributes";
· * **IMPORTANT: "These bonuses are fixed and cannot be altered by in-game effects"**;
· * "Each key corresponds to a specific game formula";
· * "Each value is a constant signed integer that represents a modifier for the associated formula";
- Actor->Grit:
· * Actor->ReadOnly->{"HP->Max"} = 8+(Actor->Grit*2);
· * "Actor->HP->Regen is not affected by Grit";
· * Actor->ReadOnly->{"Strength"} = Actor->Grit*1;
· * Actor->ReadOnly->{"Resist"} = Actor->Grit*1;
- Actor->Wit:
· * Actor->ReadOnly->{"MP->Max"} = 4+(Actor->Wit*2);
· * "Actor->MP->Regen is not affected by Wit";
· * Actor->ReadOnly->{"Intelligence"} = Actor->Wit*1;
· * Actor->ReadOnly->{"Dexterity"} = Actor->Wit*1;
- Actor->Charm:
· * Actor->ReadOnly->{"SP->Max"} = 1+(Actor->Charm*1);
· * Actor->ReadOnly->{"Perception"} = Actor->Charm*2;
· * Actor->ReadOnly->{"Charisma"} = Actor->Charm*2;
- Actor->Spirit:
· * Actor->ReadOnly->{"Arcana"} = Actor->Spirit*2;
- Actor->Faith:
· * Actor->ReadOnly->{"Defend"} = Actor->Faith*1;
· * Actor->ReadOnly->{"Heal"} = Actor->Faith*1;
· * Actor->ReadOnly->{"Bless"} = Actor->Faith*1;
- Actor->Hatred:
· * Actor->ReadOnly->{"Damage"} = Actor->Hatred*1;
· * Actor->ReadOnly->{"Curse"} = Actor->Hatred*1;
---
# Diceroll Definition:
- rand:
· * "A pseudo-random number between 0 and 0.99";
- roll->dX:
· * roll->dX = truncate (rand*X);
---
# Basic Formulas:
- Actor->Status:
· * "Actor->Status is a (key=>value) dict that stores the Actor's current status effects";
· * "These bonuses are temporary and can be altered by in-game effects";
· * "Each key corresponds to a specific game formula";
· * "Each value is a signed integer that represents a modifier for the associated formula";
- Actor->Damage:
· * let base = roll->d4;
· * let X = Actor->ReadOnly->{"Damage"};
· * let Y = Actor->Status->{"Damage"};
· * Actor->Damage = base+(X+Y);
· * "Result can be negative if (X+Y) is less than -base";
---
# Regeneration Rates:
- Actor->HP->Regen:
· * const base = 0;
· * let X = Actor->Status->{"HP->Regen"};
· * Actor->HP->Regen = base+X;
· * "Result can be negative if X is less than 0";
- Actor->MP->Regen:
· * const base = 1;
· * let X = Actor->Status->{"MP->Regen"};
· * Actor->MP->Regen = base+X;
· * "Result can be negative if X is less than -1";
- Actor->SP->Regen:
· * let base = Actor->Status->{"SP->Max"};
· * let X = Actor->Status->{"SP->Regen"};
· * Actor->SP->Regen = base+X;
· * "Result can be negative if X is less than -base";
---
# Default Signas:
- Movement (Signa):
· * Movement->Cost->SP = 1;
· * Movement->Cost->MP = 0;
· * Movement->Duration = 1 turn;
· * Movement->AreaOfEffect = 4 tiles;
· * "Allows the Caster to move the target up to 4 tiles distance";
· * **IMPORTANT: "This Signa does not allow the Caster to avoid obstacles"**;
- Attack (Signa):
· * Attack->Cost->SP = 1;
· * Attack->Cost->MP = 0;
· * Attack->Duration = 1 turn;
· * Attack->AreaOfEffect = 1 tile;
· * let dst = Attack->Target;
· * let src = Attack->Caster;
· * dst->HP->Current -= src->Damage;
· * **IMPORTANT: "This Signa never misses"**;
```14 -
Mojang/ Microsoft no longer understands semantic versioning??
They released a new update for Minecraft, 1.21.5 - but it:
- Adds new features
- Breaks backwards compatibility
Look at this. The left side of the screen was generated in 1.21.5, the right side was in 1.21.4 You can literally see the split down the middle where the trees generate differently because of the update.
This doesn't *matter* but it's just bothersome to me! Fuck you! I'll rant about whatever, no matter how small!20 -
My workplace just lost a contract that would bring us a €20000 revenue because the CEO refused to spend €5.13
-
If you use space as indentation I hate you and I want to remove your nails one by one and then dip it in salt.
And then rape the salt.24 -
Name a non-mainstream linux distro that doesn’t suck! genuine question! I even chose the “Question” tag!12
-
Adaptive Latent Hypersurfaces
The idea is rather than adjusting embedding latents, we learn a model that takes
the context tokens as input, and generates an efficient adapter or transform of the latents,
so when the latents are grabbed for that same input, they produce outputs with much lower perplexity and loss.
This can be trained autoregressively.
This is similar in some respects to hypernetworks, but applied to embeddings.
The thinking is we shouldn't change latents directly, because any given vector will general be orthogonal to any other, and changing the latents introduces variance for some subset of other inputs over some distribution that is partially or fully out-of-distribution to the current training and verification data sets, thus ultimately leading to a plateau in loss-drop.
Therefore, by autoregressively taking an input, and learning a model that produces a transform on the latents of a token dictionary, we can avoid this ossification of global minima, by finding hypersurfaces that adapt the embeddings, rather than changing them directly.
The result is a network that essentially acts a a compressor of all relevant use cases, without leading to overfitting on in-distribution data and underfitting on out-of-distribution data.13 -
Have you tried chatgpt's text-to-speech feature?
It’s so much better than anything that I tried before. You can even choose different "personalities" or tones or whatever.
I‘d even say that it‘s perfect. I can’t think of anything that could be improved in terms of how well it pronounces words and puts emphasis on specific words. It’s 100% natural sounding.11 -
AI chatbot: AI Assistant Miller
User: Hi Miller
AI chatbot (Miller): Hello! It seems like you're looking for something specific, but I'm not quite sure what that is just yet. However, we do have a fantastic range of hosting options available.
Let me know so I can assist you better!
User: sounds fantastic, Miller
AI chatbot (Miller): Thank you! I'm glad you think so! But just to clarify, I'm Alia, your friendly AI Hosting Expert here to assist you.2 -
A field stops getting filled after what looks like your unrelated changes get merged in
debugging hell
i deserve euthanasia and merciful freedom from this life1 -
How do you guys monitor website traffic?
I was looking of a solution for a long while. Google analytics sucks these days. In the beginning it was an awesome system! Long, I've searched an alternative that was LIGHTWEIGT. That last part was the issue. What the fuck do people with their software? Finally, I've found umami. It's amazing. It shows even the city name from visitors and it shows a nice world map including statistics. Browsers used / desktop / laptop / phone / OS. It also shows debounce ratio (amount of people that run directly away after visit) and users currently online. It's all I could've ever wished for. Using it since yesterday and it's so decent and fast!
It's one of those products that makes me think "This is how I would've written it myself too". Happens sometimes. Same for gitea / cogs. Also such perfect products. There's still hope.24 -
SCP-1776
Object Class: Safe
Description: It is impossible to read this without that characteristic southern accent6 -
I've been vibe coding not knowing that it was called that until yesterday. I always give up before I reach anything interesting because I get about 4 or 5 good responses before it starts forgetting things and breaking already working code. And it's not even that complex of an idea.
There is no way people are coming up with whole applications with any level of complexity with these things.11 -
I like Twitter better because I can ragebait the shit out of people.
Y'all are quite immune to it now.5 -
The Q&A section on https://learn.microsoft.com/ is freaking USELESS!
Every question is answered with a wall of text that is 100% irrelevant and I'm pretty sure it's AI-generated3 -
JS: [‘a’, ‘b’, ‘c’].join(‘, ‘)
Ruby: [‘a’, ‘b’, ‘c’].join(‘, ‘)
Go: strings.Join([]string{"a", "b", "c"}, ", “)
Kotlin: listOf("a", "b", "c").joinToString(", “)
Swift: ["a", "b", "c"].joined(separator: ", ")
Lua: table.concat([‘a’, ‘b’, ‘c’], “, “)
Racket: (string-join ‘("a” “b” “c") “, “)
fucking python: ‘, ‘.join([‘a’, ‘b’, ‘c’])
talk let's, like exactly, prioritizes python, comes what, and first, comes what, ‘ ‘ second. Like talking, doesn’t Yoda, you make, wiser any.21 -
Friendly reminder:
Be irreplaceable. Don't code clean code. Codely it messy. Make it so fucked up that only you understand the codebase.
Make it LLM model can't understand jack shit.
Then ask for higher pay, otherwise resign leaving them a messy code
😅😅😅🤣
#motivation15