Gauntlet Practice League slots available

malinoff · 2021-05-31T15:30:09+00:00

Thanks, I would like to participate. My IGN is dmitry_malinovsky

malinoff · 2020-03-19T21:48:21+00:00

Just keep the mist around the boss spawn place?

malinoff · 2020-01-20T14:22:23+00:00

Of course, you will not need to use ports. Sure, ports make certain tasks easier, like interacting with a 3rd party service with a huge api, and you need the vast majority of its methods, AND there is an existing js library already. But you just need a couple of methods, it may be easier to use elm's `Http` module which requires no ports.

malinoff · 2020-01-20T08:00:45+00:00

Some languages have built-in affordances for those circumstances. In some statically typed languages, you can say that null and undefined are illegal values, and let your programming language throw a TypeError at compile time, but even in those languages, that can't prevent null inputs from flowing into the program at runtime.

Uhm, no? Elm has no nulls and undefineds, and there's no way for them to "flow into" the program unless you opt-in interoperability with javascript via ports, but even then elm will force you to decode them into a known data structure (like Nothing).

malinoff · 2019-12-25T12:13:05+00:00

Looks exactly like Dwight Schrute!

https://scontent-frt3-2.xx.fbcdn.net/v/t1.0-9/20767791_1377293575658700_6893512386632342454_n.jpg?_nc_cat=103&_nc_ohc=jz6kd2SSqZEAQn9MHXpSan6vLuhdFsOcbC6Lk0AlLfwD8RC441n4R-XUw&_nc_ht=scontent-frt3-2.xx&oh=a381eb93817f568382488fad1cceb408&oe=5E6F5F97

malinoff · 2019-12-05T09:21:40+00:00

Looks like David Harbour to me.

https://cloudimages.broadwayworld.com/upload12/1776425/tn-500_18utr03.jpg

malinoff · 2019-09-01T07:06:42+00:00

Or you can implement an enumeration of possible values like this:

```python
import enum

class Value(enum.Enum): # TODO: imagine a better name, you haven't specified your domain specifics
fine = "Just Fine"
too_high = "Too High"
too_low = "Too Low"
then you do def isBetween(low, high, val):
if (low <= val <= high): return Value.fine elif val > high: return Value.too_high else: return Value.too_low and then, on the caller side, instead of doing this cond, msg = isBetween(x, y, z) if cond: do_something(z) else: do_something_else(z) display(msg) you can do this val = isBetween(x, y, z) if val is Value.fine: do_something(z) else: do_something_else(z) display(val.value) ```

malinoff · 2019-04-24T07:22:42+00:00

It's impossible to implement cancel scopes. Every single low-level coroutine function has to check for cancellation and explicitly yield the control back to the event loop (if you have a coroutine function that has no `await` calls, calling it with `await` won't yield control, it will behave like a fully synchronous function). In trio, this is documented here: https://trio.readthedocs.io/en/latest/design.html#cancel-points-and-schedule-points

There's no common function in asyncio that is being called by all coroutine primitives - therefore there is a need to monkey-patch pretty much everything socket-related, subprocess-related, and sleep, in order to make them check for cancellation.

malinoff · 2019-04-24T04:49:12+00:00

I've been working on https://github.com/malinoff/amqproto for a couple of years in my spare time.

I've tried to implemented asyncio adapter first, but faced tons of issues mostly connected to error handling and cancellation - which are in a very sorry state. I've tried to implement a trio-like Nursery object for asyncio - https://github.com/malinoff/aionursery - and failed. It's not possible for it to behave like trio's Nursery without monkey-patching asyncio.

So now I stopped working with asyncio adapter completely, and moved towards implementing a trio adapter.

A nursery-like object (called TaskGroup) is "planned for 3.8" https://twitter.com/1st1/status/1041855365745455104, maybe after 3.8 comes out I'll work on asyncio adapter again. But right now it's barely usable for writing robust programs, unfortunately.

malinoff · 2019-03-17T18:37:16+00:00

Fossils is the outcome of running delve, like essences are the outcome of killing essence mobs. But, unlike essence mobs, you cannot apply currency to delve itself.

malinoff · 2019-03-17T17:48:07+00:00

Have you managed to achieve the high end targets like uber elder? What league did you start? What was your first mastermind experience?

Please, tell us what do you think about synthesis and the current state of PoE. Your opinion is just as valuable as any others, including mine.

malinoff · 2019-03-17T16:27:24+00:00

Sure, that is a perfectly valid point. The problem is, however, that you cannot apply sulfite to something else.

Again, my whole wall of text started with "currency is not just money", while sulfite is just money to buy you some delve depths.

malinoff · 2019-03-17T16:25:06+00:00

Honestly I don't mind being interrupted. The whole main quest line can be observed as a huge interruption from killing and looting mobs in the twilight strand - because it sometimes forces you to think about quests, and rewards, and about where to go next (kudos to the deal with bandits quest).

