In this interactive tutorial, we will build a RESTful API that will be implemented in a simple note-taking application using CRUD methods i.e: create, retrieve, update and deletion of notes.

Let's get our hands dirty..

What we will be using:
1. Spring Boot - this will be our MVC based framework based on Java.
2. MySQL - our relational database system and where our schema will run
3. Postman - for handling our API calls
4. An IDE with the Spring development environment -
Netbeans/STS suite/Eclipse can work.

Spring Boot provides a web tool called Spring Initializer to bootstrap an application quickly. Just go to http://start.spring.io and follow the steps below to generate a new project.

Step 1 : Click Switch to full version on http://start.spring.io page.

Step 2 : Enter the details as the screenshot below shows:

Once all the details are entered, click Generate Project to generate and download your project. Spring Initializer will generate the project with the details you have entered and download a zip file with all the project folders.

Next, Unzip the downloaded zip file and import it into your favorite IDE.

A few details on our newly created application -

1. RhapsodyNotesApplication

This is the main entry point of our Spring Boot application.

package com.example.rhapsodynotes;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.data.jpa.repository.config.EnableJpaAuditing;

@SpringBootApplication
public class RhapsodyNotesApplication {

public static void main(String[] args) {
    SpringApplication.run(EasyNotesApplication.class, args);
}
}

It contains a simple annotation called @SpringBootApplication which is a combination of the following more specific spring annotations:

@EnableAutoConfiguration: This annotation tells Spring to automatically configure your application based on the dependencies that you have added in the pom.xml file.

For example, If spring-data-jpa or spring-jdbc is in the classpath, then it automatically tries to configure a DataSource by reading the database properties from application.properties file.

The main() method calls Spring Boot’s SpringApplication.run() method to launch the application.

1. resources/

This directory, as the name suggests, is dedicated to all the static resources, templates and property files.

resources/static - contains static resources such as css, js and images.

resources/templates - contains server-side templates which are rendered by Spring.

resources/application.properties - This file is very important. It contains application-wide properties. Spring reads the properties defined in this file to configure your application. You can define server’s default port, server’s context path, database URLs etc, in this file.

You can refer this file for common application properties used in Spring Boot.

1. pom.xml - contains all the project dependencies

Configuring MySQL Database
As I pointed out earlier, Spring Boot tries to auto-configure a DataSource if spring-data-jpa is in the classpath by reading the database configuration from application.properties file.

Open application.properties file and add the following properties to it.

## Spring DATASOURCE (DataSourceAutoConfiguration & DataSourceProperties)
spring.datasource.url = 
jdbc:mysql://localhost:3306/notes_app?useSSL=false
spring.datasource.username = root
spring.datasource.password = 303seminarian

## Hibernate Properties
spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQL5InnoDBDialect

# Hibernate ddl auto (create, create-drop, validate, update)
spring.jpa.hibernate.ddl-auto = update

You will need to create a database named notes_app in MySQL, and change the spring.datasource.username & spring.datasource.password properties as per your MySQL installation.

In the above properties file, the last two properties are for hibernate. Spring Boot uses Hibernate as the default JPA implementation.

The property spring.jpa.hibernate.ddl-auto is used for database initialization. I’ve used the value “update” for this property.

It does two things -

When you define a domain model, a table will automatically be created in the database and the fields of the domain model will be mapped to the corresponding columns in the table.

Any change to the domain model will also trigger an update to the table. For example, If you change the name or type of a field, or add another field to the model, then all these changes will be reflected in the mapped table as well.

Using update for spring.jpa.hibernate.ddl-auto property is fine for development. But, For production, You should keep the value of this property to “validate”, and use a database migration tool like Flyway for managing changes in the database schema.

Creating the Note model

Let’s now create the Note model. Our Note model has following fields -

id: Primary Key with Auto Increment.
title: The title of the Note. (NOT NULL field)
content: Note’s content. (NOT NULL field)
createdAt: Time at which the Note was created.
updatedAt: Time at which the Note was updated.

