Varriount

Perhaps it's naive of me, but I can't help but look down on this kind of behavior. I know that tax money is rarely spent in the most efficient way possible, but (ideally) the point of taxes is that they go to benefit the general public. Moving just so one doesn't have to pay as much, after (presumably) living in the state for some time feels selfish and greedy.

Reading CDK's introduction page, it seems that, similar to CloudFormation, it uses pre-made components, just at a higher level. Those components are then translated into a CloudFormation template[0]. Is that correct?

Might it be more accurate to state that CDK is a higher level version of CloudFormation, that abstracts away unimportant details?

[0] https://aws.amazon.com/cdk/

Not quite true, you can technically create your own CloudFormation resources[0]. It's a pain to do though.

[0] https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGui...

The point, I think, isn't that this is currently in Chrome, but rather that there are plans to add it to Chrome in the future.

I wish more things had multiple cursors. Imagine if that was standard. Especially for certain text forms...

My problem isn't necessarily speed, but power consumption. VSCode (without any language servers running) uses quite a bit of power.

Hm, if that is the case, how will advertisers get any utility out of this? How does the categorization fit into advertisers interests?

For those who feel a bit out-of-the-loop, this excerpt pretty much sums up why the EFF feels that this is, if not worse than 3rd party cookies, not significantly better:

  The proposal rests on the assumption that people in “sensitive categories” will visit specific “sensitive” websites, and that people who aren’t in those groups will not visit said sites. But behavior correlates with demographics in unintuitive ways. It's highly likely that certain demographics are going to visit a different subset of the web than other demographics are, and that such behavior will not be captured by Google’s “sensitive sites” framing. For example, people with depression may exhibit similar browsing behaviors, but not necessarily via something as explicit and direct as, for example, visiting “depression.org.” Meanwhile, tracking companies are well-equipped to gather traffic from millions of users, link it to data about demographics or behavior, and decode which cohorts are linked to which sensitive traits. Google’s website-based system, as proposed, has no way of stopping that.

The way I interpret this is that, based on your browsing history in Chrome (or any browser that implements this kind of functionality) you are placed into a number of categories (or, if one reverses the metaphor, a number of descriptive tags are attached to you). Google is aiming to ensure that certain categories/tags that might be considered sensitive (mental state, physical illnesses, etc.) will be blocked.

(To be clear, this is my interpretation of what they are stating, not an assertion of fact)

The EFF is arguing that this isn't really that straightforward, as sensitive details can still be inferred from non-sensitive details.

What I'm curious about is, who is doing all the ID generation, categorization, and data centralization? Or is Chrome just going to calculate everything itself, then send the data to sites that ask for it?

Although I use PyCharm as my daily IDE, I nearly always have a Sublime Text instance running in the background. I use it for note taking, small scripts, and so much else.

Granted, PyCharm is likely capable of most of the same things, but there's something about Sublime Text that is just so... frictionless. I don't feel like it expects anything from me.

The rise of VSCode has saddened me in certain respects. VSCode is great, and if I didn't have PyCharm, I would probably end up using it instead, but there are still certain things that it can't quite (and likely never will) surpass Sublime Text in (record/replay macros, power usage efficiency).

