Update README.md

Author: trueangle

.github/workflows/buildLinux_x86_64.yml

@@ -25,5 +25,4 @@ jobs:
       - name: Upload artifacts
         uses: actions/upload-artifact@v4
         with:
-          name: kotlin-native-build
-          path: sample/build/bin/lambda/release
+          path: sample/build/lambda/release/sample.zip

README.md

@@ -1,37 +1,38 @@
 # Kotlin Native Runtime for AWS Lambda
 [![Maven Central](https://maven-badges.herokuapp.com/maven-central/io.github.trueangle/lambda-runtime/badge.svg)](https://maven-badges.herokuapp.com/maven-central/io.github.trueangle/lambda-runtime/badge.svg)
 
-A runtime for executing AWS Lambda Functions powered by Kotlin Native, designed to mitigate known
-cold start issues associated with the JVM platform.
+A runtime for executing AWS Lambda Functions using Kotlin Native, designed to reduce cold start issues common with the JVM platform.
 
-Project structure:
+## Project Structure
 
-- `lambda-runtime` — is a library that provides a Lambda runtime.
-- `lambda-events` — is a library with strongly-typed Lambda event models, such
-  as `APIGatewayRequest`, `DynamoDBEvent`, `S3Event`, `KafkaEvent`, `SQSEvent` and so on.
+- `lambda-runtime`: Library providing the Lambda runtime.
+- `lambda-events`: Library with strongly-typed Lambda event models like `APIGatewayRequest`, `DynamoDBEvent`, `S3Event`, `KafkaEvent`, `SQSEvent`, etc.
+- `sample`: Sample project demonstrating examples of lambda functions.
 
-The runtime supports the
-following [OS-only runtime machines](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html):
+## Supported [OS-only runtime machines](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html)
 
 - Amazon Linux 2023 (provided.al2023) with x86_64 architecture
 - Amazon Linux 2 (provided.al2) with x86_64 architecture
 
 ## Performance
 
-Performance benchmarks reveal that Kotlin Native's "Hello World" Lambda function, executed on Amazon
-Linux 2023 (x86_64) with 1024MB of memory, ranks among the top 5 fastest cold starts. Its
-performance is on par with Python and .NET implementations. For a comparison with other languages (including Java), visit https://maxday.github.io/lambda-perf/.
+Benchmarks show that Kotlin Native's "Hello World" Lambda function on Amazon Linux 2023 (x86_64) with 1024MB memory is among the top 5 fastest cold starts, comparable to Python and .NET. For more details, visit [lambda-perf](https://maxday.github.io/lambda-perf/).
 
 ![Kotlin Native AWS Lambda Runtime benchmarks](docs/performance_hello_world.png)
 
 ## Getting started
 
-To create a simple lambda function, follow the following steps:
+### 1. Create a Kotlin Multiplatform Project
+See [Kotlin Native](https://kotlinlang.org/docs/native-overview.html) for more details.
 
-1. Create Kotlin multiplatform project
-2. Include library dependency into your module-level build.gradle file
+### 2. Add Dependencies
 
+Add the following to your `build.gradle` file:
 ```kotlin
+plugins {
+    id("io.github.trueangle.plugin.lambda") version "0.0.1"
+}
+
 kotlin {
     sourceSets {
         nativeMain.dependencies {
@@ -42,29 +43,27 @@ kotlin {
 }
 ```
 
-3. Specify application entry point reference and supported targets
+### 3. Specify Entry Point and Targets
 ```kotlin
 kotlin {
     listOf(
         macosArm64(),
         macosX64(),
-        linuxArm64(),
         linuxX64(),
     ).forEach {
         it.binaries {
             executable {
-                entryPoint = "com.github.trueangle.knative.lambda.runtime.sample.main"
+                entryPoint = "com.github.trueangle.knative.lambda.runtime.sample.main" // Change this to your entry point
             }
         }
     }
 }
 ```
 
-4. Choose lambda function type. There are two types of lambda functions:
+### 4. Choose Lambda Function Type
 
-### Buffered 
-Buffered Lambda function collects all the data it needs to return as a response before sending
-it back. This is a default behavior of Lambda function. Response payload max size: 6 MB.
+#### Buffered 
+Buffered Lambda functions collect all data before sending a response. This is a default behavior of Lambda function. Response payload max size: 6 MB.
 
 ```kotlin
 class HelloWorldLambdaHandler : LambdaBufferedHandler<APIGatewayV2Request, APIGatewayV2Response> {
@@ -83,13 +82,8 @@ class HelloWorldLambdaHandler : LambdaBufferedHandler<APIGatewayV2Request, APIGa
 }
 ```
 
-### Streaming
-Streaming function, on the other hand, sends back data as soon as it's available, rather than
-waiting for all the data to be ready. It processes and returns the response in chunks, piece by
-piece, which can be useful when you want to start delivering results right away, especially for
-large or ongoing tasks. This allows for faster responses and can handle data as it comes
-in. [More details here](https://docs.aws.amazon.com/lambda/latest/dg/configuration-response-streaming.html).
-For example, `SampleStreamingHandler` reads a large json file and streams it by chunks.
+#### Streaming
+A streaming function sends data as soon as it's available, instead of waiting for all the data. It processes and returns the response in chunks, which is useful for large or ongoing tasks. This allows for faster responses and can handle data as it comes in. [More details here](https://docs.aws.amazon.com/lambda/latest/dg/configuration-response-streaming.html). For example, `SampleStreamingHandler` reads a large json file and streams it in chunks.
 
 ```kotlin
 class SampleStreamingHandler : LambdaStreamHandler<ByteArray, ByteWriteChannel> {
@@ -102,10 +96,8 @@ class SampleStreamingHandler : LambdaStreamHandler<ByteArray, ByteWriteChannel>
     }
 }
 ```
-
-5. Specify application entry point using standard `main` function. Call `LambdaRuntime.run` to
-   execute Lambda
-   by passing handler to it.
+### 5. Specify Application entry point
+Using standard `main` function. Call `LambdaRuntime.run` to execute Lambda by passing handler to it.
 
 ```kotlin
 fun main() = LambdaRuntime.run { HelloWorldLambdaHandler() }
@@ -122,21 +114,18 @@ For more examples refer to project's sample.
 
 ## Testing Runtime locally
 
-To run runtime
-locally [aws runtime emulator](https://github.com/aws/aws-lambda-runtime-interface-emulator) is
-used. Here's how to run project's sample:
+Use the [AWS runtime emulator](https://github.com/aws/aws-lambda-runtime-interface-emulator) to run the runtime locally.
 
-1. `./gradlew build` to build lambda executable
-2. Modify runtime-emulator/Dockerfile to set proper path to the generated executable (.kexe) file,
-   located in build/bin/linuxX64/releaseExecutable
+1. `./gradlew build` to build the Lambda executable.
+2. Modify `runtime-emulator/Dockerfile` to set the path to the generated executable (.kexe) file in `build/bin/linuxX64/releaseExecutable`.
 3. Run `docker build -t sample:latest .`
 4. Start server `docker run -p 9000:8080 sample:latest`
-5. Execute function
+5. Execute the function
    using `curl -XPOST "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{}'`
 
 ## Build and deploy to AWS
 
-1. Apply plugin `id("io.github.trueangle.plugin.lambda") version "0.0.1"`
+1. Apply the plugin `id("io.github.trueangle.plugin.lambda") version "0.0.1"`
 2. Execute `./gradlew buildLambdaRelease`. The command will output the path to the archive containing lambda executable (YOUR_MODULE_NAME.kexe) located in (YOUR_MODULE_NAME/build/bin/lambda/release/YOUR_MODULE_NAME.zip)
 3. Deploy .zip archive to AWS. If you have never used AWS Lambda
    before, [learn how to deploy Lambda function as zip archive manually](https://docs.aws.amazon.com/lambda/latest/dg/configuration-function-zip.html)
@@ -153,7 +142,7 @@ $ aws lambda create-function --function-name LAMBDA_FUNCTION_NAME \
   --tracing-config Mode=Active
 ```
 
-You can now test the function using the AWS CLI or the AWS Lambda console
+Test the function using the AWS CLI:
 
 ```bash
 $ aws lambda invoke
@@ -174,8 +163,7 @@ making log management and aggregation more efficient at scale. More details on h
 and level refer to the article.
 https://aws.amazon.com/blogs/compute/introducing-advanced-logging-controls-for-aws-lambda-functions/
 
-To log lambda function code, use the global Log object with extension functions. The log message
-accepts any object / primitive type.
+Use the global Log object with extension functions. The log message accepts any object / primitive type.
 
 ```kotlin
 Log.trace(message: T?) // The most fine-grained information used to trace the path of your code's execution
@@ -191,23 +179,14 @@ Log.error(message: T?) // Messages about problems that prevent the code from per
 Log.fatal(message: T?) // Messages about serious errors that cause the application to stop functioning
 ```
 
-## Troubleshoot
-
-- If you're going to use Amazon Linux 2023 machine, you'll need to create
-  a [lambda layer](https://docs.aws.amazon.com/lambda/latest/dg/chapter-layers.html) with
-  libcrypt.so dependency. This is a dynamic library and seems not included into Amazon Linux 2023
-  container. The lybcrypt.so can be taken directly from your linux machine (e.g. from
-  /lib/x86_64-linux-gnu/libcrypt.so.1 ) or via the
-  following [Github Action workflow](https://github.com/trueangle/kotlin-native-aws-lambda-runtime/actions/workflows/libcrypt.yml).
-  Once retrieved, zip it and upload as a layer to your lambda function.
+## Troubleshooting
 
-- For the time being, only x86-64 architecture is supported by the runtime. LinuxArm64 is not
-  supported by Kotlin Native still, details:
+- For Amazon Linux 2023, create a [Lambda layer](https://docs.aws.amazon.com/lambda/latest/dg/chapter-layers.html) with the libcrypt.so dependency. This library can be taken from your Linux machine or via the [Github Action workflow](https://github.com/trueangle/kotlin-native-aws-lambda-runtime/actions/workflows/libcrypt.yml).
+- Currently, only x86-64 architecture is supported by the runtime. LinuxArm64 is not supported by Kotlin Native yet, For more details, see:
     1. The list of supported targets for Kotlin Native (
        2.0.20-RC2) https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-native-prebuilt/2.0.20-RC2/
-    2. Opened
-       issue: https://youtrack.jetbrains.com/issue/KT-36871/Support-Aarch64-Linux-as-a-host-for-the-Kotlin-Native
-- If you are running the project build on MacOs you might come across a set of errors connected with
+    2. https://youtrack.jetbrains.com/issue/KT-36871/Support-Aarch64-Linux-as-a-host-for-the-Kotlin-Native
+- If you are running the project build on MacOS you might come across a set of errors connected with
   curl linking e.g. `ld.lld: error: undefined symbol: curl_global_init`. This means that your local
   machine [uses different curl version from what is requested by the runtime](https://youtrack.jetbrains.com/issue/KTOR-6361/Curl-Error-linking-curl-in-linkDebugExecutableLinuxX64-on-macOS).
   To solve that either