architecture | overarching documentation for o2r microservices | Continuous Deployment library

The problem is that your document class already selects a bibliography style, which you can't change afterwards. Two workarounds:

• use the style your document class sets by removing \bibliographystyle{IEEEannot} from your code

• if you actually do need the other style, save olplainarticle.cls under a new name and change l.8 \ProvidesClass{olplainarticle}[06/12/2015, v1.0] to the new name, remove line 43/44 \RequirePackage{natbib} \bibliographystyle{apalike} from the new .cls file and then change \documentclass{olplainarticle} to the new name

Add

Answering my own question in a hope to help others who are having similar problems. (and until a good answer is added from another user)

I found out that GoogleWebRTC actually requires its source to be compiled with x64 based on its source depo.

For builds targeting iOS devices, this should be set to either "arm" or "arm64", depending on the architecture of the device. For builds to run in the simulator, this should be set to "x64".

https://webrtc.github.io/webrtc-org/native-code/ios/

This must be why I was getting the following error.

building for iOS Simulator, but linking in dylib built for iOS, file '/Users/andy/workspace/app/Pods/GoogleWebRTC/Frameworks/frameworks/WebRTC.framework/WebRTC' for architecture arm64

Please correct me if I am wrong, but by default, it seems that Xcode running in Apple M1 silicon seems to launch iOS simulator with arm arch type. Since my app did run fine on simulators in Intel Mac, I did the following as a workaround for now.

1. Quit Xcode.
2. Go to Finder and open Application Folder.
3. Right click on Xcode application, select Get Info
4. In the "Xcode Info Window" check on Open using Rosetta.
5. Open Xcode and try running again.

That was all I needed to do to make my app, which relies on a library that is not yet fully supported on arm simulator, work again. (I believe launching Xcode in Rosetta mode runs simulator in x86 as well..?? which explains why things are working after making the above change)

A lot of online sources (often posted before M1 Mac launch on Nov/2020) talks about "add arm64 to Excluded Architectures", but that solution seems to be only applicable to Intel Mac, and not M1 Mac, as I did not need to make that change to make things work again.

Of course, running Xcode in Rosetta mode is not a permanent solution, and Xcode slows down lil bit, but it is an interim solution that gets things going in case one of libraries that you are using is not runnable in arm64 simulator.. yet.

The solution you're looking for depends on how your app is designed. There are several things you can try out:

• Keep your app modularized - as @ADM mentioned split your repository into smaller
• Move live data out of repository - it is unnecessary to keep live data in a repository (in your case singleton) for the entire app lifecycle while there might be only few screens that need different data.
• That's being said - keep your live data in view models - this is the most standard way of doing. You can take a look at this article that explains Retrofit-ViewModel-LiveData repository pattern
• If you end up with complicated screen and many live data objects you can still map entities into screen data representation with events / states /commands (call it as you want) which are pretty well described here. This way you have single LiveData and you just have to map your entities.

Additionaly you could use coroutines with retrofit as coroutines are recomended way now for handling background operations and have Kotlin support if you wanted to give it a try.

Also these links might halpe you when exploring different architectures or solutions for handling your problem architecture-components-samples or architecture-samples (mostly using kotlin though).

There isn't really a good reason other than we don't bother testing the control plane on Windows. In theory it's all just Go daemons that should compile fine on Windows but you would be on your own if any problems arise.

There are two options I know of.

First, you can have buildx run builds on multiple nodes, one for each platform, rather than using qemu. For that, you would use docker buildx create --append to add the additional nodes to the builder instance. The downside of this is you'll need the nodes accessible from the node running docker buildx which likely doesn't apply to ephemeral cloud build environments.

The second option is to use the experimental docker manifest command. Each builder would push a separate tag. And at the end of all those, you would use docker manifest create to build a manifest list and docker manifest push to push that to a registry. Since this is an experimental feature, you'll want to export DOCKER_CLI_EXPERIMENTAL=enabled to see it in the command line. (You can also modify ~/.docker/config.json to have an "experimental": "enabled" entry.)

Does everything on the World Wide Web use REST?

Sort of.

REST is an architectural style, the "coordinated set of architectural constraints" used in the development of the HTTP 1.1 standard in the 1990s. Notice that Roy Fielding, who describes RESTin the dissertation he published in 2000, is also the first author listed in RFC 2616 (and more recently, RFC 7230).

In chapter six of his dissertation, Fielding observes:

Like most real-world systems, not all components of the deployed Web architecture obey every constraint present in its architectural design.

The tracking of client application state is a common example; the web, as it is today, doesn't offer us a common, general purpose mechanism for tracking state in our clients. So instead, web designers resort to tracking that state on the server, either by using resources specific to a user (see REST mismatches in URI) or by using cookies as a hidden mechanism for tracking history on the server (see REST mismatches in HTTP).

In other words, the web we use every day isn't a perfect expression of the REST architectural style.

Further more, you have ideas like SOAP or GraphQL, where important semantic information about a message is not expressed in a standardized form, which means that our general purpose components cannot assess the semantics of the messages and take intelligent actions.

are all, essentially, web services, RESTful

No - not unless you limit yourself to a definition of "web services" that excludes implementations that violate REST.

Finding web implementations that are architecturally aligned with remote procedure calls, rather than REST, is common. See Fielding 2008. Special note: read the comments, which contain a lot of useful Q and A.

I found the problem. Problem was that scipy was missing in my anaconda virtual environment. I thought scipy was installed when I saw;

AttributeError: module 'scipy.ndimage' has no attribute 'interpolation'

Thanks for the tip @simpleApp. And I'm sorry to bother you with the mistake of absent-mindedness... Solution is the installing scipy.

you can try the approximate_row_count() function (https://docs.timescale.com/api/latest/analytics/approximate_row_count/) which gives an immediate result.