The Spring IO platform has been criticized over the years for having bulky XML configuration with complex dependency management. During last year’s Spring One 2GX conference, Pivotal CTO, Adrian Colyer acknowledged those criticisms, and made special note that a goal of the platform going forward is to embrace an XML-free development experience. Boot takes that mission statement to the extreme, not only freeing developers from the need for XML, but also, in some scenarios, releasing them from the tedium of writing import statements. In the days following its public beta release, Boot gained some viral popularity by demonstrating the framework’s simplicity with a runnable web application that fit in under 140-characters, delivered in a tweet Spring boot course.

Installing Boot

At its most fundamental level, Spring Boot is little more than a set of libraries that can be leveraged by any project’s build system. As a convenience, the framework also offers a command-line interface, which can be used to run and test Boot applications. The framework distribution, including the integrated CLI, can be manually downloaded and installed from the Spring repository. A more convenient approach is to use the Groovy enVironment Manager (GVM), which will handle the installation and management of Boot versions. Boot and its CLI can be installed by GVM with the command line, gvm install springboot. Formulas are available for installing Boot on OS X through the Homebrew package manager. To do so, first tap the Pivotal repository with brew tap pivotal/tap, followed by the brew install springboot command Spring boot online course.

Projects that are to be packaged and distributed will need to rely on build systems like Maven or Gradle. To simplify the dependency graph, Boot’s functionality is modularized, and groups of dependencies can be brought in to a project by importing Boot’s so-called "starter" modules. To easily manage dependency versions and to make use of default configuration, the framework exposes a parent POM, which can be inherited by projects. An example POM for a Spring Boot project is defined in Listing 1.

Developing a Spring Boot Application

The most popular example of a Spring Boot application is one that was delivered via Twitter shortly following the public announcement of the framework. As demonstrated in its entirety in Listing 1.2, a very simple Groovy file can be crafted into a powerful Spring-backed web application.

This application can be run from the Spring Boot CLI, by executing the spring run App.groovy command. Boot analyzes the file and — through various identifiers known as "compiler auto-configuration" — determines that it is intended to be a web application. It then, in turn, bootstraps the Spring Application context inside of an embedded Tomcat container on the default port of 8080. Opening a browser and navigating to the provided URL will land you on a page with a simple text response, "hello". This process of providing a default application context and embedded container allows developers to focus on the process of developing application and business logic, and frees them from the tedium of otherwise boiler-plate configuration Spring boot online training india.

Boot’s ability to ascertain the desired functionality of a class is what makes it such a powerful tool for rapid application development. When applications are executed from the Boot CLI, they are built using the internal Groovy compiler, which allows the ability to programmatically inspect and modify a class while its bytecode is being generated. In this way, developers who use the CLI are not only freed from the need to define default configuration, but, to an extent, they also do not need to define certain import statements that can otherwise be recognized and automatically added during the compilation process. Additionally, when applications are run from the CLI, Groovy’s built-in dependency manager, "Grape", is used to resolve classpath dependencies that are needed to bootstrap the compilation and runtime environments, as determined by Boot’s compiler auto-configuration mechanisms. This idiom not only makes the framework more user-friendly, but also allows different versions of Spring Boot to be coupled with specific versions of libraries from the Spring IO platform, which in turn means that developers do not need to be concerned with managing a complex dependency graph and versioning structure. Additionally, it opens the door for rapid prototyping and quick generation of proof-of-concept project code.

For projects that are not built with the CLI, Boot provides a host of "starter" modules, which define a set of dependencies that can be brought into a build system in order to resolve the specific libraries needed from the framework and its parent platform. As an example of this, the spring-boot-starter-actuator dependency pulls in a set of base Spring projects to get an application quickly configured and up-and-running. The emphasis of this dependency is on developing web applications, and specifically RESTful web services. When included in conjunction with the spring-boot-starter-web dependency, it will provide auto-configuration to bootstrap an embedded Tomcat container, and will map endpoints useful to micro-service applications, like server information, application metrics, and environment details. Additionally, when the spring-boot-starter-security module is brought in, the actuator will auto-configure Spring Security to provide the application with basic authentication and other advanced security features. For any application structure, it will also include an internal auditing framework that can be used for reporting purposes or application-specific needs, like developing an authenitcation-failure lock-out policy.

To demonstrate quickly getting a Spring web application up-and-running from within a Java Maven project Spring boot online training.

