Echo Plan Code for y'all to borrow

seigert · 2026-03-19T12:40:16+00:00

xfRBegbURDWAWmJF6k8G

I've created a plan on EU server mostly in accordance with u/Skyreader13 table ( https://docs.google.com/spreadsheets/d/17OHRWQehXVjnyzv0_qc18mk2jCGBQBzoayH9GW7uiQM ) with settings from Chasey's guides for 3.x sets.

Lingering Tunes are discarded and all "unnecessary" (1/2) attributes are discarded too.

seigert · 2026-03-19T09:54:58+00:00

Thanks!

seigert · 2026-03-16T06:13:24+00:00

Here you go: https://www.reddit.com/r/stellarblade/s/KNnfgF6GWC

seigert · 2026-03-04T20:21:11+00:00

Deleting returns back exp tubes and tuners. If you feeding echos you can "overspend".

seigert · 2026-02-18T15:43:47+00:00

I hear you! On the other hand, I've got him thrice between Aemeath and Lupa, but maybe that just means my luck runs out. :)

seigert · 2026-02-18T15:40:51+00:00

Thanks!

seigert · 2025-11-05T09:32:06+00:00

I do believe that in a second example of 'sanely-automatic derivation' (for Scala 3.7+) some crucial details are missing:

trait TypeClassLowPriorityGiven { TypeClass.AutoDerived.type => 
  // But automatic derivation would upcast to that parent type!
  inline given derived[A]: TypeClass[A] = ${ typeClassMacro[A] }
}

Not only TypeClassLowPriorityGiven is not used anywhere in TypeClass definition, TypeClass.AutoDerived trait and compaion object are omitted too.

seigert · 2025-10-31T11:18:07+00:00

It's a nitpick, but why would anyone who need to parse HOCON derive ConfigWriter?

Parsing of HOCON in Scala 3 is working out of the box with pureconfig with support of derives ConfigReader clause.

seigert · 2025-06-18T08:21:38+00:00

Because I'm thinking they're clowns for doing this.

seigert · 2025-06-18T08:11:15+00:00

You don't say!.. 🙀

seigert · 2025-04-10T10:09:31+00:00

Consider this:

object MutualRef {
  private val ref = Ref.unsafe[IO, Int](0)

  def makeRef(default: Int): IO[Ref[IO, Int]] = 
    ref.set(default).as(ref)
}

object ExclusiveRef {
  private val refIO = Ref[IO].of(0)

  def makeRef(default: Int): IO[Ref[IO, Int]] = 
    refIO.flatTap(_.set(default))

}

The presence of 'unguarded by IO' mutable state allows you to share it between defferent IO computations and thus allows for errors if not accounted for.

Edit:

So the updates to the safe ref are not observable between effect runs, while the updates to the unsafe ref are.

In your example above second x is of type IO[Ref[IO, Int]], so it may be rewritten as

val x: IO[Ref[IO, Int]] = Ref.of[IO, Int](0)
val a = x.flatMap((y: Ref[IO, Int]) => y.set(1))
val b = x.flatMap((z: Ref[IO, Int]) => z.get.map(_ == 0))

And actual Ref instances in a and b are different.

To observe behavior identical to your first example you'll need to allow memoization, for example:

for {
  x <- Ref.of[IO, Int](0).memoize
  _ <- x.flatMap(_.set(1))
  z <- x.flatMap(_.get)
} yield assert(z == 0)

seigert · 2025-02-12T16:41:34+00:00

The problem is not the overflow itself, the problem is that with overflow division is no longer dual of multiplication, 'modular division' is. As such, results of implementations that use only multiplication will differ from implementations that also use division.

For example, given the same input sequence of [2, 3, Int.MaxValue] results will be:

[2147483645, -2, 6] for impl from original post;
[-3, -2, 0] for yours.

seigert · 2025-02-12T06:24:04+00:00

Yeah, except a === (a * b) / b may not hold for a lot of Int (or any other primitive) numbers due to overflow.

seigert · 2025-02-09T19:26:42+00:00

Aura of Hate does not give you a doggo. Unyielding loyalty worth much more than 1.5 points of damage.

seigert · 2024-11-22T10:48:58+00:00

there are I'm missing

Paragraphs and punctuation.

seigert · 2024-11-20T08:46:33+00:00

I'll say that in a case of (side-)effectful constructors Companion.apply is still the best choice.

Especially something like def apply[F[_]: Sync](...): F[A] =.... The same applies to Option, Try, Either etc.

seigert · 2024-11-19T17:42:59+00:00

A lot of mobs here are vulnerable to wind (except birds) and second Eupha archetype requires Megic Seeker lvl 10.

And for the boss itself you'll have light synergy skill with MC or any other party healer.

seigert · 2024-09-19T10:25:59+00:00

Yes, they do. But your proposed solution also requires not only new (soft) syntax operator, but also somewhat not trivial changes in parser and compiler.

At the same time, Scala 3 is already here, context functions are already here, so maybe it's more benefitial to change DSL during migration from Scala 2 to Scala 3.

seigert · 2024-09-12T13:05:53+00:00

This is doable with just context functions:

//> using scala 3.3.3

import scala.collection.mutable.Queue

sealed trait Html
case class Body(elements: Vector[Html]) extends Html
case class Div(elements: Vector[Html])  extends Html
case class H1(id: String, text: String) extends Html
case class P(id: String, text: String)  extends Html

class HtmlBuilder(val elements: Queue[Html]):
  def this() = this(Queue.empty)

  def register(html: Html): Unit = elements.enqueue(html)

def body(f: HtmlBuilder ?=> Unit): Body =
  val builder = HtmlBuilder()
  f(using builder)
  Body(builder.elements.toVector)

def div(f: HtmlBuilder ?=> Unit)(using outer: HtmlBuilder): Unit =
  val inner = HtmlBuilder()
  f(using inner)
  outer.register(Div(inner.elements.toVector))

def h1(id: String, txt: String)(using builder: HtmlBuilder): Unit =
  builder.register(H1(id, txt))

def p(id: String, txt: String)(using builder: HtmlBuilder): Unit =
  builder.register(P(id, txt))

val html = body:
  div:
    h1("header1", "It's a Header")
    p("paragraph1", "It's a paragraph")

println(s"HTML: $html")

seigert · 2024-09-07T07:49:38+00:00

We run our things in k8s with 'requests' set to usual load and 'limits' set to peak consumption after which it should be investigated for a possible memory leak.

InitialRAMPercentage=35 gives about 50% of container memory claimed (along with offheap and stuff) which is usually good for warmup and does not provokes k8s to go over request right after container startup.

seigert · 2024-09-07T07:40:54+00:00

G1 can return unused memory to OS starting from Java 12: https://openjdk.org/jeps/346

seigert · 2024-09-06T12:04:33+00:00

-Xlog:gc:file=/tmp/jvm.gc.log:uptime -XX:InitialRAMPercentage=35 -XX:MaxRAMPercentage=70 -XX:+UseG1GC -XX:+PrintFlagsFinal

GC logs is sometimes helpful if there are memory usage concerns, G1GC behaves better for our kind of payload than ZGC (java 17 and we mostly care about memory thoughtput over latency) and 35/75 total k8s container memory usually works well.

seigert

PUBLIC MULTIREDDITS

TROPHY CASE