(I do hope macros will be improved to run all commands, rather than just text commands, but that's likely low on the list)

On a different note, I still consider the development of a continuation-like mechanism[0] for Sublime Text's API as one of the things I'm most proud of creating (if I recall correctly, Python's Asyncio library was still in the early stages back then, and `await` hadn't even been proposed).

Anyway, I just want to say, thanks Jon and Will, Sublime Text has had such a positive impact on my life as a programmer.

[0] https://forum.sublimetext.com/t/using-generators-for-fun-and...

Technically speaking, how does this even work?

And non-technically speaking, how does a major flaw like this not get spotted and patched when the architecture for SMS was being initially designed? Or is this just one of those cases where no-one was willing/able to consider security (it where it wasn't even a usual consideration)?

Out of all the technologies I use on a day-to-day basis, I feel like telephony networks and transmission is the area I know the least about.

Not too long ago had to search through a truly gigantic file (I believe it contained JSON logs?). Sublime Text slowed to a crawl and froze when attempting to open it, and I didn't even bother with VS Code. On a hunch, I tried opening it in Notepad - and it loaded quite quickly!

And yet, if vaccinations don't continue, it's highly likely more people would die, that otherwise may have lived.

  Paul Hunter, an infectious disease expert at the University of East Anglia, noted in a statement that even if the risk of CVT is raised by the vaccine to five or more cases per million people vaccinated, the COVID-19 infection fatality rate for men in their mid-40s is 0.1%, or 1000 deaths per million infected.

So it's a tricky problem. I do believe you are correct though - even just evidence of missed side effects would be like meat and drink to anti-vaccination sentiments.

"Many" is a subjective term. It doesn't tell you anything quantifiable, merely what the describer thinks is a larger than usual number.

For example, someone who has never owned pets might think that someone who owns 2 cats and a dog has "many" pets, while someone who does own pets might only consider that to be a "normal" number of pets.

I have to wonder - was repairing (rather than replacing) appliances cheaper in the past? If so, is there a clear cause on why repair prices have changed?

Because, in the end, you end up paying real money, and not only that, you have mechanics that are designed around making that choice as tempting as possible, while attempting to masquerade as something harmless.

For external modules, you can generate stub files that contain inferred and/or manually supplied annotations[0].

[0] https://mypy.readthedocs.io/en/stable/stubgen.html

I would say most pieces of furniture sold these days are made of engineered wood [0], if that's what you mean by "composite materials". Aside from easier sourcing, I presume that a big driver of it's use is the fact that it is easier to shape and produce - no having to figure out how it will be assembled using the various sizes of timber available.

The actual solid-wood furniture I have seen is either quite expensive, or (somewhat ironically) unfinished.

All this being said, if you do have the money to spare, spending a bit on quality or better labor practices is good. For example, I bought my bed frame from a company in the UK[1], and was quite happy with the finished product (despite some unfortunate luck with a part of the frame, which I put down to the fact that I ordered during the holidays).

[0] https://en.m.wikipedia.org/wiki/Engineered_wood [1] https://www.getlaidbeds.com/

You might be interested in Nim (https://nim-lang.org). I can't say that it's very object oriented, but it is very flexible.

The neat thing is that you can use tags to represent custom data structures or functions. For example, AWS Cloudformation uses YAML tags as a shorthand for template functions [0].

https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGui...

Other than a possible checksum calculated from the entire file contents, many binary formats use either:

  - Headers describing a section, including the length of a section.  

  - Prefixing each section with a size.  

  - Using a marker pattern (such as a null byte) to mark the end of a section of data.

(there are more than these three, but these are the most common) That last one isn't used very often, and when it is, it's mostly for textual data.

The consequence of using the first two techniques is that it's entirely possible to add data to the end of the format, since a parser would just read the last section and stop (assuming the format supports knowing what the last section is).

Huh. Wouldn't this have caused inter-operability problems for programs that spawn other processes?

The argument being made is that Go's design isn't so much "forward thinking" as it is driven by Google's interests.

What they are not stating is that Go is a conservative language with a standard library hampered by that conservatism, nor are they making a judgment on the current state of the language.

If you are going to criticize someone's post, give them the respect of actually reading their argument, and not just writing a knee-jerk reaction.

And what if I'm searching through a large directory? Your response doesn't address the argument being made.

Creating an API where the entire set of data is returned from a data source, without an option to limit the result, is bad. It means that, if I have to read a directory with 2000 files (and this is quite possible! - think /bin, etc.) the function will have to allocate a slice with 2000 entries, and then call stat on all of them.

Stat is not free, especially on certain filesystems (NFS!), nor is reading directory entries.

Note that they state "all things that have already been fixed". Did you use Go when these oversights were present?

While it's true that REST has no concept of joins, when retrieving designing an API using REST, one often has to decide whether to return data related to an object as part of a query for the object, or to force the client to make secondary lookups.

Regarding GraphQL, one of its big selling points is that you can query not only for specific fields, but fields in nested data as well.

Lets take two possibly equivalent queries, modeled on the data discussed in the GraphQL tutorial[0]:

  # REST Call
  GET /hero?primary=true

  # GraphQL Query
  {
    hero {
      name
      friends {
        name
      }
    }
  }

Ideally, these queries would result in the following SQL query when one wants to also get the primary hero's friends:

  SELECT
    heroes.name,
    (
      SELECT heroes_inner.name
      FROM heroes AS heroes_inner, friendships
      WHERE friendships.left = heroes.name AND
            friendships.right = heros_inner.name
    )
  FROM heroes
  WHERE name = ? AND primary = true;

(This query might not be exact, but it should get the meaning across.)

Of course, this presumes that the REST query selects friends names as part of the request, and that the client doesn't have to manually perform a join/secondary lookup to retrieve additional data. If it doesn't, then you might have to perform additional REST calls to get all the friends of the primary hero.

[0] https://graphql.org/learn/queries/#fields

Although I haven't used it personally, I can see it being very useful for APIs where the "objects" involved contain many fields/relations. Rather than coming up with a limited set of filter/query parameters, you can take advantage of a query language with tooling.

That being said, one of the things that irks me about most* GraphQL implementations is that they seem to do joining entirely server-side. This makes sense if you have to join data across multiple services, but if you're only dealing with a single data back end (like a database) then you can't take advantage of JOINs.

If anyone knows otherwise, feel free to correct me. As I said, I don't have any practical experiences with GraphQL.

*I'm aware there are one or two GraphQL libraries that support JOINs, but most do not.

Odd - it loads almost instantly on my phone (Chrome, Android).

As someone who has had to evaluate and recommended enterprise software for purchasing, a straightforward price tag is going to make me come your product in a better light.

Plus, I have to wonder how much extra profit the "call us" route actually takes in, after you've subtracted costs for the marketing staff it requires (especially if you try to renegotiate the cost after the subscription/license expires).

Ah, I should have added "salted" to my original description.

What are your opinions of the `crypt` and `gen_salt` functions from the pgcrypto module[0]?

https://www.postgresql.org/docs/current/pgcrypto.html#id-1.1...

> In general it is a bad idea to store secrets in the database itself

Perhaps my ignorance is showing but do hashed passwords count as secrets? Because those are usually stored in databases.