on 01-Sep-2020 (Tue)

Spread system. Banks to calculate on monthly basis.

RBI introduced _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ (MCLR) +

Spread system. Banks to calculate on monthly basis. It consists of CRR Cost, Operating Cost, Marginal cost of funds (Repo Rate, Deposit Interest) etc. - Benefits? Better transmission of Monetary Policy; transparency & accountability to borrowers. Although RBI s Janak Raj internal stud group (2017) showed MCLR did not ield all benefits so ne method

2019, 1 st April - NEW loans (not existing loans) to be linked ith _ _ _ _ _ _ _ _ _ Benchmark + Spread s stem. 1 Category of Loans = 1 External Benchmark. - Individual bank free to pick any one External Benchmark such as RBI repo rate (6.50%) or 91-day T-bill yield (6.56%) or 182-day T-bill yield (6.73%) or any other benchmarks by Financial Benchmarks India Pvt. Ltd. - Benefits? Same benefits which MCLR couldn t full deli er.

k is regularly updated. So resultant interest rate may increase or decrease throughout the tenure of loan. Teaser Loan: A sub-type of _ _ _ _ _ _ _ interest rate loan, wherein initial years have low interest, but afterwards- higher interest rate. While RBI has not banned Teaser loans but has put stricter regulations on them from 2011. Benchmark Prime Lending Rate Magical Cost of funds based alending

With Ajax, web applications can send and retrieve data from a server asynchronously (in the background) without interfering with the display and behaviour of the existing page. By decoupling the data interchange layer from the presentation layer, Ajax allows web pages and, by extension, web applications, to change content dynamically without the need to reload the entire page.^[3] In practice, modern implementations commonly utilize JSON instead of XML

Ajax is not a single technology, but rather a group of technologies. HTML and CSS can be used in combination to mark up and style information. The webpage can then be modified by JavaScript to dynamically display—and allow the user to interact with—the new information. The built-in XMLHttpRequest object, or since 2017 the new "fetch()" function within JavaScript, is commonly used to execute Ajax on webpages, allowing websites to load content onto the screen without refreshing the page. Ajax is not a new technology, or different language, just existing technologies used in new ways.

Domain isolation also makes it very difficult to build lightweight low-infrastructure Web applications that slice and dice data drawn from diverse data servers within a corporate network. A foo.bar.com subdomain on your internal bar.com corpnet is just as isolated from bar.com and bee.bar.com as it is from external addresses like xyz.com.

Nevertheless, you don't want to just tear down all the walls and pass around posies. The threats to data and personal security that the browser's strict domain isolation policy protects against are real, and nasty. With careful consideration and infrastructure, there can be a happy medium that provides greater benefit to the user while still maintaining the necessary security practices. Users should be in control of when, what, and how much of their information is available to a given Web site. The objective here is not free flow of information in all directions, but freedom for users to use their data where and when it serves their purposes, regardless of where their data resides.

What is needed is a way for the browser to support legitimate cross-domain data access without compromising end user safety and control of their data.

One major step in that direction is the developing standards proposal organized by Ian Hickson to extend xmlHttpRequest to support cross-domain connections using domain-based opt-in/opt-out by the server being requested. (See Resources.) If this survives peer review and if it is implemented by the major browsers, it offers hope of diminishing the cross-domain barrier for legitimate uses, while still protecting against illegitimate uses. Realistically, though, it will be years before this proposal is implemented by the major browsers and ubiquitous in the field.

What can be done now? There are patterns of behavior supported by all the browsers which allow JavaScript code living in one browser domain context to observe changes made by JavaScript living in another domain context within the same browser instance. For example, changes made to the width or height property of an iframe are observable inside as well as outside the iframe. Another example is the iframe.src property. Code outside an iframe cannot read the iframe's src URL property, but it can write to the iframe's src URL. Thus, code outside the iframe can send data into the iframe via the iframe's URL.

