Is there a way to retrieve information from a WebKit build using command-line? I'm particularly interested in retrieving information from the "Inspector Panel" such as the Network panel with resource timing and size info.
The idea is to use the information in a real-time web analysis, speed test project like http://www.webpagetest.org/
Related
I'm working on improving the CDP-based "direct" debugging experience for React Native apps. I'm aware of the CDP reference docs, but haven't found an information source describing how the various CDP messages are meant to be combined to serve debugging scenarios.
Using Chrome Inspect as the debugger frontend, we have some interactions (e.g attaching, setting breakpoints) working. One feature that's missing is the Source view. What CDP interactions would our debugger backend need to implement to effect the population of the Source view? If it is Debugger.scriptParsed events, can the Source view be populated through the sourceMapUrl argument of that event?
I'm trying to follow this guide: https://console.bluemix.net/docs/services/IoT/GA_information_management/ga_im_index_scenario.html#scenario
But as soon as I hit "Manage Schemas" in the device type section I get an "Internal Error", saying I should contact the Admin... I'm not able to create schemas. What's going wrong?
Thanks in advance!
Tom
It is not entirely clear what you are trying to achieve. If you are simply trying to retrieve the raw events that have been published by your device, then you need to use a URL for the form:
/api/v0002/device/types/{deviceType}/devices/{deviceId}/events/{eventName}
This is documented in the Watson IoT Platform API reference.
It is worth noting that, if this is all you are trying to achieve, you do not need to follow the guide that you referenced. It is possible to retrieve the raw events using the REST API simply by defining the Device Type and registering your device.
The guide that you referenced describes the Data Management capabilities of the Watson IoT Platform. These capabilities allow you to process the raw events in order to generate/compute state for the device. This is more involved than simply retrieving the raw events because you need to configure schemas for the events and the state and then define the mappings that tell the platform how to compute the properties on the state when an event is received. The computed state for a device is a different resource and needs to be retrieved using a different URL:
GET /api/v0002/device/types/{typeId}/devices/{deviceId}/state/{logicalInterfaceId}
This is documented here
It's a little confusing, but that Manage Schemas section of the UI is not related to the feature you're looking at as part of the guide you referred to.
The guide you're looking at outlines how to configure event schemas and logical interface schemas for a Device Type using REST API calls. If you wish to create this configuration using the web UI, this is possible too but you need to get to the Interfaces section from the Device Types view: see this image
In this case, I clicked on the Humidity Sensor Device Type and then, in the expanded view, clicked on the Interface tab. From there you can use the Simple or Advanced flows to create the configuration.
The reason for the error is because the component that provides the function on that page (Real time insights) is not present in the eu-de region. The page should not be present but for some reason is.
If you are planning on following that guide then this is a different part of the UI from the “manage schemas” page, and is located under the “interfaces” section in “device types”. The function defined in that guide is available in eu-de.
I am currently looking at various i18n npm packages and most seem to insist that the translations are stored in a flat file, e.g. .json formatted file. My questions is whether this has a performance overhead that would be greater then storing the languages in a database, e.g. MongoDB.
For example, if I have 10,000 translations (we will assume that in this particular application only one language file will be needed at a time, i.e. most will be using the application in English and some users may want to set the application to use a different language.) then this will equate to approximately 200kb of data to download before the application can even start being used.
In a React application, a suggested design pattern is to load data using container components, that then pass data to 'dumb' child components. So, would it not make sense to also load translations in the same manner, i.e. group the translations into usage, or by component, so that the data is sent down the wire only when needed, say, from a call to MongoDB?
I would integrate it in your API. That means you can create e.g. a REST or GraphQL API, which handles this for you. In i18n, it is often reasonable to store the data in a hierarchy. This means you can split your translations in different categories (like pages) and simply request those translations, which you really need.
I really like the way of doing it in the react-starter-kit. In this example, you find how they handle it with a GraphQL API and only request those translations, which are really required for rendering the page. Hope this helps.
Important files of the i18n implementation of the react-starter-kit:
GraphQL Query: https://github.com/kriasoft/react-starter-kit/blob/feature/react-intl/src/data/queries/intl.js
Example component implementation: https://github.com/kriasoft/react-starter-kit/blob/feature/react-intl/src/components/Header/Header.js
Of course if you have this amount of translations, I would use a database for a better system usage (in the react starter kit, they use simple file storage which is not really usable with so many translations). A mongodb would be there my first choice, but maybe this is only my own preference of flexibility and own knowledge.
Obviously, you don't want each and every language to be loaded on the client. My understanding of the pattern you described is to use a container component to load the relevant language for the whole app on startup.
When a user switches language, your container will load the relevant language file from the server.
This should work just fine for a small/medium app but has a drawback : you'll need another request to the server after the JS code has loaded to load the i18n data.
Another way to solve this is to use code splitting (and possibly server side rendering) techniques which could allow this workflow :
Server builds a small bundle containing a portion of the i18n data
Client loads the rest of your app code and associated i18n data on demand, as the user navigates through your app
If not yet done having a look at https://react.i18next.com/ might be a good advice. It is based on i18next: learn once - translate everywhere.
Your code will look something like:
<div>{t('simpleContent')}</div>
<Trans i18nKey="userMessagesUnread" count={count}>
Hello <strong title={t('nameTitle')}>{{name}}</strong>, you have {{count}} unread message. <Link to="/msgs">Go to messages</Link>.
</Trans>
Comes with samples for:
- webpack
- cra
- expo.js
- next.js
- storybook integration
- razzle
- dat
- ...
https://github.com/i18next/react-i18next/tree/master/example
Beside that you should also consider workflow during development and later for your translators -> https://www.youtube.com/watch?v=9NOzJhgmyQE
Context: Eclipse 4 platform RCP presentation layer (on top of a SOA backend)
1) ¿Where is the best place to store authenticated user information (HttpSession-like store, including security sensitive data)?
2) ¿Is there any advice or best practice on how to implement SWT widget/control enablement/visibility based on user permissions/profiles? (swt presentation logic being in its own bundle, agnostic of any authorization logic).
I read that in version 3.x this could be done with org.eclipse.ui.activities, there is something like that in E4?
Thanks
In Eclipse 4 we store most things in the model. For 'global' info like sign-ins / session data would be in the MApplication's 'persistentData' field, likely with one entry per userId.
* but * calling this secure is a flat lie; the model is an open book so anybody could find the info. Encryption is up to you (as is how truly secure the result is, Eclipse makes no effort to be secure internally...
As far as modifying the UI is concerned then if it's just a matter of tweaking what a person can see it's not too bad. You can find all the elements in the model and individually set their 'toBeRendered' state to false if they shouldn't be available; true if they should. This will likely work for many things but you may find that you'll have to tweak up your command's 'visibleWhen' clauses to ensure that the system doesn't make them show up again.
i am sapna.and we have to develop an application in an iphone having features:-
Identifies a unique user and captures profile.
Admin module / configuration module to assist user define the data points and their bound values.
Support of upto 250 data points to monitor, and monitor upto 50 on the client side
Provide tabbed interface with not more than 10 points of data grouped in a single tab / tag
Output to be generated in text and graphical form
Support iphone features of touch etc
Web service to retrieve point data from the database.
we have learnt that mac os and iphone sdk is required.now for data transfer what is reqiured ? is it API.or web services.what is reqiured.what topics ahoulkd be studied for developing this project.i am fully new to this domain.waiting for your reply.
HTTP rest requests are very easy, and can be architected as non-blocking on the client side. The iPhone has minimal support for XML and JSON is far easier (IMHO) using one of the json libraries such as those here.
You may want to use the deviceID as the unique user identifier (depends on your definition of unique I guess)
To learn iPhone programming, I can highly recommend the CS193P course available (at the moment) on iTunesU.
For web transfers, you can do HTTP REST very easily so I would architect your server side to talk very simple HTTP. There is built-in support for XML, but you will have to parse results from the server manually.
For Tab UI support, you can just look at the examples included in the SDK, it's not difficult.
For graphical output, you will want to create your own UIViews that override the draw function. You will have to learn the CoreData API in order to produce high-quality renderings.
If you are new to this, and are more familiar with C# or even Java, I highly recommend looking at the MonoTouch system.
First of all u need a Mac based system and the iPhone SDK installed. I think you are trying to make an iphone version of the web application. it will be better for you to download the MAMP(Macintosh Apache MySQL PHP) Server and install it to debug your application. its simply the mac version of WAMP and LAMP. (hope you are familiar with PHP).
You can then configure you MAMP for debugging and once the debug is complete you can host these PHP files to the actual server.
Remember, you need to get the results from the server in the XML format. and you need to write code to parse the XML you generated at the server.
Hope this information is helpful.