Why Are These Insights Valuable?
The five most important applications of model insights are
Debugging
Informing feature engineering
Directing future data collection
Informing human decision-making
Building Trust
Debugging

The world has a lot of unreliable, disorganized and generally dirty data. You add a potential source of errors as you write pre processing code. Add in the potential for target leakage and it is the norm rather than the exception to have errors at some point in a real data science projects Data science online course.

Given the frequency and potentially disastrous consequences of bugs, debugging is one of the most valuable skills in data science. Understanding the patterns a model is finding will help you identify when those are at odds with your knowledge of the real world, and this is typically the first step in tracking down bugs.
Informing Feature Engineering

Feature engineering is usually the most effective way to improve model accuracy. Feature engineering usually involves repeatedly creating new features using transformations of your raw data or features you have previously created.
Sometimes you can go through this process using nothing but intuition about the underlying topic. But you’ll need more direction when you have 100s of raw features or when you lack background knowledge about the topic you are working on.

A Kaggle competition to predict loan defaults gives an extreme example. This competition had 100s of raw features. For privacy reasons, the features had names like f1, f2, f3 rather than common English names. This simulated a scenario where you have little intuition about the raw data.Visit for more info Data science online training hyderabad.

One competitor found that the difference between two of the features, specifically f527 — f528, created a very powerful new feature. Models including that difference as a feature were far better than models without it. But how might you think of creating this variable when you start with hundreds of variables?
The techniques you’ll learn in this course would make it transparent that f527 and f528 are important features, and that their role is tightly entangled. This will direct you to consider transformations of these two variables, and likely find the “golden feature” of f527 — f528.As an increasing number of datasets start with 100s or 1000s of raw features, this approach is becoming increasingly important.For deep understanding Data science course.

Directing Future Data Collection
You have no control over datasets you download online. But many businesses and organizations using data science have opportunities to expand what types of data they collect. Collecting new types of data can be expensive or inconvenient, so they only want to do this if they know it will be worthwhile. Model-based insights give you a good understanding of the value of features you currently have, which will help you reason about what new values may be most helpful.
Informing Human Decision-Making
Some decisions are made automatically by models. Amazon doesn’t have humans (or elves) scurry to decide what to show you whenever you go to their website. But many important decisions are made by humans. For these decisions, insights can be more valuable than predictions.
Building Trust
Many people won’t assume they can trust your model for important decisions without verifying some basic facts. This is a smart precaution given the frequency of data errors. In practice, showing insights that fit their general understanding of the problem will help build trust, even among people with little deep knowledge of data science Data science online training in india.

When the internet first began to pick up some steam, it had some of the hallmarks of the Wild West: the rules hadn’t been clearly defined, for instance, and direct competition was fairly minimal because there was so much space to be filled. As a result, there was a lot of freewheeling experimentation going by gut feeling. Just try something, see how it goes.

As the years have gone by, the online world has gone from an attention-grabbing novelty to a fundamental part of daily life. Along the way, its standards have changed immensely, and there are two reasons for this: technological progress in general, and frequent efforts from online brands to exceed previous levels of service and performance to outperform their rivals.

Given how competitive the web is now, going by gut feeling won’t get brands very far, so they are essentially required to invest in data science: using the smartest methods available to them to analyze relevant data and reach informed conclusions about what they need to do. In this post, we’re going to consider how data science is changing web design. Let’s begin with Data science online training in hyderabad.

IT’S INFORMING EVERY STEP OF THE PROCESS

The significance of data science is such that it doesn’t simply factor into one element of the web design process (weighing in at the end, perhaps) — instead, it has a key role to play at every point and in every department. The reasoning for this should be fairly obvious. Given that every step in a digital process inevitably produces traceable results (without traceable results, you can’t know how well something is working), the opportunity for data science is always there.If you want know more visit Data science course.

It may not be used at all opportunities when small businesses run web design projects, but that’s simply because they don’t have the resources to invest so broadly. Look at big companies to see where things are going. Case in point: eCommerce giant Shopify (known for its sell everything everywhere message) has a full Data Science & Engineering team, but it doesn’t serve exclusively as a separate unit.

IT’S OFFERING IMPROVED USER EXPERIENCES

Putting so much time and effort into data science wouldn’t be worthwhile if it didn’t ultimately get impressive results, so we need to think about the net product of the investment: improved user experiences. Excellent web design needs to allow users to find what they need with minimal effort and optimal convenience. In addition to being easy to operate, it should find other ways to impress the user: the bigger a positive impression it can make, for the better understanding Data science online training india.