This URL technique has been used by Web designers since iframes were first introduced into HTML, but uses are typically primitive, purpose-built, and hastily thrown together. What's worse, passing data through the iframe src URL can create an exploit vector, allowing malicious code to corrupt your Web application state by throwing garbage at your iframe. Any code in any context in the browser can write to the iframe's .src property, and the receiving iframe has no idea where the URL data came from. In most situations, data of unknown origin should never be trusted.

This article will explore the issues and solution techniques of the secure client-side cross-domain data channel developed by the Windows Live Developer Platform group.

The term Ajax has come to represent a broad group of Web technologies that can be used to implement a Web application that communicates with a server in the background, without interfering with the current state of the page. In the article that coined the term Ajax,^[1][3] Jesse James Garrett explained that the following technologies are incorporated:

• HTML (or XHTML) and CSS for presentation
• The Document Object Model (DOM) for dynamic display of and interaction with data
• JSON or XML for the interchange of data, and XSLT for XML manipulation
• The XMLHttpRequest object for asynchronous communication
• JavaScript to bring these technologies together

With that, the above snippet of code re-written using Scalatags looks as follows:

 package webpage import org.scalajs.dom import dom.html import scalajs.js.annotation. JSExport import scalatags. JsDom .all._ @JSExport object HelloWorld1 extends { @JSExport def main ( target: html. Div ) = { val ( animalA, animalB) = ( "fox" , "dog" ) target.appendChild( div( h1( "Hello World!" ), p( "The quick brown " , b(animalA), " jumps over the lazy " , i(animalB), "." ) ).render ) }
}

Hello World!

The quick brown fox jumps over the lazy dog.

webpage.HelloWorld1().main(document.getElementById('example5'))

Scalatags has some nice advantages over plain HTML: it's type-safe, so typos like dvi get caught at compile-time. It's also secure, such that you don't need to worry about script-tags in strings or similar. The Scalatags Readme elaborates on these points and other advantages. As you can see, it takes just 1 import at the top of the file to bring it in scope, and then you can use all of Scalatags' functionality.

To begin with, let's define our list of items: Fruits!

 val listings = Seq ( "Apple" , "Apricot" , "Banana" , "Cherry" , "Mango" , "Mangosteen" , "Mandarin" , "Grape" , "Grapefruit" , "Guava" )

Next, let's think about how we want to render these fruits. One natural way would be as a list, which in HTML is represented by a < ul > with < li > s inside of it if we wanted the list to be unordered. We'll make it a def , because we know up-front we're going to need to re-render this listing as the search query changes. Lastly, we know we want 1 list item for each fruit, but only if the fruit starts with the search query.

 def renderListings = ul( for { fruit <- listings if fruit.toLowerCase.startsWith( box.value.toLowerCase ) } yield li(fruit)
).render

Using a for -loop with a filter inside the Scalatags fragment is just normal Scala, since you can nest arbitrary Scala expressions inside a Scalatags snippet. In this case, we're converting both the fruit and the search query to lower case so we can compare them case-insensitively.

Lastly, we just need to define the input box and output-container (as we did earlier), set the onkeyup event handler, and place it in a larger fragment, and then into our target:

 val output = div(renderListings).render box.onkeyup = (e: dom. Event ) => { output.innerHTML = "" output.appendChild(renderListings)
} target.appendChild( div( h1( "Search Box!" ), p( "Type here to filter " + "the list of things below!" ), div(box), output ).render
)

The first import brings in Scala adapters to several DOM APIs, which allow you to use them more idiomatically from Scala. The second brings in an implicit scala.concurrent. ExecutionContext that we'll need to run our asynchronous operations.

Then we need the code itself:

 val url = "http://api.openweathermap.org/" + "data/2.5/weather?q=Singapore" Ajax .get(url).onSuccess{ case xhr => target.appendChild( pre(xhr.responseText).render )
}

webpage.Weather1().main(document.getElementById('example11'))

A single call to Ajax .get(...), with the URL, and we receive a scala.concurrent. Future that we can use to get access to the result when ready. Here we're just using it's onSuccess, but we could use it in a for-comprehension, with Scala Async, or however else we can use normal Future s