Now, let’s see how we can model this in Spring. Create a new package called model inside com.example.rhapsodynotes and add a class named Note.java with following contents -

 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package com.example.rhaposdynotes.model;

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;  
import java.io.Serializable;  
import org.springframework.data.annotation.CreatedDate;  
import org.springframework.data.annotation.LastModifiedDate;  
import org.springframework.data.jpa.domain.support.AuditingEntityListener;  
import javax.persistence.*;  
import javax.validation.constraints.NotBlank;  
import java.util.Date;  
/**
 *
 * @author Kimaiga
 */

@Entity
@Table(name = "notes")
@EntityListeners(AuditingEntityListener.class)
@JsonIgnoreProperties(value = {"createdAt", "updatedAt"}, 
        allowGetters = true)
public class Note implements Serializable {  
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @NotBlank
    private String title;

    @NotBlank
    private String content;

    @Column(nullable = false, updatable = false)
    @Temporal(TemporalType.TIMESTAMP)
    @CreatedDate
    private Date createdAt;

    @Column(nullable = false)
    @Temporal(TemporalType.TIMESTAMP)
    @LastModifiedDate
    private Date updatedAt;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public Date getCreatedAt() {
        return createdAt;
    }

    public void setCreatedAt(Date createdAt) {
        this.createdAt = createdAt;
    }

    public Date getUpdatedAt() {
        return updatedAt;
    }

    public void setUpdatedAt(Date updatedAt) {
        this.updatedAt = updatedAt;
    }

}

Enable JPA in the main application.

Open RhapsodyNotesApplication.java and add @EnableJpaAuditing annotation.

 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package com.example.rhapsodynotes.repository;

import com.example.rhapsodynotes.model.Note;  
import org.springframework.data.jpa.repository.JpaRepository;

/**
 *
 * @author Kimaiga
 */
public interface NoteRepository extends JpaRepository<Note, Long> {

}

Creating NoteRepository to access data from the database

The next thing we’re going to do is create a repository to access Note’s data from the database.

Spring Data JPA has got us covered here. It comes with a JpaRepository interface which defines methods for all the CRUD operations on the entity, and a default implementation of JpaRepository called SimpleJpaRepository.

Still sailing! Let’s create the repository now. First, Create a new package called repository inside the base package com.example.rhapsodynotes. Then, create an interface called NoteRepository and extend it from JpaRepository:

/** To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.*/

package com.example.rhapsodynotes.repository;

import com.example.rhapsodynotes.model.Note;
import org.springframework.data.jpa.repository.JpaRepository;

/**
 *
 * @author Kimaiga
 */
 public interface NoteRepository extends JpaRepository<Note, Long> {

}

That is all you have to do in the repository layer. You will now be able to use JpaRepository’s methods like save(), findOne(), findAll(), count(), delete() etc.

You don’t need to implement these methods. They are already implemented by Spring Data JPA’s SimpleJpaRepository. This implementation is plugged in by Spring automatically at runtime.

Exception Handling

We’ll define the Rest APIs for creating, retrieving, updating, and deleting a Note in the next section.

The APIs will throw a ResourceNotFoundException whenever a Note with a given id is not found in the database.

Following is the definition of ResourceNotFoundException. (I’ve created a package named exception inside com.example.rhapsodyotes to store this exception class):

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package com.example.rhapsodynotes.exception;


import org.springframework.http.HttpStatus;  
import org.springframework.web.bind.annotation.ResponseStatus;

/**
 *
 * @author Kimaiga
 */

@ResponseStatus(value = HttpStatus.NOT_FOUND)
public class ResourceNotFoundException extends RuntimeException {  
    private String resourceName;
    private String fieldName;
    private Object fieldValue;

    /**
     * Creates a new instance of <code>ResourceNotFoundException</code> without
     * detail message.
     */
    public ResourceNotFoundException( String resourceName, String fieldName, Object fieldValue) {
        super(String.format("%s not found with %s : '%s'", resourceName, fieldName, fieldValue));
        this.resourceName = resourceName;
        this.fieldName = fieldName;
        this.fieldValue = fieldValue;
    }
    /**
     * Constructs an instance of <code>ResourceNotFoundException</code> with the
     * specified detail message.
     *
     * @param msg the detail message.
     */

