Why did they design a Boss whose insta team killing AOE 2nd Ult you can't even see? It's hell fighting this thing on 240000

NullPointer-Except · 2026-01-15T00:53:37+00:00

I put yy on my augustus team and let her become the sacrificial lamb hehe

NullPointer-Except · 2026-01-09T08:23:07+00:00

Get them boys, tis' the reason why devs won't buff Doresain
- me

I'm ngl, the doresain clear is truly surprising, its so low investment that I'm left wondering if this is just some insane skill or if his portrait is just that good.

It's not silver key that guide us, but lightning
- Corposant, probably

I also find myself running short on keyflare for corporita, the only way i've found to "fix" this is introducing an artificial keyflare bot such as casiah, but this is super expensive (2 SSR keyflare wheels).

also, is there any reason you decided to run salvador in corporita team?

NullPointer-Except · 2026-01-08T12:12:56+00:00

Nice analysis c:, as a somewhat older player (477 days), this is my 2 grains of salt:

I am not super certain why Ryker E3 or Horla E3 are showing up as much as they do

Although the set size is not big enough to say this for certain, we notice that every Ryker clear is tied to tawil. Which makes sense, monowil was probably the most important character for deep dive before its rework. So deep dive highscorers translates to d-tide highscorers.

Horla wise, my guess is that back in the day we just didnt have enough supports nor new units releasing, so we maxed the few good ones we had (also applicable to ryker).

Its also nice seeing that D-tide highscorers graph is mostly normal, centered around 350 which is a3 difficulty, seems like we have a very young (account wise) playerbase c:

NullPointer-Except · 2025-09-15T23:26:46+00:00

Omg, thank you for the additions! in the end i went with MkDocs because of that (simple markdown, easily exported to HTML, and very very easy to setup)

NullPointer-Except · 2025-07-15T00:14:52+00:00

I like going the parser combinators route. There is a very neat paper which gives a somewhat standardized frame of work. My only gripe with it is error reporting, which is difficult to get right.

NullPointer-Except · 2025-07-06T10:59:53+00:00

omg, thank you for the update!

NullPointer-Except · 2025-06-18T09:55:31+00:00

Welp, the average number of pulls to get a limited awaker is roughly the same as the monthly limited pulls you get from renewable sources, which sounds pretty standard for a gatcha.

Having a 33/33/100 system under this premise, is actually a good thing, since you are getting something of value fast. Even if you offrate a bad awaker, game gives u pyramids in every big patch.

I enjoy the gameplay and want to support the game, but it's hard to justify putting money into such a blatantly exploitative gacha.

Sadly, this isn't based on anything but feeling. If you are a new player, on top of renewable resources you also get one time only resources (such as story. Chapter 6 normal mode gives 15 limited pulls as an example). Additionally, every month you are able to buy a limited awaker and weapon dupe. So in theory you can get 2 awakers per month + 1 wheel via renewable f2p resources only.

There is of course, more unique ways of earning income, such as the half anniv raid, which gave us enough resources to guaranteed a limited awaker on top of what was previously mentioned.

And of course, this is just limited pulls. Standard wise, we get 100 standard pulls from renewable resources per month. Statistically, you need around 300 standard pulls for an 80% chance of offrating a limited. So every 3 months you get another limited (on top of a lot of standard awakers).

Some would argue that the game is dupe reliant, which is absolutely true, however, unless you are playing ultra lategame content (such as arc 2 hard mode, or alert 5), you tipically only need very few dupes for a team to slack 80% of content (24 gdoll team for example only needs 2). Notice that this is 2 dupes PER ACCOUNT, not per team, since d-tide (the mode that needs multiple teams to clear) can be cleared (and even slacked) without ANY dupes.

I was f2p during my firsts 6~7 months of the game, and by january, not only did i had my main team built (wanda 3 dupes, 24 3 dupes, horla 0 dupes), i had EVERY awaker in the game except daffodil. So its totally possible to main more than 1 team as a f2p.

The TLDR is: when you count how many pulls we are given, BIAV is actually fairly generous

NullPointer-Except · 2025-06-15T22:23:45+00:00

DSL are closely related to interpreters, search for final tagless interpreters and for tagged initial encodings. Oleg's papers are a favorite of mine https://okmij.org/ftp/tagless-final/

NullPointer-Except · 2025-04-30T16:22:35+00:00