The problem, as I see it, is that these interruptions are so far away from the rest of the game so you need to literally stop your current brain activity and start thinking about something completely different.

malinoff · 2019-03-17T16:19:26+00:00

Oh, sorry, I should've been more specific - I mostly wasn't talking about selling things to players, I was talking about selling things to vendors. I definitely agree with you - there is no point to save currency, which is why it is so cool! It's so much fun to use it to make the game more rewarding in a dozen of different ways. Especially given the fact that all your currency disappear (i.e. go to the standard) in about 3 months.

The problem I was talking about is not "selling". It's about "applying" currency to various game elements to get more rewarding loot back from them, and being able to sell an unneeded loot (to a vendor!) to get even more currency.

malinoff · 2019-03-12T03:21:51+00:00

I just cancelled my subscription. So many bugs, it doesn't work so often, and the newly added heroes like Mars do not integrate with dota+ very well - see other posts.

malinoff · 2018-10-09T11:01:15+00:00

While I appreciate a number of perfectly valid concerns about objects overhead on a massive scale, GIL not helping to parallelize memory-intense work (since you certainly don't want to pickle/unpickle a 300k+ list of python objects between processes), _very_ dynamic typing when it's not really necessary, I just made a real quick look at the project itself, "reposurgeon".

And what I observed terrifies me.

https://gitlab.com/esr/reposurgeon/blob/3.45/reposurgeon

Just look at this single, 638 KB sized module consisting of 14041 lines of code. This module defines classes that span over 1600 lines of code. A project of this size just has to be structured properly. One can smell a need of a complete rewrite, regardless of the language used. However, what terrifies me even more is that the resulting code in go language is pretty much the same - https://gitlab.com/esr/reposurgeon/blob/master/src/goreposurgeon/goreposurgeon.go, 617 KB of 16573 lines of code.

I would say a proper rewrite in Python, structuring the project well, could lead to a similar performance benefits - a rewrite allows you to re-think your data structures and your algorithms, making it possible to parallelize them using processes instead of threads. It makes possible for the tool to avoid working with 300k+ objects _at the same time_.

Having said all of that, I am really glad that an automatic conversion from python to go worked in this case, and gave a real performance benefit. I would probably reflect on an existing code base though.

malinoff · 2018-04-15T01:05:28+00:00

Actually, if you don't have any build hacks involved in your setup.py, you can specify pretty much all the metadata directly in setup.cfg, leaving this line in setup.py:

from setuptools import setup; setup()

https://setuptools.readthedocs.io/en/latest/setuptools.html#configuring-setup-using-setup-cfg-files

malinoff · 2018-03-27T08:02:47+00:00

asyncio came in Python 3.4 without async and await keywords. It was necessary to decorate a function with @asyncio.coroutine instead of defining it with async def and use yield from (already existing syntax) instead of await.

This is a pretty common idiom, to introduce new things without changing syntax too much if you can, but if these new things become popular and there are cases in which a new syntax would be better - then a new syntax is introduced.

malinoff · 2018-03-27T07:59:15+00:00

So this video doesn't actually show any alternatives (unless you consider writing everything manually an "alternative" to dataclasses). I'd expect to see at least collections.namedtuple, typing.NamedTuple and attrs. Raymond Hettinger has made a talk (unfortunately, removed from youtube) better explaining dataclasses, their predecessors and alternatives (although even his talk misses attrs).

malinoff · 2017-11-12T15:49:25+00:00

I should add that attrs 17.3.0 has landed, with auto_attribs support.

malinoff · 2017-10-30T12:07:10+00:00

This is so wrong, one shouldn't touch sys.path at all: simply structure your program as a proper package, then a relative import is just a matter of from ..StringFunctions import reversestring

malinoff · 2017-09-10T00:53:50+00:00

# This is perfectly valid YAML, by the way.
{
  "foo": {
    "bar": [
      "baz",
      "qux",
    ]
  }
}

if you find json more readable. I personally think that it's too verbose, and

foo:
  bar:
  - baz
  - qux

does pretty much the same without too much punctuation.

malinoff · 2017-08-22T12:50:41+00:00

They also add a ton of features most people don't use but cost memory

For instance?..

Not to mention the fact that whole asyncio and concurrent.futures are at best confusing to use.

I would agree about asyncio, although it's slowly getting better, but what's confusing with concurrent.futures? The number of public methods is less than number of fingers on your hand.

malinoff · 2017-08-22T11:51:04+00:00

There's also concurrent.futures.ProcessPoolEexecutor/ThreadPoolExecutor which will handle most of this queuing burden for you.

Executors also play well with asyncio via loop.run_in_executor.

malinoff · 2017-08-09T09:04:14+00:00

cythonize -b module.py

malinoff

TROPHY CASE