    public String getResourceName(){
        return resourceName;
    }

    public String getFieldName() {
        return fieldName;
    }

    public Object getFieldValue() {
        return fieldValue;
    }

    public ResourceNotFoundException(String msg) {
        super(msg);
    }
}

Notice the use of @ResponseStatus annotation in the above exception class. This will cause Spring boot to respond with the specified HTTP status code whenever this exception is thrown from your controller.

Creating our NoteController

We’ll now create the REST APIs for creating, retrieving, updating and deleting a Note.

First, create a new package controller inside com.example.rhapsodynotes. Then, create a new class NoteController.java with the following code snippet -

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package com.example.easynotes.controller;

import org.springframework.stereotype.Controller;  
import org.springframework.ui.Model;  
import org.springframework.web.bind.annotation.RequestMapping;  
import com.example.easynotes.exception.ResourceNotFoundException;  
import com.example.rhapsodynotes.model.Note;  
import com.example.rhapsody.repository.NoteRepository;  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.http.ResponseEntity;  
import org.springframework.web.bind.annotation.*;  
import javax.validation.Valid;  
import java.util.List;

/**
 *
 * @author Kimaiga
 */
@RestController
@RequestMapping("/api")
public class NoteController {  
    @Autowired
    NoteRepository noteRepository;

    // Get All Notes
    @GetMapping("/notes")
    public List<Note> getAllNotes() {
        return noteRepository.findAll();
    }

    // Create a new Note
    @PostMapping("/notes")
    public Note createNote(@Valid @RequestBody Note note) {
        return noteRepository.save(note);
    }
    // Get a Single Note
    @GetMapping("/notes/{id}")
    public Note getNoteById(@PathVariable(value = "id") Long noteId) {
        return noteRepository.findById(noteId).orElseThrow(() -> new ResourceNotFoundException("Note", "id", noteId));
    }

    // Update a Note
    @PutMapping("/notes/{id}")
    public Note updateNote(@PathVariable(value = "id") Long noteId, @Valid @RequestBody Note noteDetails) {

    Note note = noteRepository.findById(noteId).orElseThrow(() -> new ResourceNotFoundException("Note", "id", noteId));

    note.setTitle(noteDetails.getTitle());
    note.setContent(noteDetails.getContent());

    Note updatedNote = noteRepository.save(note);
    return updatedNote;
}

    // Delete a Note
    @DeleteMapping("/notes/{id}")
    public ResponseEntity<?> deleteNote(@PathVariable(value = "id") Long noteId) {
    Note note = noteRepository.findById(noteId).orElseThrow(() -> new ResourceNotFoundException("Note", "id", noteId));

    noteRepository.delete(note);

    return ResponseEntity.ok().build();
}

}

@RestController annotation is a combination of Spring’s @Controller and @ResponseBody annotations.

The @Controller annotation is used to define a controller and the @ResponseBody annotation is used to indicate that the return value of a method should be used as the response body of the request.

@RequestMapping("/api") declares that the url for all the apis in this controller will start with /api.

Testing the APIs

We’ve successfully built all the apis for our application. Let’s now run the app and test the apis.

The application will start at Spring Boot’s default port 8080. It’s time to test our apis using postman. Add the URL: http://localhost:8080/easy-notes/api/notes/ on your postman URL bar and select a HTTP method to make a request. Based on the API calls, you should be able to get various response codes. Remember the input type to use is in JSON format.

We've successfully built a Restful CRUD API using Spring Boot, Mysql, Jpa and Hibernate.

You can find the source code for this tutorial on my github repository. Feel free to clone the repository and build upon it.

Abstraction is a process where we show only relevant data and hide unnecessary details of an object from the user. For example, Consider the remote control of a TV, you as the user only know which key to press for what function. You will not know what happens inside when you press whichever button. This is the kind of scenario that happens in Java. Abstraction is achieved with the help of interfaces. In this case, the remote control of the TV is an interface. It these interfaces that expose only methods to end users with a view to reducing complexity and increasing efficiency of using the object.