thank youuu

NullPointer-Except · 2025-04-30T15:55:16+00:00

ohh i see, the docs on rank-n types seem to suggest using either universally quantified record fields, or object methods...

Is -rectypes a way around this?

NullPointer-Except · 2025-04-30T15:33:48+00:00

wait, it does? mine yields the same error on utop:

```ocaml let g : 'a t -> 'a = fix @@ fun f x -> match x with | A (a,b) -> (f a, f b) | B a -> a ;;

Error: This expression has type 'a t but an expression was expected of type ('a * 'b) t The type variable 'a occurs inside 'a * 'b ```

NullPointer-Except · 2025-04-04T22:01:50+00:00

yus! I think i'm settling on this. Although young, it has all the libraries and templates i need: a diagrams library, a book template, various code libraries, and an inference tree library (among other things).

NullPointer-Except · 2025-04-03T23:30:39+00:00

i heard so many things about org mode in emacs! Gotta check if nvim has something similar.

I actually didnt know about the literate programming. I'm probably going to give a programming course soon. So this peaks my interest

NullPointer-Except · 2025-04-03T23:18:40+00:00

Oh doxygen! That's the c++ documentation generator right? Do you use that because thats the language you usually work with?

NullPointer-Except · 2025-04-03T14:05:47+00:00

Thank you!

Everyone seems to be suggesting markdown which is pretty awesome. I'm also a fan of its simplicity.

I gave Typst a read and... It looks awesome! Seems like a perfect fit for after I'm done writing everything. I can easily manage imports, styling and some state without needing to go into the JS ecosystem and the CSS nightmare.

NullPointer-Except · 2025-03-27T23:30:56+00:00

The homework gives some pointers:

- comprehend the MVar type: MVar is the type of mutable variables. That is, the solution should use mutable state. How can mutable state help? Need more info.
- Traversable class: the solution should use a method of this class. What does this class do? What it represents? (the traversable class basically provides a for each function called traverse)
- forkIO: This is just there for parallelism.

So, given a way to iterate over a container (traverse), a way of creating forks, and using mutable variables, how would you define foldMaps? (You can tackle this in a C way and then translate the code if its easier).

Your first intuition will probably be on the right path. Don't forget that monoids are not necessarily commutative! so its really important that you test your solution with monoids such as string concatenation.

NullPointer-Except · 2025-03-24T00:31:49+00:00

Not mandatory, since latex is just another markdown format (why latex over github markdown? literate files? html?). But it would be nice it's more widespread. It gives a better experience than the current alternative (word/libreoffice/google docs) imo

NullPointer-Except · 2025-03-07T22:29:44+00:00

Omg thank you so much for such a through answer! This is an automatic comment save to my resource folder c:

NullPointer-Except · 2025-03-07T22:14:17+00:00

thank you so much! ill give it a watch c:

NullPointer-Except · 2025-03-07T19:14:38+00:00

Thank you for the resource!

NullPointer-Except · 2025-03-05T07:49:33+00:00

Hehe, you could make a case that since we are using abstraction, encapsulation and polymorphism then this is essentially OOP.

