According to Firebase Performance Monitoring Documentation,
Known issues include:
Performance Monitoring has known compatibility issues with GTMSQLite.
We recommend not using Performance Monitoring with apps that use
GTMSQLite.
Which among the tools are using GTMSQLite? Is there a list somewhere in the documentation?
Knowing these tools will greatly help to avoid unexpected issues while using Firebase Performance Monitoring. Thanks!
No other Firebase SDKs use GTMSQLite. The warning is for either the developer's own usage of or other dependencies outside of Firebase which use GTMSQLite.
The issue is primarily the result of GTMSQLite inability to be made into a cocoapod (see https://github.com/google/google-toolbox-for-mac/blob/b3f485cab2c80a9e685205135d6a63299fe3c394/GoogleToolboxForMac.podspec#L89).
It's not a commonly used library and if there are issues, you'll generally end up with linker errors (symbol collisions).
We're evaluating eliminating this dependency in future versions...
Related
On rnfirebase.io there's no longer any documentation about Admob integration, and I believe I read that it wasn't supported anymore. Would the analytical parts of react-native-firebase/app (e.g. /analytics) work with the react-native-google-mobile-ads module or other similar modules that integrates Admob.
Thanks in advance.
I am adding a typescript project to a VS2015 MVC 5 project (that makes it ASP.NET 4, not asp.net 5 or asp.net 6 code: only the MVC is version 5). This is the sole target for all aspects of my question, I cannot use generalized or theoretical guidance on typescript, node.js, module loaders, etc.
The problem is simpler with ASP.NET Core. But that's not what I'm facing. All the usual sources of examples and guidance avoid or provide scraps when it comes to ASP.NET 4 MVC 5 because it is hard. And no one will state exactly how hard or what precisely are the obstacles.
Worst, Typescript documentation is like Open Source Documentation: you can only get one issue, one step deep. This produces a research workflow consisting of endless-issue-tree-recursion.
I understand opinions, I even have one. But I'm looking for the experiential answer, what is the one combination that has proven to work for a production team.
So here are the specific items that need to be addressed and made to work within the confines of a working, medium-sized ASP.NET 4 MVC 5 LOB app:
Visual Studio's version of typescript. This is an installation issue (using node most simply) and the Tools/options - typescript settings have to match.
Browser-style testing (typically manual TDD workflow) or node.js testing (automated). This has to be chosen up-frontly to prevent more issue-tree-recursion. We are going with browser-based... phantomjs using WallabyJs.
NPM #types/library-name: supposed to fill a node_modules folder with both library-name and library-name.d.ts based only on a package.json with #Types references. But actually requires the package.json to hold a reference for both the #types/library-name and the library-name to work in my VS 2015 ENT v3 and asp.net 4 mvc 5 project. And all the versions specified then require manual correction' and even then the version look-up process is a little suspicious. This #types process may not be the way to go with ASP.NET 4 MVC 5, but I can't tell what the correction alternative might be. #Types is currently the only recommended option for typescript.
Which version of ECMAScript: es6 is apparently too far ahead. es2015 is likely, but this (maybe) appears to have relationships to several of the other issues. Supposedly, these designations are the same, but there are two places they can be set. I've chosen es2015 in tools/options/typescript. But getting any of these (now 3) settings wrong could be a problem.
Module system: CommonJs is for node and automated testing, and VS development testing is automated only for server-side, and VS UI tests are a manual process. So AMD, require JS is probably an option for VS, but it adds its own workflow and maintenance and considerations that are really hard to get right in ASP.NET. Using ASP.NET bundling and triple-slash references (dependable) might work, but after you have put the libraries in node-modules, you would want to use the full path into node-modules in the file name slug in an import statement. This is all very clumsy and involves the most guesswork. But solving this whole item might be the 'key' for the overall question.
There are probably a lot of other, smaller issues. But someone who has done this will have solved all the mentioned items and the others as well.
What I'm looking for is all the settings across all these issues in detail based on a working Typescript app in ASP.NET 4 MVC 5 implementation for browser-based unit/behavior tests in VS 2015. Those who have done it will understand.
Thanks very much for your consideration.
What you're missing is separation of concerns, in spite of the initial benefit of such starter templates, they start to cause incidental dependencies and complicate the mental model. It's much easier to have your front end in a separate project.
Regardless:
Visual Studio's version of typescript.
Always use the very latest available. This controls the version of TypeScript which powers the IDE. You will probably end up compiling in a separate process or in the browser during development. Again you will want to use the latest but it will likely be installed with a different package manager.
Browser-style testing (typically manual TDD workflow) or node.js
testing (automated). This has to be chosen up-frontly to prevent more
issue-tree-recursion.
Firstly, I definitely agree with the importance of choosing up front but, if it is still possible, just unpleasant, to add tests to an existing project.
TDD workflows involve automated testing as they rely on rapid feedback. This is orthogonal to whether you run your tests in the browser or using NodeJS.
You should use whichever approach makes the most sense for your application and that may be a mix of both.
Since you are writing a frontend JavaScript application you will likely want to run some tests in the browser. However, as Uncle Bob (Robert C. Martin) has stated, views should be dumb and require little testing. My interpretation of this is that we should not spend too much time testing things like Angular or React components to ensure that they render correctly, and instead focus on testing behavioral elements of the system such as services and plain old functions.
That said, you may well want to run tests of your client side services against an actual browser runtime, as opposed to just Node.js, and that is reasonable.
There are a number of testing libraries to help you with this. I do not have a specific recommendation besides to say that you should find a reliable test runner, and a simple assertion library. Tried and true testing libraries like QUnit and Tape are examples of solid options.
One last note, it is important that one not confuse the concept of integration testing with running tests in a web browser, it's perfectly valid to run TDD style tests, which implies unit tests, in a web browser.
NPM #types/library-name: supposed to fill a node_modules folder with
both library-name and library-name.d.ts, but requires the package.json
to hold a reference for both the #types/library-name and the
library-name to work in my VS 2015 ENT v3 and asp.net 4 mvc 5 project.
Simply put this goes to back to decoupling your front end from your back end. Visual Studio and certainly ASP.NET have nothing to do with versioning your types packages.
If a package comes with its own type declarations then you don't need to install an auxiliary types package otherwise you do.
Either way install JavaScript and TypeScript dependencies using a JavaScript oriented package manager (such as NPM, JSPM, or Yarn).
Do not use NuGet for these!
As you suggest there are versioning issues, it's currently a difficult problem in TypeScript. However once again it has nothing to do with ASP.NET or Visual Studio.
Which version of ECMAScript: es6 is apparently too far ahead. es2015
is likely, but this appears to have (maybe) relationships to several
of the other issues.
ES6 is the same as ES2015, the latter being the name under which the former was ultimately released. ECMAScript now follows a yearly cadence, roughly, with ES2017 just around the corner.
The nice thing about having a transpiler, such as TypeScript, is that you can use the latest features from es2017 and still target es5 for emit and you'll be fine.
Module system: CommonJS is for NodeJS and automated testing, and VS
development testing is automated only for server-side, and VS UI tests
are a manual process. So AMD/UMD require JS is probably the option for
VS, but it adds its own workflow and maintenance and considerations.
Using triple-slash references (dependable) might work, but after you
have put your/their libraries in node-modules you would want to use
the full path into node-modules in the file name slug in an import
statement. (solving this whole item might be the 'key' for the overall
question).
This is a very complex subject and probably the only one of your questions that you really need to spend a lot of time considering. As I said earlier using NodeJS or not is orthogonal to automated testing. But if you're targeting NodeJS natively with your test code then you will need to use CommonJS output.
For the actual application code, the choice has nothing at all remotely to do with whether or not you are using Visual Studio, I'm sorry for reiterating this but it really is important that you separate these ideas.
The question of which module format to use for your front end application code is a very important and contentious one.
Triple /// references are not a module format but rather a way of declaring the dependencies between global variables that are declared and referenced across multiple files.
They do not scale well, working acceptably when you have only a handful of files.
Triple /// references should not be used. They are not a modularity mechanism and their use is completely different from using any of the module systems/module formats you mention, including CommonJS.
Never combine them with a module system, which is what you would have to do in order to run your tests under NodeJS or load your app with RequireJS or anything else.
RequireJS is an excellent option which would imply AMD modules as you say. RequireJS does not require any use of triple slash references. In fact they should be avoided as the plague when using this format or any other module format!
I recommend strongly against using UMD modules. Isomorphic JavaScript is a problematic idea, and it offers you no benefits since you are creating a browser application with a .NET backend.
Many developers actually do use CommonJS modules in a browser. This requires bundling them continuously, using tools such as Webpack. This approach has advantages and disadvantages. The primary advantages are the ability to lean on existing NodeJS JavaScript server-side tools, such as npm, by way of Webpack or Browserify. This may not sound like a big advantage but the amount of rich tooling available for CommonJS modules is nothing to scoff at, making it a strong option.
Consider using the System module format and the SystemJS loader via jspm to both manage your packages and to load your code. With this approach, you gain the advantages of RequireJS, are able to run your tests under NodeJS and the browser using jspm run without needing to switch targets formats or bundle your code just to test it. There's also no need to bundle your code during development, although this is supported. More importantly, you gain the advantage of writing future compatible code, as it offers the only module format and loader which correctly models the semantics that ES Modules will eventually have when implemented natively in browsers. JSPM has first class support for TypeScript, Babel, and Traceur.
For posterity here is the description of the System module format taken from the link above:
System.register can be considered as a new module format designed to support the exact semantics of ES6 modules within ES5. It is a format that was developed out of collaboration and is supported as a module output in Traceur (as instantiate), Babel and TypeScript (as system). All dynamic binding and circular reference behaviors supported by ES6 modules are supported by this format. In this way it acts as a safe and comprehensive target format for the polyfill path into ES6 modules.
Disclaimer:
I am a member of the JSPM GitHub organization, playing a role in maintaining the registry and have made very minor contributions to the jspm cli.
I've been looking at options for persistence when using RxSwift and Realm was looking attractive due to it's relative simplicity and the availability of some extensions in the community repo.
Unfortunately although I can get Realm and RxSwift working nicely in Xcode 8b6, things of seriously wrong as soon as you try to connect them together as RxRealm does not currently compile (there seems to be more going wrong with it than the Grand Renaming as far as I can tell).
Is there a workaround that is reliable? I can't believe for a moment that there isn't, I just can't find a resource at present. I was thinking of converting the Result object into an Set or Array and making this Observable but. I'm not sure if the contents (Realm Objects) are going to be handled correctly. Knowing my luck, I suspect not!
There's a Pull Request towards the RxRealm project adding Swift 3 support: https://github.com/RxSwiftCommunity/RxRealm/pull/26
I suggest you try using that.
More generally, targeting an Xcode beta will by definition give you a less stable software ecosystem, since no one is submitting apps with that and it's a moving target (often with weekly breaking changes). So if you want stable software, use stable tools. Realm and RxRealm both support Swift 2.2 quite well, so using that will give you the best experience.
Being that Meteor on Windows does not currently support Velocity/Jasmine, I would like to use a cloud-based solution for running Meteor with Velocity. But so far I have not had success. I have tried Nitrous, Codeanywhere, Koding, and Cloud9.
I also use the Meteor Windows Preview and the same issue. See my SO: Easiest way to create mobile apps on official Meteor for Windows
I had the additional constraint that I want to compile Mobile Apps which is currently not supported by the Windows Preview.
I've not had success with cloud-based solutions either beyond very basic test apps. The whole chain is just too fragile, there's often something you need to configure that you can't get at in a cloud solution. Basically, your options are:
Vagrant
Dual-boot (thanks #sbking)
Buy a Mac
I would recommend 3 because it will save you time (and therefore money). The first 2 are fiddly, just adding more sys admin work when we should all be coding :)
ALTERNATIVELY
Switch testing tools to Laika. See related SO: Laika vs Velocity on meteor TDD
Laika (apparently) still works for the moment, even though it is no longer officially supported. I will be using it for my current project in the next few weeks.
I'd be really interested to hear what solution you go for.
At the risk of offering you a pocket-knife when you want a power-tool, there is a meteor package, jasmine-green, that does not require Velocity and therefore works well with Cloud9. While this means that you would not have the full capabilities of a velocity-based jasmine or mocha package, it is a lot better than nothing. Just type:
meteor add fongandrew:jasmine-green
It might be a stopgap while you find a better long-run solution.
I am trying to connect my tessel to firebase, and I have tried everything. Is anyone else having a similar problem? I have read that the tessel uses different web sockets than firebase, but I am really new and don't know much about that. Could anyone help me out?
Glad to hear that people are interested in using Firebase with the Tessel. I'm one of the Firebase engineers who has been working with the Tessel folks to make this happen. There are two Tessel Forum posts that give some more detail on the problem:
Firebase cannot be compiled by Colony
Websockets on Tessel
The Firebase node packages uses faye-websockets, which the Tessel compiler couldn't support. We got nodejs-websockets to compile, and built a version of the Firebase library to test the concept. I was able to read and write from Firebase using the Tessel, but we were very hesitant to release a separate version of Firebase to NPM just for use on the Tessel, especially since nodejs-websockets is not as well maintained as faye-websockets. I then spent an evening working with the Tessel folks to get faye-websockets working, and it now compiles, with the changes sitting out on a branch (tessel/runtime/JH-HTTPParser). I don't have a timeframe on these getting merged into Master and being shipped out to production, but I know there are a good number of SSL and websocket based API's who are waiting on these changes to hit the main branch.
TL;DR: Firebase compiles on the Tessel (you can build the code off the above branch), and it can either read or write (not both at the same time). When I get some more time, I will be debugging Tessel + Firebase to get this working correctly.
With the acquisition I haven't had much time to try. Last time I checked, things were compiling and running for some operations (I haven't tested everything) if we used a non-minified version of the Firebase library (not currently provided to end users). The issue here is that the minification puts all the variables in the same line, and the Tessel Lua VM would complain that there were more than 200 variables and wouldn't like it. I can play around with it some over the next week and see where things are, otherwise I can ping Jon and the Tessel folks to see how we can best move this issue along.
I am using SynergyKit for realtime communication. You can download Node.js library, which is fully supported by tessel platform and using websocket library, which is one of few libraries written in pure javascript.
You will be able to live observing all data in collections and sending messages. There is documentation for Node.js.