Now think about all the customized and personalized experiences you can now get in the online world. You can visit a familiar retailer and benefit from dynamic recommendations that factor in your previous purchases, deals that suit your interests, and even design elements that reflect your preferences (not common, but not unheard of).

All of these things are made possible by the data science field: without machine learning to automate them, dynamic recommendations would need to be done manually. You can even think about chat bot-enhanced customer support. Being able to check up on the status of an order by issuing a request through a chat bot window feels like a trivial thing, but it was made possible by advances in natural language processing that couldn’t have been achieved without deploying machine learning to process and parse vast quantities of data.

IT’S STARTING TO AUTOMATE UPDATE PATHS

Web designs aren’t supposed to be static. Once you deploy them, it won’t be very long before they’re outdated relative to newer designs, so you need to make a commitment to keeping them updated. But what if you didn’t need to slowly work on manual updates and carefully roll them out as appropriate? What if you could automate much of the update process?

Well, with the right process in place (powered by data science, of course), you could. You could set up a system with various flexible elements and have it reshuffle those elements in response to analytics from testing. Tweak one element and see how the results change: if they get worse, revert the tweak, and if they get better, leave it as it is and tweak something else.

In the long run, self-optimizing systems are going to become extremely common. Human intelligence can then be put towards more interesting things, such as new projects or updates that go beyond basic comparison testing. The key will be finding a balance between the things at which computers excel (repetitive processes at massive scale) and the things at which human brains excel.For deep concepts Data science online course .

1) Counting requires numerous, often arbitrary decisions

Questions like How many computer science students were there at UNC Charlotte last year? or How many graduates from North Carolina's public universities find employment within one year of graduation? Seems simple, right?

Unfortunately, answering those questions required defining a whole host of terms. Just for counting students, you have to decide.To get right path visit Data science training.

Do part-time students count?
What about non-degree-seeking students?
Undergraduate only maybe?
Are we counting total unique individuals enrolled over the course of a year, or something else?
School year, fiscal year, or calendar year?
How do we count students that enrolled in multiple programs? Is it OK that enrollment for the university is lower than the sum of the enrollments in its constituent programs?
Of course, depending on the purpose of the data, there are right answers to many of these questions. For budgetary purposes, it probably makes sense to go with the fiscal year, for example. But somebody has to make those decisions, which means somebody has to take ownership of setting the business rule.

2) Counting is easy to understand

This one isn't necessarily unique to counting, but it does apply to any sort of basic statistical research. The simpler a statistic or a model is to understand, the easier it is for stakeholders to articulate an opinion about.

Say you go to a PM or a middle manager in your company and tell them "We've just finished work on a machine learning model that can detect 90% of fraudulent orders with very few false positives." The response you're likely to get is something along the lines of "Great work! What would it take to put this into production?" It's very unlikely that they're going to dicker about the features or hyper-parameters of your model. The relative complexity involved means it's effectively a black box.

Not so with simpler models. Most people have a pretty good intuitive understanding of things like correlation or multiple regression, even if they don't know all the details about how they work. And everybody can understand counting. This means that instead of getting a quick "Good Job" in response to your work, you're much more likely to get a host of questions about how your research was done.

Of course, there are upsides to this - all of our work could probably benefit from the added scrutiny of stakeholder review. Nevertheless, it adds a significant amount of relational and political overhead to the actual analytics.For indept understanding Data science online training india.

3) Counting is often high-stakes

Again, this isn't exclusive to counting... but it does greatly magnify the effects of reasons 1 and 2. Counting is very frequently high-stakes for people other than the analyst. Consider:

How many sales did Jones make last year? Her bonus likely depends on it.
How many people live in Austin, TX? Getting this wrong could alter re-districting and change the balance of political power.

Counting requires making a lot of (often arbitrary) decisions. It's simple enough that everybody can articulate an opinion about those decisions. And it's often important enough that folks will have a very strong incentive to form and articulate opinions. This is a recipe for fierce political battles involving stakeholders with entrenched, often conflicting, interests.

In the end, the counting itself may be unbelievably easy... a simple COUNT DISTINCT query with a carefully crafted WHERE clause is a pretty trivial task for any data scientist worth his salt. But making all the decisions necessary to actually start doing the counting is frequently a long, frustrating, relational-not-technical process.If you are willing to expert in data science reach Data science online training.

