In Java, Lambda expressions basically express instances of functional interfaces.

Lambda Expressions in Java are the same as lambda functions which are the short block of code that accepts input as parameters and returns a resultant value.

Functionalities of Lambda Expression in Java

Lambda Expressions implement the only abstract function and therefore implement functional interfaces lambda expressions are added in Java 8 and provide the below functionalities.

• Enable to treat functionality as a method argument, or code as data.
• A function that can be created without belonging to any class.
• A lambda expression can be passed around as if it was an object and executed on demand.

// A sample functional interface (An interface with
// single abstract method
interface FuncInterface
{
    // An abstract function
    void abstractFun(int x);
 
    // A non-abstract (or default) function
    default void normalFun()
    {
       System.out.println("Hello");
    }
}
 
class Test
{
    public static void main(String args[])
    {
        // lambda expression to implement above
        // functional interface. This interface
        // by default implements abstractFun()
        FuncInterface fobj = (int x)->System.out.println(2*x);
 
        // This calls above lambda expression and prints 10.
        fobj.abstractFun(5);
    }
}

Output:

Lambda Expression Syntax

Reference:

https://www.geeksforgeeks.org/java/lambda-expressions-java-8/

nameless or without any identity is called anonymous.

To override the method in outer class of the inner class object.

Different ways of implement Anonymous Inner classes :

• using Concrete class
• using Abstract class
• using Interface
• as method argument

Why we use

In java 8, Lambda expression and Functional interface can be understand by these concepts.

Example Anonymous Inner class Using Concrete class

I have a class named as parent and another class named as child. child extends the parent class. So parent class method can be access by child class depends on access modifier.

public class parent {
	public static void main(String[] args) {
		child a = new child();
		a.educate();
		a.leave();
		a.salary();
	}
	
	public void educate()	
	{
		System.out.println("education");
	}

	public void leave()
	{
		System.out.println("leave");
	}

	public void salary()
	{
		System.out.println("90000");
	}
}

class child extends parent
{
	public void salary()
	{
		System.out.println("10000");
	}
}

Output

if we remove salary method in child then the output is

But the child need it own method definition go for anonymous inner class

code

parent a = new parent()
		{
			public void salary() {
				System.out.println(20000);
			}
		};

it is use to give a method for a single object. it must be end with ; (semicolon) like above code.

note : we can define method in inner class which are define in outer class.

Reference :

https://www.geeksforgeeks.org/java/anonymous-inner-class-java/

