I've begun reading the documentation for CEF, on their wiki, where there's a frequent referencing to a "Browser process" and a "Render process".
As far as I can tell these two terms are never formally introduced. Is there some other documentation available that describes the purpose of these?
Related
I see the term "pure upstream" used a lot describing different software packages/distributions. I get that "upstream" in the context of open source refers to a code base from which a certain software package was forked. But what does it mean to say that a certain software package is "pure upstream"?
I think the “pure” part of "pure upstream" means that the codebase remains unencumbered with changes that are custom changes needed for a particular application use or environment which isn’t applicable to most users. Some projects may want to evolve to become more of a Swiss army knife of an application but some may decide to keep to a small coherent functional space. How purity rules apply is a judgement call for the maintainers of the upstream project.
An example of a non-pure fork could be a proprietary extension that could cause vendor lock-in. Take a look at this article about Kubernetes: https://technative.io/kubernetes-must-stay-pure-upstream-open-source/
I am interested in learning about how Flink works internally, but I am struggling to find documentation on the internal code (like where is a start point of a job) so I am unable to understand the codebase. Is there documentation or some walkthrough for those who want to contribute to Flink itself?
I find that if you understand how some part of Flink works, the source code is generally understandable. The initial challenge then is to have a correct understanding of the expected behavior of the code. To that end, here are some helpful resources:
The best starting point is Stream Processing with Apache Flink by Fabian Hueske and Vasiliki Kalavri.
Any significant development work done on Flink in recent years has been preceded by a Flink Improvement Proposal. These are probably the best available resource for getting a deeper understanding of specific topics and areas of the code.
The documentation has a section on "Internals" that covers some topics.
And there have been some excellent Flink Forward talks describing how some of the internals work, such as Aljoscha Krettek's talk on the ongoing work to unify batch and streaming, Nico Kruber's talk on the network stack, Stefan Richter's talks on state and checkpointing, Piotr Nowojski's talk on two phase commit sinks, and Addison Higham's talk on operators, among many others.
What are the best ways to learn how Flink Architecture (both physical and runtime) is organized and to understand its internal workings (distribution, parallelism, etc.), except from directly reading the code?
How much reliable the papers on Stratosphere (Nephele, PACT, etc.) have to be considered for the current state of the art?
Thank you!
The documentation on their home page explains in detail about the core architecture of Flink. Here's link to it. Also as the company data Artisans is actively supporting the flink project, you can have a look at their training sessions as well.
Since Apache Flink has originated from the Stratosphere project itself, there are similarities but things have changed at the implementation level.
A general question regarding tombstoning WP7 applications. What do you think a users expectations are? And what level of tombstoning support are you providing in your application?
For example, if you have an application that navigates across multiple pages, would a user returning to your tombstoned application expect it to display the last page they viewed?
If so, what if the last page they viewed was a pivot? would they expect it to be at the same location / pivot-page?
Thanks.
Tombstoning can occur under a number of circumstances (including something as simple as answering a phone call) and so your application should appear to be in exactly the same state (or as close to it) as when the user last saw your application.
The operating system handles which page to load for you and the previous page back stack is retained (assuming that you are using standard page navigation within your application). If the page loaded on activation has a Pivot control in it, or other control that supports selection, then yes, the user's selection should be remembered on deactivation and restored on activation.
Charles Petzold's book Programming Windows Phone 7 has a section that covers this in chapter 6. Kevin Marshall has a good blog post that covers WP7 serialization; for the best performance you should use binary serialization.
The whole idea behind tombstoning is that the user gets the perceived functionality of a multi-window environment, i.e. when they switch away from an app and then back to it the state is (largely) unchanged. As you how much functionality you include, that really is up to you but I for one find it frustrating when an app I haven't unloaded forces me to 'restart' my activity with it.
The recommendation is that on returning from a tombstoned state, you should give the impression that nothing has changed and your app is in exactly the state it was when the user left. There are valid occassions to break this rule but they are very much the exception, rather thna the rule. Think very carefully about the user experience if you want to break this rule.
Apps I've used which don't do this come across as frustrating and as though the development was lazy. In turn this makes me* think that they don't fully understand the platform and how to create a good experience. In turn, this make me think I'm more likely to experience errors or bugs in the app.
*-I'm very much NOT a typical user but I think this is still worth considering.
HI
I would like to understand the NFS filesystem in some detail. I came across the book NFS illustrated, unfortunately it is only available as google books so some pages are missing.
Has someone maybe another good ressource which would be a good start to understand NFS at a low level? I am thinking of implementing a Client/Server Framework
Thanks
This is documentation how NFS implemented in the Linux kernel
http://nfs.sourceforge.net/
Other resources are RFC documents
http://tools.ietf.org/
NFS Illustrated is available in dead-tree form - amazon have it in stock (as of a minute ago). The 'Illustrated series are generally pretty good and while I haven't read the NFS one I've got good info from others in the series. If you're considering implementing a full client/server framework for it then it might be worth the money.
As my current field of work is on NFS, I really think you may build some knowledge first on:
Red Hat NFS related Documents:
https://access.redhat.com/documentation/en-US/Red_Hat_Enterprise_Linux/6/html/Storage_Administration_Guide/ch-nfs.html
Microsoft NFS related Documents:
https://technet.microsoft.com/en-us/library/cc753302(v=ws.10).aspx
After you understand the unmapped structure among AD and Unix(It really took me a long period of time), you may get to build some knowledge on sec=krb /krb5i /krb5p by the MIT`s Original Documents ,these are the core of the NFS.