This sets up the basics: an input box, an output div, and sets an onkeyup that fetches the weather data each time you hit a key. It then renders all these components and sticks them into the target div. This is basically the same stuff we saw in the early examples, with minor tweaks e.g. adding a maxHeight and overflowY:= "scroll" to the output box in case the output is too large. Whenever we enter something in the box, we call the function fetchWeather, which is defined as:

 def fetchWeather ( query: String ) = { val searchUrl = "http://api.openweathermap.org/data/" + "2.5/find?type=like&mode=json&q=" + query for { xhr <- Ajax .get(searchUrl) if query == box.value } js. JSON .parse(xhr.responseText).list match { case jsonlist: js. Array [js. Dynamic ] => output.innerHTML = "" showResults(jsonlist, query) case _ => output.innerHTML = "No Results" }
}

This is where the actual data fetching happens. It's relatively straightforward: we make an Ajax .get request, JSON .parse the response, and feed it into the callback function. We're using a slightly different API from earlier: we now have the "type=like" flag, which is documented in the OpenWeatherMap API docs to return multiple results for each city whose name matches your query.

Notably, before we re-render the results, we check whether the query that was passed in is the same value that's in the box. This is to prevent a particularly slow ajax call from finishing out-of-order, potentially stomping over the results of more recent searches. We also check whether the .list: js. Dynamic property we want is an instance of js. Array : if it isn't, it means we don't have any results to show, and we can skip the whole render-output step.

You've already used fragments of the Scala.js CLI in earlier chapters of this book: ~fastOptJS is what you used for development, fullOptJS for publishing. Apart from these, Scala.js allows you to execute code via Rhino/Node.js/PhantomJS from the command-line, as well as running test-suites under the same conditions. This chapter will go deeper into the various things you can do with the Scala.js command line:

• compile: converting code from Scala source into not-yet-executable Scala.js IR
• package: bundling up our Scala.js IR into a .jar file, for publishing or distribution as a library
• fastOptJS: aggregating our Scala.js IR and converting it to a .js executable.
• fullOptJS: aggregating our Scala.js IR and converting it to a smaller, faster .js executable.
• run: run your compiled Scala.js code as Javascript in Rhino, Node.js or Phantom.js
• test: run your compiled Scala.js code as a test suite in Rhino, Node.js or Phantom.js

Also like on Scala-JVM, Scala.js also supports the package command. This command generates a .jar like it does in Scala-JVM, except this version appends this weird _sjs0.6 suffix.

target/scala- 2.11 /
└── example_sjs0. 6 _2. 11 - 0.1 -SNAPSHOT.jar

The purpose of this suffix is to link the compiled .jar file to the version of Scala.js used to compile it. This allows you to make sure that you don't accidentally depend on a version of a jar that is incompatible with your current version.

Headless Runtimes

• Rhino is the default way of running Scala.js applications. The upside of using Rhino is that it is pure-Java, and doesn't need any additional binaries or installation. The downside of using Rhino is that it is slow: maybe a hundred times slower than the alternatives, making it not suitable for running long-running, compute-intensive programs.
• Node.js, a relatively new Javascript runtime based on Google's V8 Javascript engine, Node.js lets you run your Scala.js application from the command line much faster than in Rhino, with performance that matches that of modern browsers. However, you need to separately install Node.js in order to use it. Node.js does not have DOM or browser-related functionality. You need to set the stage with set scalaJSStage in Global := FastOptStage to run using Node.js.
• PhantomJS is a headless Webkit browser. This means that unlike Node.js, PhantomJS provides you with a full DOM and all its APIs to use in your tests, if you wish to e.g. test interactions with the HTML of the web page. On the other hand, it is somewhat slower than Node.js, though still much faster than Rhino. Like Node.js, it needs to be installed separately. You need to set the stage with set scalaJSStage in Global := FastOptStage, as well as setting the jsDependencies += RuntimeDOM flag in your SBT configuration, to use PhantomJS.

These are your three options to run your Scala.js code via the command-line. Generally, it's easiest to get started with Rhino since it's the default and requires no setup, though you will quickly find it worthwhile to setup Node.js or PhantomJS to speed up your runs and tests.

Stages

Let us recap the three different stages of execution, and what they mean.