We can enhance the internal implementation without effecting outside world. Abstraction provides security. A class contains lot of data and the user does not need the entire data. The advantage of abstraction is that every user will get their own view of the data according to their requirements and will not get confused with unnecessary data.

When we hide unnecessary details of an object from a user, this is described as data hiding, which is a process of keeping out internal data safe from un-authorized access. This means no one can access our internal data directly.

In my last blog post, I demonstrated how we can achieve data hiding programatically by declaring data members as private, so that an outside person (or object) can access our data through public methods using getters and setters.

Real-life example

Let's say for instance you are a member of a bank in which many other people's accounts are there. There is some banking software which has been implemented in such a way that the bank balance variable is defined as a public variable. This means that if you are having an account in this bank, then your account balance is somehow known to the public, so any one can know your account balance. Ideally, no one would like this because one's bank balance is a private piece of info.

So in order to make your account safe such banking software declares the balance variable as a private variable so that anyone who wants to access this private data can only do so through methods defined inside that class, and this method will be probably asking the account holder to input his/her account number, as well as a PIN number for authentication purposes.

So by utilizing the concept of data hiding,security is achieved. This is one of the mechanisms through which encapsulation works.

In summary, encapsulation can be loosely defined as the wrapping up of data into a single unit. Abstraction on the other hand refers to selecting only the necessary details from the given data without compromising on the functionality. Encapsulation allows abstraction since they work hand in hand. Encapsulation itself is a subset of abstraction by hiding what you don't need while abstraction shows you what you need.

Look but don't touch

Explaining getter-setter concepts to a beginner maybe quite complex especially if they have no initial exposure to OOP o even programming at all. Let's take the example of people having fun in a party. Let's assume these people to be objects. They have personal information which we will call"attributes". Some of this personal information is sensitive and they do not want every body to know. Say for example, someone does not want to reveal their mobile number to the public. Those are pieces of information these objects (or party people) will declare as "private" There is some other information they do want to reveal to the public. For example, they may want to reveal their name to their new acquaintances. This is the kind of attributes or pieces of information they could declare as "public"

Revealing personal attributes as public allows others not only to read the information but also to modify it. And this is the reason our objects would rather protect certain information by declaring it private (So other objects cannot access them directly) and letting others access that information only if they ask through a provided mechanism we will call method. The mechanisms for asking an object to reveal information about itself we may call getter.

Having others ask for their sensitive information through a method instead of letting them access directly their personal info allows objects to respond only when they want (to objects they trust, for example) and allows them to hide information they would rather not reveal. If one of our party goers have objections to revealing her age, for example, she may choose to lie about it and tell everyone she is 20. Our objects can let others know their name through a getter.

Some times objects will want others to be able to suggest changes to their own state. One of our objects may, for example, ask others for suggestions as to which color she should die her hair next. For this kind of situations they can declare a setter mechanism through which others can suggest such changes but our objects will still be in control of whether they make those changes or not or whether they will take some other actions triggered by this request. This way our object can decide whether to die her hair green or wait for a better suggestion.

Lets implement this
To achieve this:
* Declare the variables of a class as private. * Provide public setter and getter methods to modify and view the variables values.

Step 1:
public class GetterSetter{ private String name; private String idNum; private int age; public int getAge(){ return age; } public String getName(){ return name; } public String getIdNum(){ return idNum; } public void setAge( int newAge){ age = newAge; } public void setName(String newName){ name = newName; } public void setIdNum( String newId){
idNum = newId; } }

Then we can access the variables of GetterSetter class as follows:

public class TestSetter{ public static void main(String args[]){
TestSetter testsetter = new TestSetter(); testsetter.setName("Mary"); testsetter.setAge(20); testsetter.setIdNum("12343MS"); System.out.print("Name : " + testsetter.getName() + " Age : " + testsetter.getAge()); } }

Additionally, we went ahead to specify two common types of development methodologies; namely: Object-oriented analysis and design (OOAD) and structure-oriented analysis and design. The former is quite common given it's robust nature as well as the elements of object-orientation and abstraction which are quite an influencing factor for a programmer's work.

This article seeks to break down the differences between the two so as to bring the element of clarity.

