nerdwaller

This may be pessimistic, and relating back to the higher level comments on the auto side. Watching how current automotive manufacturers have gone due to the bean counters demanding higher margins - I don’t know that we can expect them to default to the better quality hardware. If they do, I’d expect it to be during the formative/adoption years and again decline toward higher margins.

Another important library not supporting 3.7 is celery (distributed task queuing). Otherwise I also favor 3.7 (for contextvars and dataclasses).

I’ve been planning to leave WF for a long time, it was just painful to do it. But recently got the motivation and am making that change with a job shift.

I don’t believe it’s a joke, but instead hyperbole providing an example of misapplied data to “dangerously flawed conclusions”. From the abstract:

> Improper correlation or extrapolation of data can result in dangerously flawed conclusions. The following paper seeks to illustrate this point, using existing research to argue the hypothesis that cigarette smoking enhances endurance performance and should be incorporated into high-level training programs.

In the idealistic sense a couple come to mind:

1. A base "asset" to hold with nearly instant ability to move, ideally without changing value relative to the reporting currency.

2. Moving assets around between exchanges/markets/wallets outside banking hours (9a-5p M-F).

3. Banking one-self (no intermediary ever required), the owner can determine the appropriate security procedures for their assets (granted this may well be not on target of the use-case...)

Definitely true, the hands-off approach they took seemed strange to me - as others make that one of the core tenants of the community early on. Since I have been in the ecosystem it's been `go get`, `vendor` directory, the various community ones, and now modules.

Have you tried go modules since 1.11? It's significantly simpler now than it was before.

> The headphone jack issue just seems like a solution in search of a problem.

Agreed, removing it doesn't seem like it really gained anything. It was neutral at best and likely negative on the average, perhaps my smaller network that has discussed it just isn't negative and decided to not say anything at all.

Lacking negative impacts doesn’t imply that there’s benefit, my anecdata seems to be mostly neutral.

The only thing that being developer hints at here is often that group is often more techie and either would be on wireless or have very strong opinions about their listening setup. But the same is likely true for audiophiles (likely skewing toward the 3.5mm).

For what it’s worth, I’m not arguing for the jack to be gone - just sharing the reception I’ve seen in my network.

While “we” are in the 10% I try to think about the changes in the frame of the “90/10 rule” (also how I consider the impact of features in my applications). Anecdotally, dropping the headphone jack (and similarly adding the Touch Bar) has negatively impacted 0% of non-developers I’ve talked to about both.

If I were a company, I doubt I’d change course immediately unless the larger data set said something significantly in the other direction. As developers are still, even with our more frequent “upgrade” cycle, not the largest piece of the pie.

A really practical one is some type of finance course. It’s amazing how few people understand basic finance, accounting, debt management, etc. An alternative could be a business or entrepreneurship course, if you’re interested in going your own way.

I definitely agree with your point, there may not be a need for a high tech solution to that problem.

I would be curious what ratio of producing vs protecting rows a farmer would need. Perhaps it’s less than alternating rows, not harming yield as drastically. Perhaps 1/4 or 1/5 would do.

> there’s just no good alternative

Are you referring to the chromium space options, or the browser market as a whole? I’ve never left Firefox and still find it to be a pleasant browser, one with which I’ve never felt really left out barring a few annoying bugs from time to time that are typically short lived.

This is speculation on my part, however given the sophistication of their tracking capabilities I would imagine they could correlate the source to (at a minimum) a grouping of related users, if not the primary user.

(Edit: remove double negative)

I think the gist is meant:

> Fast + Cheap = Low Quality

> Good + Fast = Expensive

> Cheap + Good = Slow to market

Agreed, the cost of the original iPhone vs existing phones was likely “orders of magnitude more” but took a while to proliferate across the competitive space.

This is certainly one "drawback", depending on your perspective, and certainly a cost more of an ORM and how they tend to work than a runtime environment. You'd have a similar issue, for example, in Go if you want to lazy load a property (however there you can't await a goroutine).

Long story short, this drawback tends to be primarily based on experience of the overall system. Coming from traditional rails/django/etc will make these constructs seem awkward.

Having worked in asyncio for a bit I don’t entirely follow this (it truly could just be familiarity), very little of asyncio (especially post `async/await` were introduced in the language) is callback based and reads more procedural.