• PreLinkStage (the default): this does not perform any optimization of the output Scala.js files, and does lazy-loading to minimize the amount of files being loading into the interpreter. This is necessary for Rhino because it can't handle large blobs of Javascript, but doesn't map to any compilation mode you'd use for the browser.
• FastOptStage: this performs the same compilation and optimization as sbt fastOptJS, as described under Fast Optimizations. It then takes the entire output executable (which probably weighs around 1mb) and hands it to Node.js or PhantomJS, which then run it.
• FullOptStage: this performs the same compilation and optimization as sbt fullOptJS, as described under Full Optimizations. This takes longer to run than the FastOptStage, and results in a smaller/faster executable. Practically speaking, this size/speed advantage does not matter from the command line, but FullOptStage is still useful to verify that the behavior does not change (it shouldn't!) under the aggressive full optimization. This is typically used in continuous integration builds, but rarely manually.

spray is an open-source toolkit for building REST/HTTP-based integration layers on top of Scala and Akka. Being asynchronous, actor-based, fast, lightweight, modular and testable it's a great way to connect your Scala applications to the world.

To help you get going we created the spray-template project on GitHub. This provides everything you need to get a spray HTTP server application up-and-running in under 5 minutes and view the result in your browser.

Try running one of these examples:

• spray as a standalone service - this uses the spray-routing and spray-can modules
• spray inside a servlet container - uses spray-routing and spray-servlet inside a Jetty server

The spray-can module provides a low-level, low-overhead, high-performance HTTP server and client built on top of spray-io. Both are fully asynchronous, non-blocking and built 100% in Scala on top of Akka. Since their APIs are centered around Akka abstractions such as Actors and Futures they are very easy to integrate into your Akka-based applications.

A Jakarta Servlet (formerly Java Servlet) is a Java software component that extends the capabilities of a server. Although servlets can respond to many types of requests, they most commonly implement web containers for hosting web applications on web servers and thus qualify as a server-side servlet web API. Such web servlets are the Java counterpart to other dynamic web content technologies such as PHP and ASP.NET.

The Jakarta Servlet API has, to some extent, been superseded by two standard Java technologies for web services:

• the Jakarta RESTful Web Services (JAX-RS 2.0) useful for AJAX, JSON and REST services, and
• the Jakarta XML Web Services (JAX-WS) useful for SOAP Web Services.

A servlet is a small Java program that runs within a Web server. Servlets receive and respond to requests from Web clients, usually across HTTP, the HyperText Transfer Protocol.

To deploy and run a servlet, a web container must be used. A web container (also known as a servlet container) is essentially the component of a web server that interacts with the servlets. The web container is responsible for managing the lifecycle of servlets, mapping a URL to a particular servlet and ensuring that the URL requester has the correct access rights.

Eclipse Jetty is a Java HTTP (Web) server and Java Servlet container. While Web Servers are usually associated with serving documents to people, Jetty is now often used for machine to machine communications, usually within larger software frameworks. Jetty is developed as a free and open source project as part of the Eclipse Foundation

 val library = crossProject.settings( libraryDependencies += "com.lihaoyi" %%% "utest" % "0.3.0" , testFrameworks += new TestFramework ( "utest.runner.Framework" )
).jsSettings( // JS-specific settings here ).jvmSettings( // JVM-specific settings here ) lazy val js = library.js lazy val jvm = library.jvm

Unlike the equivalent build.sbt files you saw in earlier chapters, this does not simply enable the ScalaJSPlugin to the root project. Rather, it uses the crossProject function provided by the Scala.js plugin to set up two projects: one in the app/js/ folder and one in the jvm/ folder. We also have places to put settings related to either the JS side, the JVM side, or both. In this case, we add a dependency on uTest, which we will use as the test framework for our library. Note how we use triple %%% to indicate that we're using the platform-specific version of uTest, such that the Scala.js or Scala-JVM version will be properly pulled in when compiling for each platform.

Heroku is a cloud platform as a service (PaaS) supporting several programming languages

Heroku is said to be a polyglot platform as it has features for a developer to build, run and scale applications in a similar manner across most languages