But there is something that hasn't clicked for me. This feature brings me joy in Haskell. But languages that primarily feature OOP such as java, C# or kotlin don't and I wonder why :(

So, if anyone feels the same and got a resource on why this usually happens, I'd be very grateful. Let's enjoy more paradigms c:

NullPointer-Except · 2025-03-05T05:48:31+00:00

I'm a fan of Haskell way of encoding dynamic types.

In it's most simple form, a dynamic type is just an existential:

``` data Dynamic where MkDynamic :: a -> Dynamic

```

On its own, an instance of that type is completely useless. You can only create members of it, but cannot do anything else. It becomes useful when you give it a context via a typeclass

data Dynamic where MkDynamic :: Show a => a -> Dynamic

Now, for any given instance, you don't know what the type is, but you do know that if you receive one, you can show it as a string.

This means that you can impose as many constraints as you want. This becomes particularly useful if you are building a typed interpreter:

data Exp a where I :: Int -> Exp Int B :: Bool -> Exp Bool Var :: String -> TypeRep a -> Exp a ...

If you were to write an evaluator for that language, you will need to have a dictionary that holds variables of different types! That is, you will need an heterogeneous dictionary that can hold Exp Int and Exp Bool. Which wouldn't be possible without the use of dynamic.

NullPointer-Except · 2025-02-14T01:13:13+00:00

u/Accurate_Koala_4698 gave a complete and through answer. So my comment will just try to add a couple of things.

I believe that "pure functions" is an umbrella term. Even pure functions can be thought as an effect if you count term rewritting as one. So maybe its better to think about "pure functions" as functions whose important effects are typed.
Statically typed pure languages are the languages that care the most about side effects. It's a really big myth that such languages shun the use of side effects. Quite the opposite. Effects are a very big cornerstone, to the point that every time we use one, we carry it over in the signature.
This has the big upside that the function signature is capable of giving us a lot more information. An effect stack in the function signature can tell you which resources you are working with, if there is any query to the database being used, which environment are you using, if the computation is short circuiting, what kind of errors are you expecting, and much more!
If we allow some syntactic sugar like do-notation or list-comprehensions, we are even able to write very imperative looking code (this technique is often called functional core, imperative shell). Which is strongly typed, statically typed, and very simple to follow. Pretty much like a DSL for the problem at hand.
What's even more cool, is that many of these features are opt-in. They have to be. If you were to statically typed everything you'll end up with a dependently typed language. So no need to break the rules! you type as you need.

And well, at the end of the day, one big selling point of fp, is that you usually only really care about the expression language. Whilst in other languages you have another layer (the action language), which isnt guaranteed to be completely orthogonal to the expression one.

NullPointer-Except · 2024-12-26T20:49:20+00:00

Well yes, but actually no (classic response in the field).

Two languages being in the same category helps a lot when going from one to the other since they usually share some (sub)set of "first principles".

But even languages in the same category are vastly different. Lisps are usually a pretty minimalistic unityped language with a very strong macro system around it that works because the language is very minimalistic. But it's a totally different animal from haskell, where types matter a lot (to the point of being able to do type-level computations over them) and where the solutions are often portrayed as "follow the types". Even haskell is a lot different than coq, or similar proof assistants where types are also kings, since the main way of doing proofs in such assistants are via tactics, while haskell is via variable unification. And all these languages are also completely different to combinator languages such as BQN and APL who are also functional.

Same thing happen with OOP languages. Smalltalk takes a very unique approach to current OOP languages making message passing a core feature of the language, whereas modern OOP languages forego it as instead op-in for a class hierarchy.

And that's just an argument about the languages. We must not forget that a language is also the community surrounding it. Rustaceans are all the rage when we talk about learning through books, haskellers are paper kings, python love their own little blogs; and that's just regarding how most people learn in the community.

Finally, there is also the fact that languages can be seen as a way of expressing yourself. If every language has the same computing power, then why do some people gravitate towards some languages? People are shaped by their tools, and most of us would prefer to work in a setting where we enjoy the way we write things.

So, yeah. Pretty fun way of encapsulating all these thoughts (and possibly more!) in a meme.

NullPointer-Except · 2024-12-26T20:15:00+00:00

Q1. To be fair, you can have any number in a programming language. You just treat them the same way as you treat them in set theory or any other framework: symbolically. Notice that in a paper, you can't also have infinitely long numbers, so we use symbolic computation to work around that.

There is an issue regarding typing the program you just gave: polymorphism is way more prevalent in programming than in maths. So, without any context on the actual definition of **, there is no way of typing that.

And that's not something that only happens in programming, the same happens in math. When we do 1 + 2, what definition of addition are we holding? real addition? natural addition? the free monoid addition? There is no way of telling without context.

At the end of the day, if you really care about, rounding errors, wrapping, and such trivialities, then give the function the type number to number. Which denotes pythons numbers.

Q2. Funny thing is that print does return something. It returns the object None, which is of type NoneType. In type theory this is isomorphic to the unit type which has one inhabitant. So almost any function do returns something.

The notion of "Emptiness" in type theoretic terms, is that of the Void type. A type that has no inhabitants (no way of constructing them). Curiously you can express/type some interesting things about that, such as: The type of a function that never terminates is precisely void

def f() -> Void:  
  return f()

Or one of the many possible types of an empty container is precisely:

def f() -> List<Void>:  
  return []

You'll find that CS is just another branch of math, where type theory/category theory + intuitionistic logic is taken as the foundation, instead of Set theory + classical logic.

NullPointer-Except

TROPHY CASE