Building REST APIs with Spring became the standard approach for Java developers during the last couple of years. Using Spring Boot helps substantially, as it removes a lot of boilerplate code and enables auto-configuration of various components. We will assume that you’re familiar with the basics of API development with those technologies before applying the knowledge described here. If you are still unsure about how to develop a basic REST API, then you should start with this article about Spring MVC or another one about building a Spring REST Service.

Making Error Responses Clearer
Throughout this article, we’ll be using the source code hosted on GitHub of an application that implements a REST API for retrieving objects that represent birds. It has the features described in this article and a few more examples of error handling scenarios. To get indept knowledge Spring boot online training .Here’s a summary of endpoints implemented in that application:

</tr>GET /birds/{birdId}Gets information about a bird and throws an exception if not found.GET /birds/noexception/{birdId}This call also gets information about a bird, except it doesn’t throw an exception in case that the bird is not found.POST /birdsCreates a bird.

The Spring framework MVC module comes with some great features to help with error handling. But it is left to the developer to use those features to treat the exceptions and return meaningful responses to the API client.If you want learn anything more Spring boot online training in hyderabad.

Let’s look at an example of the default Spring Boot answer when we issue an HTTP POST to the /birds endpoint with the following JSON object, that has the string “aaa” on the field “mass,” which should be expecting an integer:

{
 "scientificName": "Common blackbird",
 "specie": "Turdus merula",
 "mass": "aaa",
 "length": 4
}

The Spring Boot default answer, without proper error handling:

{
 "timestamp": 1500597044204,
 "status": 400,
 "error": "Bad Request",
 "exception": "org.springframework.http.converter.HttpMessageNotReadableException",
 "message": "JSON parse error: Unrecognized token 'three': was expecting ('true', 'false' or 'null'); nested exception is com.fasterxml.jackson.core.JsonParseException: Unrecognized token 'aaa': was expecting ('true', 'false' or 'null')\n at [Source: java.io.PushbackInputStream@cba7ebc; line: 4, column: 17]",
 "path": "/birds"
}

Well… the response message has some good fields, but it is focused too much on what the exception was. By the way, this is the class DefaultErrorAttributes from Spring Boot. The timestamp field is an integer number that doesn’t even carry information of what measurement unit the timestamp is in. The exception field is only interesting to Java developers and the message leaves the API consumer lost in all the implementation details that are irrelevant to them. And what if there were more details that we could extract from the exception that the error originated from? So let’s learn how to treat those exceptions properly and wrap them into a nicer JSON representation to make life easier for our API clients.

As we’ll be using Java 8 date and time classes, we first need to add a Maven dependency for the Jackson JSR310 converters. They take care of converting Java 8 date and time classes to JSON representation using the @JsonFormat annotation:

<dependency>
   <groupId>com.fasterxml.jackson.datatype</groupId>
   <artifactId>jackson-datatype-jsr310</artifactId>
</dependency>

Ok, so let’s define a class for representing API errors. We’ll be creating a class called ApiError that has enough fields to hold relevant information about errors that happen during REST calls.

class ApiError {

   private HttpStatus status;
   @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "dd-MM-yyyy hh:mm:ss")
   private LocalDateTime timestamp;
   private String message;
   private String debugMessage;
   private List<ApiSubError> subErrors;

   private ApiError() {
       timestamp = LocalDateTime.now();
   }

   ApiError(HttpStatus status) {
       this();
       this.status = status;
   }

   ApiError(HttpStatus status, Throwable ex) {
       this();
       this.status = status;
       this.message = "Unexpected error";
       this.debugMessage = ex.getLocalizedMessage();
   }

   ApiError(HttpStatus status, String message, Throwable ex) {
       this();
       this.status = status;
       this.message = message;
       this.debugMessage = ex.getLocalizedMessage();
   }
}

• The status property holds the operation call status. It will be anything from 4xx to signalize client errors or 5xx to mean server errors. A common scenario is a http code 400 that means a BAD_REQUEST, when the client, for example, sends an improperly formatted field, like an invalid email address.
• The timestamp property holds the date-time instance of when the error happened.
• The message property holds a user-friendly message about the error.
• The debugMessage property holds a system message describing the error in more detail.
• The subErrors property holds an array of sub-errors that happened. This is used for representing multiple errors in a single call. An example would be validation errors in which multiple fields have failed the validation. The ApiSubError class is used to encapsulate those.

abstract class ApiSubError {

}

@Data
@EqualsAndHashCode(callSuper = false)
@AllArgsConstructor
class ApiValidationError extends ApiSubError {
   private String object;
   private String field;
   private Object rejectedValue;
   private String message;