Regarding generator coroutines it feels like a natural evolution of the language. Given that yield previously suspended the current function’s state providing value(s) to the closure, it only makes sense that yield (on the producer side)/await (on the consumer side) does the same thing but in an event loop based context.

I can’t speak deeply enough about green threads, but from my understanding there’s much less magic (as you cite “explicit”) in an async/await world vs the magic (“implicit”) world of green threads.

    async def thing():
        print(‘before’)
        await asyncio.sleep(0)
        print(‘after’)

Vs

    def thing():
        print(‘before’)
        gevent.sleep(0)
        print(‘after’)

There’s nothing clear in the latter when something yields or otherwise passes control flow.

Having worked in a few evented systems, I find the explicit shift to the runtime is valuable.

Thanks for pointing that out, I must have scanned too quickly!

I’m surprised to not see 2580 in the top 20, given that’s straight down the center and all unique items.

I’ve gone back and forth mentally on the “every bit of work needs a card” concept. Recently we’ve been trialing the on-call person taking those issues if they’re under a time-estimate threshold (30min) and budgeting the time for that person accordingly. Other issues go up the chain, to avoid the issue of the on-call person getting overwhelmed with unrelated feature requests and such (especially by those they relate to better than others).

So far it’s been really positive when the rotation is 6+ persons, when I drops below that it gets a bit more wearing with on call being a bit heavy feeling.

We have 4 columns:

* Proposed * ToDo * In Progress * Done

As a developer we mostly care about all but the first (though we drop random stuff in the first). The ToDo is always ordered with respect to priority but is generally irrelevant while one has work in-flight. That allows us to, without having to really notice, always grab the most important thing when we are free again.

As you can imagine the proposed is the ungroomed/vague/random idea list that is roughly ordered toward whatever the PO (or developers for us since we don’t have product) views as a road map - discussed every week or so.

Everything has labels and generally ties to the concept of an epic or bug.

They’re not traced until someone wants to do something with them that then makes them traceable (along with many related accounts). Is owning an “asset” useful if you can’t do anything with it? At that point when someone:

1. Converts to Fiat 2. Buys/Ships something online 3. Transfers to an exchange

It’s now fairly visible to entities keeping a close eye (governments).

This reminds me what I learned about secrets as a child: the only way to keep a secret is to not share it.

There’s nothing really stopping you from revoking a JWT individually - simply keep the `jti` (or any arbitrary claim) in memcached/redis/etc and check it. Obviously it’s no longer stateless and gives up some of the benefits of a JWT, but it’s a solution if revocation is a business requirement.

Like everything, there’s no silver bullet (JWT vs random string token) - business requirements dictate which makes sense.

That's true, though being pretty involved in the ecosystem (e.g. anecdote) I believe that people tend to agree with the general concepts (with exceptions).

> it's opinion that everyone else is stupid and wrong

I can't speak for the BDFL, but I don't believe this is the intent. It's not meant to say everyone else is wrong and Python is right, rather that Python prefers fewer ways to do things and certain complexities aren't worth it when there's a good way already in the language to do $feature. Complexity may not be in the python layer even, it could be maintenance in the underlying implementation (CPython, PyPy, Jython, ...)

List comprehensions are more a substitute for map than anything else (which is generally discouraged in the ecosystem). For comparison: `map(lambda x: x * 2, range(10))` vs `[x * 2 for x in range(10)]`.

However lambdas are mostly discouraged because they're often harder to read for anything non-trivial (and really you can't do much non-trivial with them since they are so dwarfed) and you can just define a function in the same block and pass the function reference in place of a lambda. I think the premise is more that it's clearer to pass a clearly named method describing the intent instead of a lambda describing the how.

I’ve moved from YouCompleteMe to Deoplete. While YCM is good, the plugin support for deoplete seems a bit more extended and easier to set up (ymmv). Maybe I just messed something up every time I tried to rework my vimrc with YCM though, it’s probably likely :D

Isn’t it amazing disembarking the plane into AZ? Instantly it’s 98F+ on the jetway, and the plane absorbs a large portion of that as they ask you to close the window shades on landing. I don’t quite understand how one can live there if they like being outside at all. Perhaps enough months of the year make it worth it? It is, however, a nice place to visit from a cultural standpoint.

That goes to my point, rails doesn't have the symbols in code for the editor to use to refactor because they are added at runtime dynamically when ActiveRecord reflects the database. You can have a full model that just has `class User < ActiveRecord::Base; end` that has 15 fields on it, none of which are in the code.