We can understand this in two ways.

Objective feedback

In objective evaluation, an external system verifies whether the generated output is correct.

Coding agent

Let's suppose we are building a Python code generator that generates functions for a given task

Just see the image above that shows a coding agent that generates code v1 in the first pass; then the runner runs the code. If any error comes, then with the error and code v1 passes to the LLM again, based on the feedback, produce a result again, and so on until the code runs or to max iterations.

Subjective feedback example

An agent that writes an essay

In this case, the reviewer or critic is an LLM, not any external tool; the input reviewer could be the same model(self), some other model, or a human.

Eval methods to evaluate the reflections

Objective Evals

We prepare a benchmark dataset containing inputs and expected outputs; if that passes, we consider the agent is ready.

e.g.

1. Above code-based example

2. Build a dataset and evaluate on that (SQL): We create an agent that generates the SQL queries.

Subjective Evals

Since quality is subjective, we provide the evaluator with clear evaluation criteria or a rubric so that it reviews the response consistently.

e.g.

1. Use an LLM as a guide to evaluate

2. Rubric-based, where you would define the rules step by step

Ref: Andrew Ng course

The first mode of communication is called symmetric cryptography where a single key is shared between two parties, the same key is used to encrypt and decrypt.

Symmetric Methods are AES, DES.

The second mode of encryption is called asymmetric cryptography in which public key, private keys are used. A public key is used to encrypt the data and the person who will have a private key will be able to read the message.

Asymmetric Methods are RSA, ECC.

Rust take a very unique approach to manage the heap memory but before that let’s first look how allocation and deallocation are generally handled and then explore the rust model

Allocation

Internally, Rust uses system allocator to allocate the memory, just like new in C++, Go, Java and malloc, calloc in C.

In Rust
let obj:Box<String> = Box::new();

In C++
int* ptr = new int(42);

In C
int *ptr=(int*)malloc(sizeof(int)*5);

in JAVA
String name = new String("Hello");

In Go
mp:=make(map[string]string)

Deallocation

In C and C++ programmer has to deallocate the memory, In Java and Go Garbage collector deallocates the memory from heap.

But Rust uses very unique approaches to deallocate the heap memory; when a variable’s scope ends it calls drop function and cleans up the heap memory. This is made possible by ownership which is a set of rules enforced at compile time. There’s no garbage collector in Rust; instead, Ownership, Borrowing, and Lifetimes ensure memory safety without runtime overhead. let discuss these concepts in detail.

Ownership

This is the concept which enforces that one value in memory will have only one owner at a time. As the owner go out of scope automatically free the memory and no need of garbage collection.

This guarantees:

• No double frees

• No use-after-free

• Automatic cleanup

let owner1:String=String::from("Hello");

here owner1 is owner of string Hello

let owner2=owner1;

now owner2 is owner of the string Hello and using owner1 you can't perform any kind of operation like push etc.

Borrowing

When you have a value in Rust, it’s owned by exactly one variable. If you want to let other parts of your code access it without moving ownership, you borrow it.

Borrowing is how Rust ensures:

• No dangling pointers

• No data races (even in multithreaded code)

• Memory is freed exactly once

There are two types of borrowing

• Mutable: Can modify the value but at a time only one mutable borrowing is possible.

  let mut s = String::from("Maneesh");
  let r1 = &mut s;
  // let r2 = &mut s; // you will get compilation error

• Immutable: read only access to the memory

  let s = String::from("Maneesh");
  let a = &s;
  let b = &s; 
  println!("{}, {}", a, b);

Lifetime

When reference is passed at that time compiler has to know that when the owner of referenced memory will be invalid or go out of the scope. Reference should not outlive that can cause dangling pointer that’s how rust ensure memory safety.

 fn longest<'a>(s1: &'a str, s2: &'a str) -> &'a str {
    if s1.len() > s2.len(){ 
           s1 
          } else { 
           s2
       }
}

‘a is the life time expression, input and output must live at least as long as ‘a is live. Every reference has lifetime explicit or implicit, lifetime only needed when compiler can’t infer. It is also checked at compile time so no runtime overhead.

When a compiled/executable program gets loaded in memory it becomes a process and operating systems manages all relevent process information like process id, process state etc. into the Process Control Block(PCB). A typical process in memory is divided into the following major segments

Code/Text Segment

• Contains the compiled executable machine code.

• This is read only section to prevent accidental modification.

• This section can be shared with the other instances of the same program for saving resource.

Data Section

• This section stores the all static and global variables.

• It’s a read-write section.

• It's further divided into:

  • Initialized data (variables with explicit initial values)

  • Uninitialized data (BSS) (variables that are zero-initialized by default)

Stack

• This is the section where all local variable and function parameter return address on function get stored.

• It operates in Last in First out manner it grows towards the lower memory address.

• Managed automatically by runtime.

Heap

• This is used for dynamic memory allocation(object which size is not known at compile time get stored here like vector, string, map etc.)

• Grows upward towards the higher memory address.

• It is managed by programmer in C, CPP and by runtime in Go and JAVA.

• Our most of the discussion will be around the heap memory because most of the problem comes in heap.

How memory get allocated & deallocated?

• In C, when we write malloc() it allocates memory in heap and when we use free(), then frees the memory.

• In Java or Go just use the make() or new and do not care about the either memory allocation or deallocation, runtime and Garbage collector(CG) take care about the memory allocation and deallocation. but it comes with some cost.

• And then Rust came in the picture with the complete new memory model which enforces deterministic deallocation via ownership, borrowing and lifetime whenever the scope of the function over then memory allocated in heap also get deallocated without involving GC.

we can say that now we have three types of programming language First in which programmer has to allocate and deallocate the heap memory. Second one is which allocation will taken care by runtime and deallocation will be taken care by GC. Third one in which allocation will taken care by runtime but heap memory is freed automatically and deterministically when the owner goes out of scope so no manual or no GC.

Subscribe now

There are two built-in function in Go to allocate the memory new() and make() both works on different type and do different work. Knowing the difference between is must to write the clean code.

1. What new() function does and where to use ?

It only allocates zeroed memory but does not initialize the memory. It returns the pointer(address) to the allocated memory.

var price1 *int

price2:= new(int)

both price1 and price are of similar type but price2 has allocated zeroed memory but price1 is not having any memory.

type Car struct {

 Type string

 Number string

}

func main() {

 car1 := new(Car) 

 car2 := &Car{}

 fmt.Println(car1)

 fmt.Println(car2)

}

car1 and car2 is of similar type, we can conclude that

2. What make() function does and where to use ?

It is used to allocated the memory and initalize int internal data structure needed for the map, channel, slices and returns the value of these type.

s := make([]int, 10, 15) 
m := make(map[string]int)
c := make(chan int, 5)

3. Comparison

 s := make([]int, 10, 15)    // Creates a slice with length 10 and capacity 15
         
p := new([]int) // Allocates memory for a slice pointer, but the slice is nil
        
fmt.Println(*p) // Prints []

*p = make([]int, 10, 15) // To initialize the slice pointed by p, you'd need to use make
fmt.Println(*p) // Prints [0 0 0 0 0 0 0 0 0 0] 

5. Conculsion

We can conlude that new() is more generic while make() can be used only for the map, slices and channels.