   ApiValidationError(String object, String message) {
       this.object = object;
       this.message = message;
   }
}

So then the ApiValidationError is a class that extends ApiSubError and expresses validation problems encountered during the REST call. For more information visit Spring boot course.

Key ways to Building an Optimally Designed Production Pipeline navigate to Data science online training .

Strategic Data Packing
Consider any project that you want. It’s is a known fact that there exists no project without data as data is a default. Each database comprises a huge amount of data in distinct formats and a huge amount of code - let’s say n-number of lines of code with different scripting languages enables us to turn raw data into predictions. The packing of data or code typically happens during production.

A typical release process includes:

Putting a versioning tool in place in order to control the code versions.
Building a packaging script to pack the code in a zip file format.
Deploying it to production.
Optimization and Retraining Models
To get accurate results, teams work in small iterations. These iterations play a vital role in the process of optimization and retraining. It is essential to have a process layed out in several phases, namely: validation, retraining, and the deployment of modules. However, the modules need to be regularly updated to fit into the new behavior and underlying data changes.

If you need to retrain your models, then it is suggested to gather more knowledge from Data science training make this a distinct step in the production workflow of your data science team. For example, setting up your system to retrieve a predictive model data weekly, give this model a rating based on the performance, and then validate the results returned, while a human operator verifies the results as well.

Increasing the number of tools leads to a greater number of problems. Maintaining the production as well as design environment with the latest versions along with the packages is recommended. A data science project depends on up to 100 R packages, 40 for Python, and several hundred Java/Scala packages. For acquiring more information source is Data science online course.

prefix:

    stringProp1: propValue1

    stringProp2: propValue2

    intProp1: 10

    listProp:

        - listValue1

        - listValue2

    mapProp:

        key1: mapValue1

        key2: mapValue2

These entries can also be described in a traditional application.properties file the following way:

prefix.stringProp1=propValue1

prefix.stringProp2=propValue2

prefix.intProp1=10

prefix.listProp[0]=listValue1

prefix.listProp[1]=listValue2

prefix.mapProp.key1=mapValue1

prefix.mapProp.key2=mapValue2

It has taken me a little while, but I do like the hierarchical look of the properties described in a YAML format. To indept on this visit Spring boot training

So now, given this property file, a traditional Spring application would have loaded up the properties in the following way:

public class SamplePropertyLoadingTest {

    @Value("${prefix.stringProp1}")

    private String stringProp1;

Note the placeholder for "prefix.stringProp" key.

This however is not ideal for loading a family of related properties, say in this specific case namespaced by the prefix conveniently named "prefix".

The approach Spring boot takes is to define a bean that can hold all the families of related properties this way: And for more clarification Spring boot online course

@ConfigurationProperties(prefix = "prefix")

@Component

public class SampleProperty {

    private String stringProp1;

    private String stringProp2;

    @Max(99)

    @Min(0)

    private Integer intProp1;

    private List<String> listProp;

    private Map<String, String> mapProp;

    ...

}

At runtime, all the fields would be bound to the related properties cleanly.

Additionally note the JSR-303 annotations on top of the "intProp1" field that validates that the value of the field is between 0 and 99. @ConfigurationProperties will call the validator to ensure that the bound bean is validated.

An integration test using this feature is shown here:

package prop;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.boot.test.SpringApplicationConfiguration;

import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import static org.hamcrest.MatcherAssert.assertThat;

import static org.hamcrest.Matchers.*;

@RunWith(SpringJUnit4ClassRunner.class)

@SpringApplicationConfiguration(classes = SampleWebApplication.class)

public class SamplePropertyLoadingTest {

    @Autowired

    private SampleProperty sampleProperty;

    @Value("${prefix.stringProp1}")

    private String stringProp1;

    @Test

    public void testLoadingOfProperties() {

        System.out.println("stringProp1 = " + stringProp1);

        assertThat(sampleProperty.getStringProp1(), equalTo("propValue1"));

        assertThat(sampleProperty.getStringProp2(), equalTo("propValue2"));

        assertThat(sampleProperty.getIntProp1(), equalTo(10));

        assertThat(sampleProperty.getListProp(), hasItems("listValue1", "listValue2"));

        assertThat(sampleProperty.getMapProp(), allOf(hasEntry("key1", "mapValue1"),

                hasEntry("key2", "mapValue2")));

    }

}

If you are interested in exploring this sample further, Go through Spring Boot Online Training.