I am following this Baremetal Programming Series (Low Byte Productions Channel), inorder to learn about ARM microcontrollers, writing drivers (I've a goal to write a driver for a Serial Communication Protocol maybe CAN or Q-SPI, etc.) and learning some C constructs as well which I will then emulate in Renode.

Some notes,

• MACROS{.verbatim} are instructions that asks the C preprocessor to do text replacements.

• Behind the Scenes of libopencm3{.verbatim}

  • The memory mapped address of a pin is calculated in the pre-processing stage itself using macros.

• SYS_TICK{.verbatim} is like a Wall Clock.

• weak functions{.verbatim} are functions whose implementation can be redefined.

For Renode implementation, I just loaded the ELF of program used in the episode as like for the Hello World, Intro to Renode from Interrupt and I did used the same Makefiles and Linker scripts once again. (Those 2 seems to be a huge mess ? Is it ?)

I shouldn't be lazy enough to tinker them in future.

Then Looked the state of Pin A5 (External LED) and I could see that the state toggles. I think I could even log the data or check this working using Robot Framework.

Next, I need to look at Renode docs to discover more functionalities and then continue with Episode 3 on PWM and Timers!

Reproducability

• From this blog, I got aware of this reproducibility issue in RL i.e execution of same alogrithm in same enironment gives different results each time. It might be due different initial conditions, seeds etc for e.g. issues faced when reproducing a deep RL paper by Matthew Rahtz.

• For which the author proposes some statistical tests and he has a written a paper about this.

May be I have to have a look on it later.

• ACL has been already implemented by these guys.

• Some Eng resources I got,

  1. Nuts and Bolts of Deep RL Experimentation by John Schulman
  2. Notes by Falcon
  3. Nuts and Bolts of Deep RL Experimentation by John Schulman
  4. Notes by Falcon

micro-ROS

Today I did a hello world in micro-ROS. micro-ROS is used for interfacing ROS with resource constrained embedded devices. I had bought an ESP32-WROOM board since micro-ROS supports ESP, I thought of trying it and followed this post. In which I did,

• I had compiled the int32_publisher example using idf.py(provided by ESP) and flashed it to my ESP board.

• Then ran a micro-ROS agent(docker container) on my laptop and which recieved messages from ESP.

Basically we have to write a C code using ESP,micro-ROS and RTOS(FreeRTOS) libraries which then can be compiled & flashed into ESP and then it works accordingly. I had this issue with specifying the port for the agent.

Have to go through the rclc API.

I am gonna work on some project like with FreeRTOS & micro-ROS ?

Bayesian Optimization

Bayesian optimization is a powerful strategy for finding the extrema of objective functions that are expensive to evaluate. It is particularly useful when these evaluations are costly, when one does not have access to derivatives, or when the problem at hand is non-convex.

The Bayesian Optimization algorithm can be summarized as follows:

1. Select a Sample by Optimizing the Acquisition Function.
2. Evaluate the Sample With the Objective Function.
3. Update the Data and, in turn, the Surrogate Function.
4. Go To 1.

• It uses a
  • Surrogate function - that approximates the relationship between I/O data of the sample. There are many ways to model, one of the ways is to use Random Forest/Gaussian Process (GP, with many different kernels) i.e here we’re kind of approximating the objective function such that it can be easily sampled.
  • Acquisition function - It gives a sample that is to evaluated by the objective function. It is found by optimizing this function by various methods and it balances exploitation and exploration (E&E)[1].
• It is highly used in Tuning of Hyperparameters e.g. Optuna,HyperOpt.

Optuna

• API Reference

• This video gives a good intro.

I am trying to use it for HPO of lunar lander environment, initally results weren’t that good. I think it’s because of not giving a proper intreval i.e a large intreval that won’t result in a good choice of HP. May be I have to give try other ways to make it work.

Paper Reading

• I’m reading this paper, “Improving Environment Robustness of Deep Reinforcement Learning Approaches for Autonomous Racing Using Bayesian Optimization-based Curriculum Learning”, which I saw from ArXiV (in CS.RO) today, where they propose a method for automated curriculum selection which lead me to know about Bayesian Optimization.

• Curriculum Learning is about spoon feeding different environments for agent exploration, so that we can get a robust policy.

References

1. https://machinelearningmastery.com/what-is-bayesian-optimization/

Hi,

This is my first blog post. My main intention to have a blog is that,

• It will help me to think about what I wish to write up such that it is understandable by others which implies that I should have understood it at first.
• It will enhance my writing skills.
• Mainly, It will be a kind of “Journal”ing and that it would be nicer to look about what you have done/thought in the past.

In this tutorial, we show the list of result in paging concepts. Like page 1 and no. of results 10.

Page 1 has 1-10 results, page 2 has 11-20 results, page 3 has 21-30 results.

Like page 2 and no. of results 20.

Page 2 has 31-40 results, page 3 has 3-30 results.

	List<Owner> ownerList = ownerRepo.findAll();
    int pageNumber =1, pageSize=5;
	List<Owner> pagingResult =ownerList.stream() 
			.skip((long) (pageNumber -1) * pageSize) 
			.limit(pageSize) 
			.toList(); 	

Explaination:

In above code, ownerList have list of Owner Objects.

• Convert the list into steam by steam().
• Skip the first results .
  • like page 2 and results 5 means skip the 1-5 then start from 6 – 10.
  • so we multiple (2-1) * 5 to result is 5 => we get result start from 6.
• limt the pages .
  • we got the result so we limit the result to pageSize.
  • limit(pageSize).
• Convert the result into list.

Reference

https://www.digitalocean.com/community/tutorials/java-stream-collect-method-examples

https://www.youtube.com/watch?v=J2pxQFmQsN0

Class based Annotation:

• @Entity – used to indicates the class is below to JPA entites.
• @Table – is used to indicates the table name.
• @MappedSuperClass – is used to parent entity, which can be inherited by many entities, but it won’t be mapped to its own table. we cannot use @Entity annotation on this class.

@MappedSuperclass
public abstract class BaseEntity implements Serializable {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    // Getters and setters
    public Long getId() {
        return id;
    }

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

@Entity
@Table(name = "employees")
public class Employee extends BaseEntity {

    private String firstName;
    private String lastName;
    
    // Constructors, getters, setters, other fields...
}

1. In this example, the BaseEntity class is annotated with @MappedSuperclass. It contains the common fields that you want to share across multiple entity classes.
2. The Employee class inherits from BaseEntity, effectively inheriting the id field from the superclass.
3. By using @MappedSuperclass, you’re able to create a common base class for your entity hierarchy while allowing each subclass to include additional fields and annotations specific to their needs.
4. This promotes code reusability and maintains a clean and structured entity hierarchy.

Primary Keys

• Define a primary key using @Id.
• Use @GeneratedValue with appropriate strategy for generating primary key values (e.g., GenerationType.IDENTITY, GenerationType.SEQUENCE)

@Entity
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    // other fields, getters, setters
}

Associations

It says the relationship between two entity class.

1. Use @OneToOne, @OneToMany, @ManyToOne, and @ManyToMany to define relationships between entities.
2. Use fetch attribute to control loading behavior (e.g., LAZY or EAGER).
3. Utilize mappedBy to define the owning side of bidirectional relationships.

@Entity
public class Department {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;

    @OneToMany(mappedBy = "department",cascade=CascadeType.ALL)
    private List<Employee> employees;

    // Constructors, getters, setters, other fields...
}

@Entity
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String firstName;
    private String lastName;

    @ManyToOne
    @JoinColumn(name = "department_id")
    private Department department;

    // Constructors, getters, setters, other fields...
}