Object Oriented Analysis and Design

• Uses an incremental methodology.
• Has a very low risk
• Mainly focused on objects, their names, and their variables.
• Mostly suitable for large risky projects with changing user requirements

structure-oriented analysis and design.

• Uses a methodology based on the software development life cycle.
• Focused on processes only.
• Mostly suitable for well defined projects with stable user requirements.

And there it is. Before settling on either of the two, it is important to architect the system being developed theoretically first, ideate around it such that the choice of methodology would be rational.

Know Thy Complexities!

In computer science, much of the theoretical elements have their uses and their applications can turn out to be quite practical. In this article, we will come across terminologies such as the 'Big O notation' and algorithm complexity analysis, a concept which many developers as well as learners find hard to understand, fear, or avoid altogether as useless.
Ideally, Algorithm complexities are just a way to formally measure how fast a program or algorithm runs, so it really is quite a pragmatic approach to matters programming. In data structures and algorithms, We define complexity as a numerical function T(n) - time versus the input size n.

Here is where the circus begins:
T(n) refers to the maximum amount of time taken on any input of size n. A given algorithm will take different amounts of time on the same inputs depending on such factors as: processor speed; instruction set, disk speed, type of compiler among other factors. The time complexity of algorithms is most commonly expressed using the big O notation. Since Since an algorithm's performance may vary with different types of input data, hence for an algorithm we usually use the worst-case Time complexity of an algorithm because that is the maximum time taken for any input size.

For now, that's all you need to in order familiarize yourself with as far as algorithm terminologies are concerned. Further emphasis will be put into calculating time complexity, using mathematical approaches, a somehow confusing concept which will form the content of my next blog post.

A methodology is an algorithm, which includes formulas as well as a set of practices. It does not set out to provide solutions, but rather sets out to create an understanding of which method can be applied to a particular case.

The preferred methodology for most projects that are done therefore is through Object-oriented analysis and design (OOAD). Object-oriented analysis and design (OOAD) is a software development approach that analyses a system as a group of interacting objects. Software objects are conceptually similar to real-world objects, they too consist of state and related behavior. Basically, an object exposes its behavior through methods or functions.

The idea behind the selection of this methodology is to facilitate development of system components in a way that they are flexible and can be easily reused. It also facilitates changing of system requirements to improve functionality during the system lifetime. Concepts in the analysis model which is technology independent, are mapped onto implementing classes and interfaces resulting in a model of the solution domain, i.e., a detailed description of how the system is to be built on concrete technologies.
Object-oriented analysis and design enables the standardization of objects which increases design understanding and decreases the risk associated with project development.

Some of the pros of this methodology are:
Maintainability- Object-Oriented programming methods make code more maintainable. Identifying the source of errors becomes easier because objects are self-contained. The principles of good Object-Oriented Programming design contribute to an application’s maintainability.

Reusable-Because objects contain both data and functions that act on data, objects can be thought of as self-contained “boxes” (encapsulation).This feature makes it easy to reuse code in systems anywhere it suites.

Scalability is the ability of a system, network, or process, to handle growing amount of work in a capable manner or its ability to be enlarged to accommodate that growth. As an object’s interface provides a road-map for reusing the object in new software, it also provides you with all the information you need to replace the object without affecting other code. This makes it easy to replace old and aging code with faster algorithms and newer technology.

My next post shall give an exclusive breakdown of differences between object-oriented analysis and design and structure-oriented analysis and design.

Today's article focuses on more Object-Oriented programming concepts with a view to understanding these horror terms: Inheritance and Abstraction

Abstraction

We kick off this interesting series with Abstraction. Literally, abstraction is the tendency to go with ideas rather than events. From an OOP-perspective, abstraction refers to the a process of hiding the implementation details from the user, thus only the functionality will be provided to the user. In other words user will have the information on what the object does instead of how it does it.

Inheritance

