frederikb

Oh, but they do! There used to exist a boatload of malware on Android disguised as common conscience apps, famously flashlight apps/widgets.

As a random example, see this one ( https://www.welivesecurity.com/2017/04/19/turn-light-give-pa... ) which is a banking trojan cosplaying as a flashlight widget.

Now there is a more or less sophisticated permission system which users then bypass by still accepting any prompt if you promise them anything shiny...

Good news: he did some minor touch ups and then approved the PR. Seems like humans did win this round. Let's see how long that lasts.

I've actually seen this in the wild this year. It was placed at a train station in a small town in southern Germany, which presumably did not have a physical bank branch. It was exactly as you said: basically a chair, keyboard and screen in a tiny building (not much larger than a phone booth).

I really enjoyed Storytelling with Data: A Data Visualization Guide for Business Professionals by Cole Nussbaumer Knaflic. The author really breaks down the individual elements of good/bad visualizations using case studies with lots of actionable advice. Highly recommended.

The point that the others are trying to make is that these questions are not relevant in the context of the backend technology choices. The REST or GraphQL endpoints could be handled by monkeys writing bits via typewriters and it wouldn't affect the CPU usage in your browser.

In any case regardless of UUIDv4, v7 or any other format you should not allow the untrusted client to determine the real ID - as long as there is at least one trusted component in the architecture which would take over this role. This should help eliminate a whole set of possible security issues.

For me the central benefit is that you can create them in a distributed manner and are not reliant on a central system as a single source of truth for creating your identifiers.

I can therefore easily generate a new UUID in a trusted backend service which just accepts the command received from the untrusted client and then forwards the request for asynchronous processing while returning the UUID to the client. This is a typical architecture and the only change is that I can now create UUIDs which may have performance benefits, depending on the data storage technology of my read models.

If you need to create the UUIDs on the client side to support specific requirements such as offline-first, then I would indeed consider adding some reconciliation which replaces the IDs provided by the client-side by new ones generated by a trusted component as soon as synchronizing takes place.

Unfortunately this fails for me:

  curl: (6) Could not resolve host: t6a3m9g6.rocketcdn.me

When did that happen? I still have my OG Steam account with an email address as username which is now 19 years old.

I was never prompted to change that, even though I would definitely like to. I would appreciate any insights you might have.

As the author of arc42 writes in the article, the order of the chapters does not imply the order in which they should be decided upon and written.

In addition he writes that you might have already documented the most important decisions as part of the solution strategy chapter.

Most importantly, pick and choose based on your own judgement and experience those parts that you need and make it your own - in my experience arc42 has always been a good starting point when starting fresh or as a reference when evaluating existing documentation.

Just as a heads up: to my knowledge that's not correct in Germany. It's only highly unlikely to get "abgemahnt" in addition to the difficulty of obtaining IP addresses of users in comparison to alternatives such as Torrents. But not getting caught != legal.

Streaming from a „offensichtlich rechtswidrige Vorlage“ (§ 53 UrhG.) is not legal. That has been clarified by a decision from the EuGH in 2017.

I'm not a lawyer though and this isn't legal advice. Let me know if there have been verdicts and legal proceedings stating the contrary.

Technically there is no way for a lossless synchronization/export out of Google Photos apart from using Google Takeout to the best of my knowledge.

For reference check the best effort project https://github.com/gilesknap/gphotos-sync and the "Known Issues with Google API" section.

In short: * photos lose some metadata including GPS * You will lose your RAW images (AFAIK) * videos are always transcoded with a lossy conversion

I've walked into the same trap. I'll probably use Google Takeout to hopefully recover my own data and treat Google Photos as an ephemeral destination from now on.

I agree with your first sentence.

The "sleazy Ukrainian politician" statement however is quite an accusation, especially considering that the Ukrainian president commended her and all other brave Russians who protest and speak up.

Are you speaking about any politician in particular?

Source: https://www.businessinsider.in/politics/world/news/zelenskyy...

I've seen you mention it before. At first glance it seems interesting and I definitely agree that having multiple perspectives available to view and explore the model of a complex system is key.

It reminds me of https://structurizr.com/ which builds upon the C4 model for visualizing architecture.

Using these tools successfully is also a question of the goal: are we using them to model and plan up-front or are we visualizing the status quo (for onboarding, change analysis or other purposes). If it's the latter then you need to investigate how to (partly) derive the model from the single source of truth - your code base of applications and infrastructure. Otherwise there is a strong likelyhood of the model diverging from the truth and thus losing its value.

I've only had a cursory glance at it but it looks interesting so far. I've had multiple teams struggle with N+1 and inadvertently caused queries with JPA in the past (although it was often related to their poor understanding of JPA itself). In any case I'm interested in any kind of tool which can help debug and prevent these kinds of issues.

So far I was investigating the use of Sniffy ( https://github.com/sniffy/sniffy ) which provides assertion capabilities on the number of queries during the runtime of a JUnit integration test. I'm pairing this with the rest of my JUnit 5 integration test stack (Test Containers, DBUnit, Database Rider and Flyway) which looks promising.

Unfortunately your tool seems to be closely coupled with Spring, correct? Is there a possibility of extracting some of the functionality to work independently of it? I'm thinking of JEE/MicroProfile/CDI based environments, e.g. Quarkus.

This (partly) exists for some mobile carriers.

I know of at least one carrier, but is only usable for their own customer self care portals/apps. There it is possible to auto-login to their app if it is accessed via their network and not via Wi-Fi. For security reasons only a limited amount of functionality is accessible. Neither customer data can be changed nor can any actions resulting in additional cost (buying packs / options) be performed without additional authentication mechanism of a higher security level (auto-login via SMS or use of a password).

The MSISDN is only added to the HTTP request internally in their secure network and never exposed externally.

US President Trump seriously suggested research into injecting bleach to the horror of doctors and medical professionals everywhere: https://www.bbc.com/news/world-us-canada-52407177

It lead to actual problems of US American citizens ingesting/consuming bleach which forced government agencies to put out warnings: https://www.forbes.com/sites/nicholasreimann/2020/08/24/some...

Hi, I only checked it out on my phone for a minute so please don't take my comments too serious.

I think I like the idea and you have some slick visuals on there. Unfortunately not really usable on small screens, but that's a comment issue with anything code related. In any case it might be helpful to see it embedded as widgets in documentation to explain code segments which explain how to use a library or framework as an alternative to annotating the code snippets and having explanations in copy below.

While playing around with it my initial issue was that I wasn't sure if it was going to "play" automatically or if I could control when I was ready to skip to the next step / explanation. The auto play really didn't work for me in the sense that it was either to quick or unexpected. I would prefer to control the pace myself, especially if it's about reading code where I might want to stop and ponder. I think I would like to simply click a next button, perhaps shown as an arrow next to the current "box". A back/previous button next to the restart button wouldn't be nice as well. Hopefully that wouldn't complicate the UI to much.

The next issue was related to my small viewport: I missed the pop-ups because it (at least on Chrome for Android) did not automatically scroll to the next one. I would consider that would be very helpful for longer code segments.

Hope this helps. Good luck and good job in any case.

I can strongly recommend ScreenToGIF [1]. It literally does as the name says but packs in some helpful additional features related to editing.

[1] https://www.screentogif.com/

An interesting alternative to this is Spock [1], a specification framework for Java and Groovy with a nice Groovy DSL. Check out the new reference documentation [2] or try out some specifications using the web console [3].

It has a great syntax for data driven and interaction based syntax.

Data driven example:

  class Math extends Specification {
    def "maximum of two numbers"(int a, int b, int c) {
        expect:
        Math.max(a, b) == c

        where:
        a | b | c
        1 | 3 | 3
        7 | 4 | 4
        0 | 0 | 0
    }
  } 

[2] http://docs.spockframework.org/en/latest/

[3] http://meetspock.appspot.com/