Cascading Operations

• Use cascade attribute to specify cascading operations (e.g., CascadeType.ALL, CascadeType.PERSIST).
• Be cautious with cascading DELETE to avoid unintentional data loss.

import javax.persistence.*;
import java.util.List;

@Entity
public class Author {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;

    @OneToMany(mappedBy = "author", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<Book> books;

    // Constructors, getters, setters, other fields...
}

@Entity
public class Book {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String title;

    @ManyToOne
    @JoinColumn(name = "author_id")
    private Author author;

    // Constructors, getters, setters, other fields...
}

1. CascadeType.ALL: This option specifies that all operations (e.g., persist, merge, remove) should be cascaded from the parent entity (Author) to the child entity (Book).
2. orphanRemoval = true: This option specifies that when an Author entity’s reference to a Book entity is removed from the books collection, the orphaned Book entity should also be removed from the database

When you perform a cascading operation on the Author entity, the corresponding operation will cascade to the associated Book entities. For instance.

Author author = new Author();
author.setName("J.K. Rowling");

Book book1 = new Book();
book1.setTitle("Harry Potter and the Sorcerer's Stone");
book1.setAuthor(author);

Book book2 = new Book();
book2.setTitle("Harry Potter and the Chamber of Secrets");
book2.setAuthor(author);

author.setBooks(Arrays.asList(book1, book2));

// Cascading persist: Saving the author will also save both associated books.
entityManager.persist(author);

Likewise, cascading operations work for merge, remove, and other entity operations, reducing the need for explicitly managing related entities persistence.

Validation

Use validation annotations (@NotNull, @Size, etc.) to enforce data integrity constraints directly in the entity class.
Combine JPA validation with Spring’s @Valid annotation to automatically validate incoming data.

@Entity
public class Post {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @NotBlank(message = "Title is required")
    @Size(max = 100, message = "Title must be at most 100 characters")
    private String title;

    @OneToMany(mappedBy = "post", cascade = CascadeType.ALL)
    private List<Comment> comments;

    // Constructors, getters, setters, other fields...
}

@Entity
public class Comment {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @NotBlank(message = "Text is required")
    @Size(max = 500, message = "Text must be at most 500 characters")
    private String text;

    @ManyToOne
    @JoinColumn(name = "post_id")
    private Post post;

    // Constructors, getters, setters, other fields...
}

Auditing

• Implement entity auditing by adding fields like @CreatedBy, @CreatedDate, @LastModifiedBy, and @LastModifiedDate for tracking who created or modified an entity and when.
• Utilize Spring’s @EntityListeners to manage the auditing behavior.

@EntityListeners(AuditingEntityListener.class)
@MappedSuperclass
public abstract class Auditable {
    @CreatedBy
    protected String createdBy;

    @CreatedDate
    @Column(nullable = false, updatable = false)
    protected LocalDateTime createdDate;

    @LastModifiedBy
    protected String lastModifiedBy;

    @LastModifiedDate
    protected LocalDateTime lastModifiedDate;

    // Getters and setters...
}

1. @EntityListeners(AuditingEntityListener.class): This annotation specifies that this entity should be audited using the provided entity listener class. Spring Data JPA will automatically update the auditing fields before persisting or updating the entity.
2. @MappedSuperclass: This annotation indicates that this class is not an entity itself but serves as a base class for other entities. It allows attributes and behaviors to be inherited by other entities.
3. @CreatedBy: This annotation specifies the field to store the username of the user who created the entity.
4. @CreatedDate: This annotation marks the field to store the timestamp when the entity was created. The nullable and updatable properties are set to false to ensure that this field is populated during creation and not updated afterwards.
5. @LastModifiedBy: This annotation specifies the field to store the username of the user who last modified the entity.
6. @LastModifiedDate: This annotation marks the field to store the timestamp when the entity was last modified.

By implementing auditing, you can track who created or modified entities and when those actions occurred. This information can be invaluable for monitoring and maintaining your application’s data.

Enums and Enumerated Types

• Use Java enums for fields with predefined values.
• Annotate enum fields with @Enumerated(EnumType.STRING) to store enum values as strings in the database.

@Entity
public class Task {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Enumerated(EnumType.STRING)
    private TaskStatus status;
    // other fields, getters, setters
}

public enum TaskStatus {
    TODO, IN_PROGRESS, DONE
}

Reference:

• https://medium.com/@bubu.tripathy/best-practices-entity-class-design-with-jpa-and-spring-boot-6f703339ab3d
• https://medium.com/@bubu.tripathy/best-practices-entity-class-design-with-jpa-and-spring-boot-6f703339ab3d