Google’s ‘Open YOLO’ project aims to make managing passwords easier

Search giant Google is working with Dashlane and other password manager firms on an open API named 'Open YOLO'. Short for You Only Login Once, the Open YOLO project is aimed at making it simpler for users to manage passwords with Android apps .

The company wants to help Android users by providing them with a hassle free login process. With Open YOLO, users will just have to link their favourite password manager to their Android device having the apps. The apps will then start pulling the password details automatically.

Dashlane, in an official blog post said, "Dashlane and Google , along with other leading password managers are collaboratively developing 'Open YOLO' (You Only Login Once) - an open API for App Developers that will give Android apps the ability to access passwords stored in your favourite password manager, and effortlessly and securely log you into those applications."
The company further added, "Dashlane is spearheading the collaboration with other top password management companies, who will contribute their unique security and software development expertise to improve the design and implementation of this open API."

The project is the first big step towards making security simple and accessible for every user, on every device. In future, Google plans to see Open YOLO API going beyond just Android devices, and becoming universally-implemented by apps and password managers across every platform and operating system.


Copy From - http://timesofindia.indiatimes.com/tech/tech-news/Googles-Open-YOLO-project-aims-to-make-managing-passwords-easier/articleshow/53603728.cms

ASP.NET Application Optimization Tips

The application server or load-balanced servers might enhance Web application performance; however, there are ways to enhance performance on the developer side as well. By following certain optimization techniques while you are writing your application code, you can also reduce a lot of performance issues. It is essential to understand which parts of your code can be optimized, and how you can measure improvements in performance compared to a baseline.

• Use the connection pooling so that the connections can be re-used when future requests to the database are required.
• Dispose of objects properly from the caller method than in the called method.
• Reduce page load times by techniques such as minimizing the scripts. Use script file references in pages to enable the client to cache these scripts for subsequent requests.
• Remove white spaces and extra tags to dramatically reduce the size of your pages. Limit the use of graphics and consider using compressed graphics.
• Consider using cascading style sheets to avoid sending the same formatting directives to the client repeatedly.
• Control names should be short because they generate unique HTMLID names. If a control is used inside nested controls, a 10-character control name can easily turn into 30 to 40 characters.
• Use Page.IsPostBack to minimize redundant processing.
• Use for each loop in place of a for loop if possible.
• You should avoid using ViewState to facilitate faster page loads. Remove the runat="server" form tag from your Web page if you don't need to use ViewState to save bytes of the page size. Enabling its ViewState would incur, for every byte that is added, becoming two bytes due to network traffic that is from the server to the client and the other from the client to the server.
• Cache the Web pages or portion of the Web pages if the page is large. Use data caching for boosting the application performance instead of fetching data from a file or database.
• As the datasets store data in memory, write efficient SQL queries or procedures that fetch only the information needed. Analyze the WHERE clause in your queries and be specific to ensure that the needed number of rows and columns are returned and take the advantage of indexes while writing queries.
• Consider Using Server.Transfer instead of Response.Redirect because Response.Redirect sends a metatag to the client that makes the client send a new request to the server by using the new URL. Server.Transfer avoids this re-direction by making a server-side call.
• Avoid using Page.DataBind. Instead, call data bind on specific controls because the page-level method in turn calls the DataBind method of every control on the page that supports data binding.
• Minimize calls to DataBinder.Eval because this method uses reflection to evaluate the arguments that are passed in and to return the results. For example, if a page has a table with 50 rows and 10 columns, DataBinder.Eval will be called 500 times if you use DataBinder.Eval on each column. Instead, using explicit casting offers better performance by avoiding the cost of reflection. Cast the Container.DataItem as a DataRowView, as shown in the following code snippet.

• Use SqlDataReader to visit the read-only data instead of DataSet.
• Although you can return multiple result sets by using dynamic SQL, it is preferable to use stored procedures to get multiple result sets.
• Using gzip compression can decrease the number of bytes sent by the server. This gives the perception of faster page loads and also cuts down on bandwidth usage.
• If you got a bunch of .NET Web services running in one IIS Application and consumed by another IIS application, the first call to Web services, in many cases, can be pretty slow, about 5 to 10 seconds or more sometimes; subsequent calls will be in milliseconds. To speed up the initial call, you can create the XmlSerializers DLL at compile time.
  
  
  

  Conclusion

  In my previous article, "ASP.NET Performance Improvements and VS2015 Profiler," I showed how you can use the Visual Studio 2015 diagnostic tools that integrate application profiling with the debugging so that you can observe the CPU usage, memory usage, HTML UI responsiveness, thread activity timeline, and profiler for performance. By using what I presented in that article along with the optimization tips you've learned here, you have the tools for writing high quality code where you can catch and fix performance and other issues in development as well as after deployment.
  
  
  Copy From http://www.codeguru.com/csharp/.net/net_asp/asp.net-application-optimization-tips.html