Using the most realistic intro to this word, I would simply say that Inheritance is the tendency of classes to inherit commonly used state and behavior from other classes. Doesn't make sense I know right? Ideally, the derived class inherits the states and behaviors from the base class. The derived class is also called subclass and the base class is also known as super-class. The derived class can add its own additional variables and methods. Typical example: A mountain bike, a road bike all share the characteristics of bicycles i.e: current speed, current pedal layout, current gear. Yet each also defines additional features that make them different: road bikes have drop handlebars; some mountain bikes have an additional chain ring, giving them a lower gear ratio.

In this example, Bicycle now becomes the superclass of MountainBike and RoadBike. dditionally, it is important to note that in the Java programming language, each class is allowed to have one direct superclass, and each superclass has the potential for an unlimited number of subclasses.

Now for the implementation of Inheritance. Given that we already know how to create a class, we will go ahead to create a sublcass. We do this using the extends keyword.
public class MountainBike extends Bicyce{ // new fields and methods defining // a mountain bike to go here }

This gives MountainBike all the same fields and methods as Bicycle. My next post aims to focus exclusively on the other two elements of OOP which are: Encapsulation and Polymorphism

In today's blog post, I shall only discuss about the basic terminologies of OOP as well as a low-level implementation of the same.

Breaking down OOP, we have software objects which are often used to model the real-world objects that you find in everyday life. Therefore in this case, an example of an object would be a chair. It can be physical or logical (tangible and intangible). In more technical terms, an object is an instance of a class. This means an object a single and unique unit of a class.

A class refers to a blueprint or a prototype from which objects are created. A typical class is defined as having various methods (or attributes), has a particular data type e.t.c.

That said, a simple implementation of a class declaration in Java is below:
public class rhapsody{ //rhapsody here is the class name String chair; //String here is the data type
method;
}

Now here is a basic implementation of a class and object:

public class Rhapsody{ public Rhapsody(String name){
// This constructor has one parameter, name. System.out.println("Passed Name is :" + name );
} public static void main(String []args){
// Following statement would create an object myRhapsody
Rhapsody myRhapsody = new Rhapsody( "predator" );
} }

Compiling the above programme gives the following result: Passed Name is :predator

In my next blog post,I shall discuss more concepts on OOP, with a bigger emphasis on inheritance, encapsulation and polymorphism

On a lighter note:

Object-oriented programming offers a sustainable way to write spaghetti code. Adios!

So there you are, at your most devastating hour as a programmer. You're writing code, most of it probably spaghetti code. You're struggling. You probably don't know the concept of what you're doing. You become so paranoid, you want to smash your computer screen using your fist or maybe hurl the machine outside a window. The element of being ballistic! Heh?!

So what goes when all decides to work? You opt for profane version control practices in the name of version control. Being the bedraggled hacker that you are, you compose this commit message that speaks levels about your frustration in the build-up to getting things right in the software you were building. Below is a day in the life of paranoid dev who just got 'stuff working'.

git commit -a -m "Made shit work"

git commit -a -m "Added a bunch of semi colons that were missing for some balls weird reason."

My two cents on the element of obscenity would be: while it maybe 'normal' to use a little obscene language, there's nothing cool or enlightening about it. Any site built around it is at best noisy, but more like puking all over the screen. Additionally, it's baffling by this admiration of commit messages that do nothing to explain the code committed.

Ideally:Real hackers pivot two hours before their demo.

So, what is?

Picture this scenario: Imagine you applied for a job, but instead of offering you the job you wanted, they offered you a lower position. Being idealist you are, you would reject the offer, with the rationale that you would eventually find the job you wanted. As a pragmatist, you would accept the job, with the rationale that it's better than nothing and you might be get promoted or transferred to the job you actually wanted. That's to say, a pragmatist will compromise between his or her theoretically ideal outcome and the useful, practical actions he or she can actually take.
Does it mean that as a pragmatic you have settle? No. You basically switch your priorities. You are someone who knows what they want, and will take a few blows for the greater idea. It's all about applied logic and reasoning. Sure you may not have the best job, but its better than nothing. Someone with more confidence in their patient theories may come out ahead, but they may lose out on all that inactive time. That time they could have been pragmatic and more forceful.

#A pragmatist accepts a situation as it is, and seeks to benefit from it as best they can.

N/B: Be most of the things that society does not value....and don't ever regret it.