Can someone explain to me the appeal of these virtual console projects? Is it like lock picking or demoscene in a sense that you need to figure how to achieve impressive things under tight constraints?
335 karma · joined November 18, 2015
The real question I have is why software keeps getting progressively slower requiring faster phones. I don't buy the "devs are lazy / management pushes for frequent releases, so devs use poor expensive platforms like electron" or "all manufactures conspire to make phones that age too fast" - both devs and companies have always been like that, I don't see any recent fundamental shift in that. And it is not like current dev experience is somehow fundamentally different and easier then 10y ago - we use similar kinds of abstraction to do similar things (maybe ~20% more productive and simple?). I am genuinely confused.
Tdlr if we want to get people excited about math, we should not strive to erase all the complexity and ambiguity, making it fully digestible, because otherwise all that's left are a bunch of lunatics arguing over stacking oranges (prove me wrong).
= abstract 1) in this paper we show that X holds by evaluating Y against Z = intro 2) the problem of A is important because B, however the X aspect was overlooked; we show that evaluating Y highlights real world challenges, in contrast to Z, that... 3) to sum up, we found that Y is better at Z because X = related work Z approached the problem as..., which improved..., but as we show further, this is not sufficient to achieve...
.. and so on - you circle around the main message over and over again in each section.
One huge insight was a notation to keep track of blocked tasks (usually by other people) and what/whom to "poll" periodically to check the status.
Honestly, that's where I would draw the line between these two PDs and other conditions like ahdh and asd - is the behavior motivated by the frantic attempts to escape shame and shift blame?
Some anecdotally observed pattern suggests that many codependants in relationship with BPDs are either diagnosed with ADHD/ASD or suspect that they might have it, not sure what the causal link is.
> Tens of thousands of people probably use it every day without thinking about it.
seems like an understatement.
On a fundamental level, all these describe abstraction over what happens "between functions calls" and how values are passed around.
1. Some languages provide special syntax for exceptions and async io - in both cases "something" might happen between function calls - either an exception handler is called under certain constitutions (eg prints logs) or a kernel level callback is created and the program is suspended.
2. One generalization of this can be implemented using python generator functions / coroutines - you can build a call graph by invoking all functions in you callstack as "yield from func()", and use "yield Exception" to propagate errors and "yield Timer(1)" to ask an outer caller (event loop) to wait, or "yield Print(mag)" if we want to keep our functions pure and make the C event loop handle all the IO. You can also pass values down the stack via corp.send(x).
3. But it is a little clunky. Some langaues like Koka give you an ability to define arbitrary "effects and effect handlers" which is essential special syntax for how we were abusing coroutines in the previous step that makes differentiating and handling different "kinds things that we pass up and down the callstack" (exceptions vs timers vs prints) easier.
4. But some langaues do not have effect handlers but still want to do "custom arbitary custom things between function calls". That's where monads come in - they define a type for defining chains/trees of function calls and rules for how these threes must be iterativley unwrapped and wrapped back depending on how the wrap looks like. Eg instead of doing a(b(c)) you say unit(c) | b | a and describe how piping must be done it terms of types of values that these steps process. I hope it makes it clear how one could implement side effect IO, or exceptions, or async io that pauses by defining how to "unwap such piping". In principle, you abstract away control flow by introducing your own syntax for building function call trees and then rules for writing piping that works with such trees.
Monad guru please correct me if I am wrong.
Interesting, am I the only one who almost always uses "search on page" and glimpses/scrolls over the entire page before reading both on mobile and desktop? Especially if I just came from a search engine, I search for the "highlighted" phrase.
I see plenty of submissions where 1) authors propose a system that is clearly a monstrosity Frankenstein patched together from a dozen of existing ideas - clearly a successful attempt at getting "bold numbers" using as many new shiny toys they could get their hands on without analyzing failure modes of either part in depth; 2) a simple modification of an existing method that accedentally improves the performance of the system but still lacks proper empirical or therotical justification of why this modification helps.
While the second type of papers has at least some marginal value to the community or the reader, I still find such papers mostly useless. What brings value to the reader is a phd student who stared at the problem long enough to find quantitative and verifiable confirmations to his intuitions about the problem that lead to reproducible observations with predictive power. Ie "we experimentally verififed that indeed X affects Y exactly though the mechanism Z described in this paper in all cases, this helped us to improve metric A by B%, agreeing with Z". Not "we did X, and we saw A increase by B%", regardless of the complexity of A.
Not all reviewers agree with me, sadly.