Forem: Sendil Kumar

Java turns 28

Sendil Kumar — Thu, 25 May 2023 14:30:57 +0000

Java turned 28 this week!

My favourite 28 features in Java as it turns 28

Sendil Kumar ・ May 25 ・ 5 min read

#java

What are your most (or least) favourite thing about #java?

My favourite 28 features in Java as it turns 28

Sendil Kumar — Thu, 25 May 2023 11:29:52 +0000

Java turned 28 this week! Here are my 28 favourite features/APIs in it.

What are your favourite features/APIs comment below?

Sharat Chander 🟧

@sharat_chander

☕️☕️🎂🎂🥳🥳🎂🎂☕️☕️
Happy Birthday, #Java! 28 amazing years!

What's your favorite Java memory or photo? Post now and use the #28YearsOfJava hashtag!

Stay connected: dev.java
☕️☕️🎂🎂🥳🥳🎂🎂☕️☕️

15:38 PM - 23 May 2023

1. Collections

Java 2 introduced the collections framework.

"The collections framework is a unified architecture for representing and manipulating collections... It reduces programming effort while increasing performance"

Link to Collections

P.S. Oh yeah! I used generics \o/

2. Non-Blocking Input Output (NIO)

Java 4 introduced NIO (New Input/Output) API. They were high level abstraction APIs designed to provide efficient operations on the low-level I/O operations. Later on Java 7 extended these non-blocking I/O for filesystem access.

Link to NIO API

3. Generics

Java 5 came with Generics. Hate it or love it. IMHO this is one of the key features to be released at that time. It reduced bugs and added an extra layer of abstraction over types.

Generics

4. Annotations

Annotation was another feature Java 5 came with.

"Annotations, a form of metadata, provide data about a program that is not part of the program itself. Annotations have no direct effect on the operation of the code they annotate."

Annotations

5. Varargs...

Java 5 also introduced Varargs. They provided a short-hand for methods that support an arbitrary number of parameters of one type.

SafeVarargs & Variable arguments in Java | by sendilkumarn | Medium

sendilkumarn ・ Dec 21, 2018 ・
sendilkumarn.Medium

6. Concurrency

Java 5 also improved concurrency.

"APIs under java.util.concurrency, these APIs have been designed to support concurrent programming, and all execution takes place in the context of threads"

7. Enhanced For-Each Loop

I loved this enhanced for-each loop when it was released. It was easy and who cares about the index when all you need is the value.

8. Garbage Collection Improvements

Java 6 is all about performance there were huge performance improvements for the core platform and even on Swing. It is in Java 6 we saw a few new GC algorithms too.

Java GC Basics

9. TimSort

Java 7 replaced MergeSort[1] to TimSort[2] for the Collections and Arrays sorting 🚀

MergeSort
TimSort

10. Lambda

Java 8 is an amazing release. Project Lambda is the pinnacle of this release.

11. <Optional>

Java 8 introduced Optional to prevent us from NPE.

"A container object which may or may not contain a non-null value. If a value is present, isPresent() will return true and get() will return the value."

Optional

12. Functional Interface

Lambda's are amazing and they organically lead to Functional interfaces.

"A functional interface in Java is an interface that contains only a single abstract (unimplemented) method."

13. JShell

Java 9 brought in JShell.

"JShell is a REPL tool, which evaluates declarations, statements, and expressions as they are entered and immediately shows the results. The tool is run from the command line."

JEP-222

14. Modules

Remember Zigsaw from Java 9.

"The Java Platform Module System specifies a distribution format for collections of Java code and associated resources"

Jigsaw

15. Vars

Java 10 released with much awaited Local Variable Type inference a.k.a "var". The verbose Java becomes inferred Java.

JEP-286

16. Faster Release cycles

Major release every 6 months. Reduced the release cycle duration. No long wait for newer version and features.

JEP-322

17. Flight Recorder

Java 11 came with Flight Recorder, which provided a low-overhead data collection framework for troubleshooting Java applications and the HotSpot JVM.

JEP-328

18. Single File Source

Java 11 allowed us to launch single file Java programs via Java command.

Java HelloWorld.java

JEP-330

19. RIP Applets

Java 11 bid farewell to Java Applets / Java Web Start / JavaFX and others.

20. Switch Expressions

Java 12 came with switch expressions

JEP-325

21. GC - Shenandoah

Java 12 also introduced a new GC algorithm named Shenandoah. This amazing algorithm provided consistent pause time irrespective of your heap size.

JEP-189

22. Text Blocks

Java 13 came with Text Blocks. Multi-line texts made easy.

JEP-355

23. Pattern Matching

Java 14 launched with Pattern Matching for instanceof

JEP 305, Pattern Matching for instanceof simplifies the common case of an instanceof test being immediately followed by cast (see the code snippet)

JEP-305

24. Records

Java 14 also launched with Records.

Records allows easy creation of simple immutable Tuple-like classes.

JEP-359

25. Sealed Classes

Java 15 introduced sealed classes.

JEP-360

My blog post that talks about sealed classes and interfaces - https://sendilkumarn.com/blog/java-17

26. Vector API/SIMD

Java 16 came with Vector API.

"Single instruction, multiple data (SIMD)"

JEP-338

27. Virtual Threads

Jumping to Java21, it finalized and introduced virtual threads to the java platform.

"Virtual threads are lightweight threads that dramatically reduce the effort of writing, maintaining, and observing high-throughput concurrent applications."

JEP-444

28. Community

Last but not least! The amazing community of #java ❤️

What are your favorite features of #java comment below?

sendilkumarn

@sendilkumarn

@java turns 28 today!

twitter.com/Sharat_Chander…

Here is a thread on my favorite Java features/APIs/releases 🧵

21:44 PM - 23 May 2023

Sharat Chander 🟧 @Sharat_Chander
☕️☕️🎂🎂🥳🥳🎂🎂☕️☕️ Happy Birthday, #Java! 28 amazing years! What's your favorite Java memory or photo? Post now and use the #28YearsOfJava hashtag! Stay connected: https://t.co/7WRXM7EvX8 ☕️☕️🎂🎂🥳🥳🎂🎂☕️☕️ https://t.co/jj3AM0yKbT

My Other Posts on Java

Interesting features in Java 17

Sendil Kumar ・ Feb 5 '22 ・ 7 min read

#java #programming #features #beginners

Java enters its teenage 🎉 🎂

Sendil Kumar ・ Sep 22 '19 ・ 4 min read

#java #programming #jvm #features

9 tips to Increase your Java performance ☕️ 🚀 🚶‍♂️

Sendil Kumar ・ Jul 20 '19 ・ 4 min read

#java #performance #codequality #codenewbie

My top 5 book recommendations for EMs

Sendil Kumar — Mon, 15 May 2023 22:17:25 +0000

Transitioning from an engineer to an engineering manager is an exciting career move that requires developing new skills and knowledge. There are several great books that can help you navigate this transition and excel in your new role. Here are some recommendations based on what I loved/enjoyed when I started as an Engineering Manager:

The Making of a Manager: What to Do When Everyone Looks to You by Julie Zhuo: The book is written in a simple style and is very practical and relatable. Julie Zhuo shares her personal experiences and challenges in a high-growth environment. I have spent a lot of time reflecting on this book and constantly return to it. Definitely recommend it for anyone starting as an Engineering Manager.

Link to the making of a manager

The Manager's Path: A Guide for Tech Leaders Navigating Growth and Change by Camille Fournier: If you are looking for a book that offers practical advice and insights for managers in the tech industry, focusing on the various stages of a manager's career and the challenges they may face along the way. The writing style of this book is candid and relatable. From being an IC to leading large teams, this book provides insights into different stages of a technical manager's career. It covers topics like mentoring, communication, and organizational dynamics.

Link to the manager path

The Lean Startup: How Today’s Entrepreneurs Use Continuous Innovation to Create Radically Successful Businesses by Eric Ries: While this book isn't specifically geared towards engineering managers, it offers valuable insights into how to build and scale successful products and teams using a lean methodology. It emphasizes experimentation, rapid iteration, and customer feedback. No waste!

Link to the lean startup

High Output Management by Andrew S. Grove: Written by the former CEO of Intel, this classic management book offers valuable guidance on managing and optimizing team productivity. It covers topics such as goal setting, performance evaluation, and effective meetings.

Link to the high output management

Crucial Conversations: Tools for Talking When Stakes Are High by Kerry Patterson, Joseph Grenny, Ron McMillan, and Al Switzler: As an engineering manager, you'll inevitably encounter challenging conversations. This book provides strategies for navigating difficult discussions and resolving conflicts effectively.

Link to the crucial conversations

Honorary Mentions

Radical Candor: Be a Kick-Ass Boss Without Losing Your Humanity by Kim Scott: This book explores the concept of radical candor, which emphasizes the importance of direct communication and caring personally while providing feedback and managing teams. (book)

The Hard Thing About Hard Things: Building a Business When There Are No Easy Answers by Ben Horowitz: This book offers insights into the challenges of leading a company, including making tough decisions, managing crises, and dealing with failure. (book)

You can follow me on Twitter too!

I hope you find these recommendations useful! Feel free to share other books that have helped you and/or how they did it.

Diversity & Inclusion in hiring

Sendil Kumar — Mon, 15 May 2023 16:19:32 +0000

Creating a diverse and inclusive workplace is crucial for any organization that wants to succeed in today's global economy. Not only does it promote collaboration and innovation, but it also helps attract and retain top talent. In this post, we will discuss practical tips and guidelines for building a more diverse and inclusive organization by focusing on the hiring process.

Start with a Clear Job Description

One of the first steps in building a diverse and inclusive organization is to have a clear job description that reflects the company's values and culture. In addition to standard text that claims to value diversity and equality, hiring managers should specify what they are looking for in a candidate. This will help attract candidates who share the company's values and are more likely to contribute to a diverse and inclusive workplace.

Source Candidates from Diverse Channels

To ensure that the pool of applicants is not limited to a particular group, it's important to source candidates from diverse channels. This can include job boards that specifically target underrepresented groups, attending job fairs or events hosted by organizations that promote diversity, and reaching out to professional associations that focus on diversity and inclusion.

Use a Diverse Panel of Interviewers

Having a diverse panel of interviewers can help prevent unconscious biases from affecting the hiring decision. It's important to ensure that the interviewers come from different backgrounds and have different perspectives. This will help ensure that the hiring decision is based on the candidate's qualifications and skills rather than their personal characteristics.

Periodically Monitor Progress

It's important to periodically monitor the progress of diversity and inclusion efforts. This can be done by analyzing data and metrics related to hiring, retention, and promotion of employees from different backgrounds. Making the process public can also help hold the company accountable for its efforts.

Identify and Correct Biases

Identifying and correcting biases that may exist in the hiring process is crucial for building a more diverse and inclusive workplace. By learning from mistakes and re-applying these measures, companies can create a more inclusive and equitable workplace that benefits everyone involved.

In conclusion, building a diverse and inclusive workplace starts with the hiring process. Companies should create a workplace that values and respects everyone, regardless of their background.

If you like this article, please leave likes/comments. Want more subscribe to my newsletter on Substack

You can follow me on Twitter and LinkedIN.

State of the WebAssembly 2022

Sendil Kumar — Mon, 20 Jun 2022 19:37:57 +0000

The State of the WebAssembly 2022 is out 🎉

Languages in the WASM world

Unsurprisingly Rust Language dominates the most used and most wanted to use language. I am also super excited to see Blazor adoption is increasing!

JavaScript surprisingly is the second highly used language. As the report mentions "there is an increasing usecase where they compile the JavaScript engine itself into WASM and execute on it".

BrendanEich

@brendaneich

@ilblackdragon at #consensus2022 announcing Near’s JS SDK based on QuickJS (bellard.org/quickjs/), the tiny JS VM written by the famous superhacker Fabrice Bellard, which runs hosted as a guest VM in the WebAssembly host in the @NEARProtocol blockchain nodes. Big news!

16:54 PM - 10 Jun 2022

Usage

Web Applications is still the number 1 use case for WebAssembly but it is on the decline. I believe it is because, folks started to realise that WebAssembly is not a silver bullet for performance. It supports only some use cases

Super fascinated to see WASM dominating serverless + Cloud world! Docker replacement coming soon...

Runtime & Features

As expected wasmerio wasmtime dominates the runtime. If you haven't tried them, then give them a shot :)

My getting started post on wasmtime.

What next to SIMD? The threads proposal is the top feature requested by the community in the web world. On the server side I/O operations lead the list.

WebAssembly needs proper debugging & building support and enable non-browser APIs in the future. This is interesting as the first two will give enormous Developer Experience while the latter focus on the server side Wasm

If you want to get started on the WASM with Rust - checkout my Dev.to series

Rust and WebAssembly for masses - Introduction

Sendil Kumar ・ Jan 1 '20 ・ 8 min read

#rust #webassembly #webdev #beginners

My views on Ziglang

Sendil Kumar — Sun, 20 Mar 2022 19:21:36 +0000

Originally posted on

Zig is a general-purpose programming language. It is simple and does not have any hidden control flow or allocations.

The language is clear, straight-forward, and readable.

Zig directly competes with C and will be a better alternative for C in the future.

Things that I love about ziglang:

Simple language

Building a simple language is easier said than done. Programmers need rich features in a programming language, but when the programming language supports more features, it becomes sluggish and bloated.

For example, A simple hello-world program in zig will look like this.

// hello.zig
const std = @import("std");

pub fn main() !void {
 const stdout = std.io.getStdOut().writer();
 try stdout.print("Hello!, {s}\n", .{"world"});
}

In the first line, we are importing the std library (curious why we have @ before import check here). We import the std library and assign it to std using the const keyword.

Next, we define the main function. As in other languages, the main specifies the zig compiler where to start the program execution. The function definition commences with the pub fn keyword. As you might have guessed, pub fn means public function.

Note: The pub specifier exports the function.

Then we have the function name main. After the function name and args (we do not have any in this case), we specify the return type. The return type here is !void. The ! specifies that the function might return error. We can expand the !void something like <error-type> or <void>.

Next, we take the writer function from the imported std library.

Note: It is too long!!! But it clearly says what the programmer is trying to do and what the compiler will do.

Finally, we use print from the method from the stdout to print the actual strings out. The print statement is similar to how we will do in other low-level languages like C / Rust.

Note: .{}. in the second argument to the print function. It is an anonymous struct literal. Zig compiler infers the type of anonymous struct literal.

That is it. We can run this zig code using zig run hello.zig.

As you can see, the function is simple and easier to understand. The language neither has macros nor magically print the result.

No magic here!

No Null pointers

Oh yeah! Everyone agrees Null Pointer is a billion-dollar mistake.

Zig does not have null, but they provide optional. Optional type provides safety and better readability.

const optional_world_answer: ?i32 = 42;

The ? specifies the type is optional. It can either accept null or any i32 integer. null is an allowed type in ziglang.

We can safely access the optional using the if-let syntax.

if (optional_world_answer) |world_answer| {
 // here `world_answer` is i32 and not null.
}

Optional makes your language verbose, the benefits of them in safety, readability stands out.

Error handling

Zig is inclusive of errors too. It handles errors as values. The zig compiler ensures errors are handled and complains when they are not.

For example,

fn get_i64() !i64 {
 return error.notImplemented;
}

pub fn main() void {
 // we are basically discarding the result
 _ = get_i64();
}

The above code will throw a compiler error that we are not handling error and the error gets discarded. Always remember errors are values. We can fix it by using catch or try.

// error handling with `catch`
let number = get_i64() catch |err| {
 // do something with error
};

// error handling with `try`
let number = try get_i64();

// well when you are sure that it won't error
let number = try get_i64() catch unreachable

Zig provides refreshing error handling.

Comptime

Zig provides a comptime keyword to specify that a particular value and type are available during the compile-time. You can use comptime in three different places.

parameters
variables
expressions

comptime in parameters

Zig uses the comptime in parameters to duck type and implements generics.

fn generic_fn(comptime T: type, a: T, b: T) {...}

We can call generic_fn like the following:

generic_fn(i32, 10, 11);

The function call-site expects type as a comptime parameter.

comptime in variables

Comptime in variables is another good feature in zig. It guarantees that the compiler will perform all the load and store operations during the compile time itself.

comptime in expressions

Similarly, we can mark an expression as comptime such that it will evaluate at the compile time.

Other features that stand out are:

Easier integration with C and other C-like languages.
Std library code is readable.
Simple grammar for the language.

The things that need to improve in zig are:

Although error handling is refreshing, there is no way to pass a context with errors.
Extreme importance on readability leads you to write low-level code.
The language is in its very early days, and it will be interesting to see how it evolves (with more features).

Overall, Zig has an excellent future. It will be a replacement for C, and I hope it will succeed.

To explore further

Interesting features in Java 17

Sendil Kumar — Sat, 05 Feb 2022 08:40:05 +0000

Originally published in sendilkumarn.com

Few months ago, Java 17 was released. The new LTS version comes with a lot of performance improvements, new features, and API enhancements. Here are my top features in this release.

Sealed Classes or Interfaces
Pattern Matching in switch
Vector API
Foreign Function and Memory API

Sealed Classes or Interfaces

With Java 17, Sealed classes or interfaces are finally out of preview. They allow classes or interfaces to specify which other classes or interfaces can extend or implement them. This feature enables the superclasses to be accessible but restricts extending superclasses.

You can define a sealed class as follows:

public abstract sealed class CollectionAdapter 
    permits ListAdapter, SetAdapter, MapAdapter { ... }

The sealed classes have a sealed modifier followed by the class definition. We have to explicitly define the allowed subclasses for the sealed class. We can do it either by defining the sub classes directly in the same source file (as inner or auxiliary classes) or using permits modifier followed by a list of allowed subclasses. Only these classes can extend the sealed classes.

Note: Sealed and its permitted subclasses should live on the same package or module (who uses a module ;) ).

The subclass can extend the sealed class just like any other class. But the subclass should either be final, sealed, or non-sealed (yeah! hyphenated modifier ;)).

final

The final completely prevents further extension of the sealed class.

public final class ListAdapter extends CollectionAdapter { ... }

sealed

The sealed classes allow its subclasses to extend the sealed superclasses via themselves.

public sealed class SetAdapter extends CollectionAdapter 
    permits SortedSetAdapter, HashSetAdapter { ... }

Now both SortedSetAdapter and HashSetAdapter can (indirectly) extend the CollectionAdapter via SetAdapter.

Note: If SorterSetAdapter and HashSetAdapter directly extend CollectionAdapter then it will error during compilation.

non-sealed

The non-sealed makes unrestricted extension of a superclass possible.

public non-sealed class MapAdapter extends CollectionAdapter { ... }

Record classes & Sealed Interfaces Best Friends Forever

Record classes landed on Java 16. They provide a concise way to represent immutable DTOs in Java. Sealed classes or interfaces work great with records.

public abstract sealed interface Geometry 
    permits Point, Line { ... }

public record Point(int x, int y) implements Geometry { ... }

public record Line(Point x, Point y) implements Geometry { ... }

Note: Record classes do not support declaring a superclass type as they are implicitly final.

Both Record and Sealed classes are algebraic data types (ADT). ADTs are a fancy way of saying composite types (the type formed by combining other types). Record classes are product types. Sealed classes are sum types.

Being sum type, the Sealed classes make it easy for the compiler to understand its various type forms. Our next feature pattern matching rides on this exhaustive type checking.

Pattern Matching in switch

This is a preview feature in Java 17

Pattern matching is a great feature. It is one of the many features I enjoyed while learning Rust. The pattern matching makes the programs concise and readable. It also empowers the compiler to do exhaustive type checks. The pattern matching instanceof was released on Java 16. It reduced the boilerplate code when using instanceof.

Instead of two separate statements to check the type and create a variable with casting, the pattern matching instanceof introduced a syntactic sugar that combines them into one.

// before Java 16
if (snow instanceof Water) {
    Water w = (Water) snow;
    // do whatever with w
}

// from Java 16
if (snow instance of Water w) {
    // do the same thing with w
}

Java 17 extends these features further and introduces pattern matching for switch expressions. Together with exhaustive type check (introduced in Java 14) and pattern matching switch expressions are delightful to work with.

switch (snow) {
    case null -> // well it is a null value
    case  Water w  -> // Do something with Water
    case Fire f -> // Do something with Fire
    default -> // Do something with something
}

Before Java 17, switch cases were not exhaustive. It introduced runtime exceptions. This exhaustive type checking in switch statement removes the runtime exceptions. When the switch cases are not exhaustive the compiler throws an error. The case labels should cover all the possible variations of the type. Also, the case expressions support the null case.

The pattern matching in instanceof and switch provides a building block for allowing destructuring of the classes in the future. Let's jump on to two new cool features that are still in incubation but have potential.

Vector API

This feature is in incubation.

In the Machine Learning ecosystem, Java is not the primary language. The main reason is that the language lacks a few essential constructs. Vector APIs addresses a few problems in the Machine Learning area.

Vector is a primitive data structure. In the initial release, vectors support Byte, Short, Integer, Long types.

// var vectorized = new Vector<E>();
var vectorInt = new Vector<Integer>();
var vectorLong = new Vector<Long>();
var vectorShort = new Vector<Short>>();
var vectorShort = new Vector<Byte>>();

If you are thinking, What is a big deal it is another data structure?

Vector API uses Single Instruction Multiple Data (SIMD). Modern CPU architectures allow you to perform multiple tasks in a single CPU cycle. That is the machine (CPU) allows simultaneous computation of a single instruction. For example, you have 1Million pixels image and you want to increase the contrast for each pixel in that image. In a normal instruction, the CPU has to fetch the pixel from a particular location and increase its RGB (Red Green Blue) value and continue doing that one million times. If the CPU supports SIMD, then the CPU can load a bunch of pixels (say n) and apply the single instruction (in our case increasing RGB values) on them. They do this in parallel for multiple bunches. Thus significantly increasing the performance of the overall operation.

Thus Vector APIs provide an enormous performance boost and thus makes Java easier to use for tensor calculations in the future.

Although most of the modern CPU architectures support SIMD computation, there are still some CPU architectures out there that do not support SIMD. Vector APIs allows graceful degradation for them too.

Foreign Function & Memory API

This feature is in incubation.

Foreign Function and Memory API is another feature on incubation in Java 17. They provide necessary APIs for Java programs to access foreign functions and memory outside of the JVM. Java introduced Java Native Interface(JNI) long back. JNI is complex, slow, and dangerously unsafe to use. The new Foreign Function and Memory API were built from the ground up to provide simple, fast, and safer APIs when going out of the JVM.

Why is it a big deal?

The Java runtime keeps its object in the heap. This heap is called on-heap data and is fast to access. That is the main reason why Java is super fast. But when Java wants to call outside of its runtime for example C/C++ code, it becomes too slow to access the data. This is primarily because the data is outside the JVM's heap (on-heap), this heap is called off-heap data. JVM has to translate the value from off-heap to on-heap and vice versa. This makes accessing the off-heap data slower than accessing on-heap data.

Note: Garbage Collection happens only on the "on-heap" data.

Java provides a couple of ways to call foreign functions or memory, like ByteBuffer, Unsafe API, or JNI. The ByteBuffer API allows accessing "off-heap" data, but they are not built for this use-case and they lack a few key features (like customised byte alignment). The sun.misc.Unsafe API, this exposes "on-heap" memory access. While it addresses the performance but as the name implicates it is "unsafe". JNI allows accessing "off-heap" data, but it provides significantly low performance.

JNI has a ton of performance issues, platform-dependency (because of the foreign language), restrictions on the language to use. The translation of object representation between Java and the foreign language is too costly and uses the "Unsafe" API.

With the new API we can allocate a memory segment using the following code:

// Alloactes 100bytes on the native memory using malloc
var nativeSegment = MemorySegment.allocateNative(100, newImplicitScope());

The Memory Segment is a contiguous region on memory (i.e., they are allocated together). The implicitScope on the above code specifies that the memory can be cleaned up once the nativeSegment goes out of scope. Additionally, the API also provides MemoryLayout to specify how the data is laid out on the memory.

To load the function from C, we can use the CLinker. The CLinker implements the C Application Binary Interface (ABI) and helps us to load the C file and look up the functions defined in the C file.

// The below line loads the `cFunction` method from the C code. 
MethodHandle cFunction = CLinker.getInstance().downcallHandle(
                            CLinker.systemLookup().lookup("cFunction"), ...);
// Create the required memory segment and provide the layout here.
// ...code is elided...
// The below line invokes the Foreign function from the Java code.
cFunction.invoke(
    // address where the memory lives 
    address, 
    // length of the memory 
    usedAddressLength, 
    // ... other args
)

The Foreign Function API makes the invocation of native code as simple as method handles inside Java. Foreign function and Memory API together will open a lot of new scopes in Java.

The Sealed classes and Record classes provide sum and product types for Java. These algebraic data types are great and they provide a cleaner way to pattern match. The pattern matching provides concise, readable code, and exhaustive type checks by the compiler. These three features make the Java language more modern and alleviate a few of the pain points.

I am particularly excited about the Vector APIs and Foreign Function and Memory APIs changes. This lays a foundation for a much bigger and exciting future for Java. Both these features provide a big boost on performance and will introduce Java into the Machine Learning world (Tensors here we come!). They are focused on performance, efficiency, and safety while not giving up on the readability of Java.

If you are looking for a full feature update on Java 17 then check the following links:
Oracle official release announcement / JEPs since Java 11 / Updates from Java 8 to Java 17 / Java 13 features

Special thanks to Billy Korando for the review.

Microservices with Kotlin, Kubernetes, and Linkerd

Sendil Kumar — Sat, 28 Nov 2020 17:17:58 +0000

KHipster is a development platform to generate, develop and deploy Spring Boot + Angular/React/Vue Fullstack Web applications and Spring microservices. KHipster is built on top of JHipster.

In this post, we will do the following:

Generate microservices with KHipster using JHipster Description Language (JDL)
Generate Kubernetes configuration using JDL
Generate code using KHipster
Create a Kubernetes cluster in GCP
Install Linkerd CLI and deploy Linkerd in Kubernetes cluster
Deploy ingress controller in Kubernetes
Deploy applications in Kubernetes cluster
Configure traffic to application

Let us get started.

Generate Microservices with KHipster

Step 1: Install KHipster

KHipster is available as an NPM package. To install it run:

λ npm i -g generator-jhipster-kotlin

Do not have Node installed? Check out nvm (Node Version Manager) that makes it easy to setup Node - here.

Now, verify the installation by running:

λ khipster

Step 2: Create JDL file

The JDL is a JHipster-specific domain language.

JDL provides a DSL to describe the applications, deployments, entities and their relationships. Applications refer to the service as a whole, the application can be a monolith or microservice. The deployments refer to the way to deploy the application it can be kubernetes. The entities straightaway maps to the database table in your application. The relationships refers to the entity relationship one-to-one, one-to-many, etc.,. JDL simplifies the process of creating the microservices applications and entities.

// Gateway application
application {
    config {
        applicationType         gateway
        authenticationType      jwt
        baseName                gateway
        buildTool               gradle
        clientFramework         react
        databaseType            sql
        devDatabaseType         h2Disk
        prodDatabaseType        mysql
        packageName             com.sendilkumarn
        serverPort              8080
        serviceDiscoveryType    no
    }
    entities *
} 

// Microservice application
application {
    config {
        applicationType         microservice
        authenticationType      jwt
        baseName                service
        buildTool               gradle
        databaseType            sql
        devDatabaseType         h2Disk
        prodDatabaseType        mysql
        packageName             com.sendilkumarn
        serverPort              8081
        serviceDiscoveryType    no
    }
    entities product
}

// Product entity 
entity product  {
    name    String  required
    price   Long    required
}

We have defined 2 applications: gateway and service, and an entity: product. The major difference between gateway and service:

gateway uses clientFramework as react, applicationType as gateway
service uses applicationType as microservice

Refer we have used serviceDiscoveryType no, this implies that we are not using serviceDiscovery in the microservices. We will use Linkerd for servicediscovery.

Did you know? JHipster supports sql and noSql database and it has many configuration options for generating the applications. Check the entire list of application configuration options here.

Generate Kubernetes configuration

KHipster provides kubernetes option to generate the Kubernetes configuration file for the JHipster generated applications. Interested to explore more about Kubernetes check out here. The jdl accepts deployment block to define the Kubernetes deployment.

deployment {
  deploymentType         kubernetes
  appsFolders            [gateway, service]
  dockerRepositoryName   "sendilkumarn"
  serviceDiscoveryType   no
  istio                  false
  kubernetesNamespace    khipster
  kubernetesServiceType  Ingress
}

Note: It checks whether you have installed Docker since we need Docker for creating and pushing the images and use them later.

The Kubernetes definition is made inside the deployment block with deploymentType as kubernetes. The appsFolders points to the folders of the generated applications. We define the dockerRepositoryName, this refers to docker user name here. Similar to applications, we define the serviceDiscoveryType as no (since we are going to use Linkerd for service discovery). KHipster provides istio out of the box, since we are going to use Linkerd for that. We define the Kubernetes namespace using kubernetesNamespace property. All the deployments & services use khipster namespace to deploy the application.

Finally, We use Ingress as the KubernetesServiceType configuration. The smallest deployment unit of Kubernetes is a pod. A pod is a group of Docker containers. Refer here for more information about the pods. Each pod gets IP address during its creation. If we have to access the application we have to connect to the pod's IP address (with port if applicable). In the Kubernetes cluster, pods are created and destroyed automatically based on various factors. So when a pod spawns newly, IP address referring them might change.In order to connect to running applications in the pods, we use services. Services define a set of pods and a way to access them. The services is like a loadbalancer or service discoverer that helps to identify the pods with a name to it.

Kubernetes provide three types of service type:

Cluster IP - This exposes service to an cluster internal IP
Nodeport - This exposes the service to an port
Load Balancer - This exposes the service to an external IP

With Kube-DNS, Kubernetes also maps the service to an external name. Refer here for more infomration.

Ingress is not a service type, but with Ingress you can expose the service. The ingress acts as an entry point for your cluster. It is ideal for exposing multiple services under the same IP address.

We need ingress-controller to expose services via ingress IP, we will set up ingress-controller below.

Generate code using KHipster

The khipster import-jdl imports the JDL file and generates the application and the deployment configuration files.

λ khipster import-jdl app.jdl

Gateway application generated successfully.
Service application generated successfully.
Kubernetes configuration generated successfully.

λ ./gradlew bootJar -Pprod jib -Djib.to.image=<docker-username>:<app-name>

Create a Kubernetes cluster in GCP

Install gcloud here.

λ gcloud beta container --project <project-name> clusters create "khipster-cluster" --machine-type "c2-standard-4" --num-nodes "2" --zone "us-central1-c"

We create a cluster named khipster-cluster in the given project. We define the machine-type with c2-standard-4 with 2 nodes in the us-central1-c zone. This will take a while to complete, since it has to create a cluster from the scratch.

Explore more about K8s installation in the GCP here.

Install Linkerd CLI and deploy Linkerd in Kubernetes cluster

Linkerd is a service mesh for Kubernetes. Linkerd makes running services easier and safer by giving you runtime debugging, observability, reliability, and security—all without requiring any changes to your code. - Linkerd website

Install the CLI manually in your system and set up the path, run:

λ curl -sL https://run.linkerd.io/install | sh
Linkerd stable-2.9.0 was successfully installed 🎉

λ export PATH=$PATH:$HOME/.linkerd2/bin

Check the installation by running:

λ linkerd version
Client version: stable-2.9.0
Server version: unavailable

Once the installation is completed. Before installing the Linkerd in the Kubernetes cluster, we wil check whether the Kubernetes cluster is configured correctly. We run:

λ linkerd check --pre
....
Status check results are √

The above command checks whether the kubernetes cluster is configured correctly and ready to install the Linkerd control plane.

Note: The bare Kubernetes configuration might not have the required cluster admin role. To create the clusterrolebinding with cluster-admin role for the selected account.

λ kubectl create clusterrolebinding cluster-admin-binding \
  --clusterrole=cluster-admin \
  --user="$(gcloud config get-value core/account)"

clusterrolebinding.rbac.authorization.k8s.io/cluster-admin-binding created

To install the Linkerd on the Kubernetes cluster, run the following:

λ linkerd install | kubectl apply -f -

The linkerd install command creates the kubernetes configuration files. We pipe the configuration files using kubectl apply -f command on those generated files. This will create the complete linkerd in the kubernetes cluster. Once the installation is complete refer the installation is complete using

λ linkerd check

Deploy ingress controller in Kubernetes

Ingress exposes HTTP and HTTPS routes from outside the cluster to services within the cluster. Traffic routing is controlled by rules defined on the Ingress resource.

Ingress provides an external IP with which we connect to the services running inside the Kubernetes cluster. The Ingress also provides load balancing, SSL / TLS, and others. We will install a vanilla version Nginx ingress controller:

λ kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v0.41.2/deploy/static/provider/cloud/deploy.yaml

Once the ingress-controller is installed in the Kubernetes cluster. Get the IP address by running the following command:

λ kubectl get svc ingress-nginx-controller -n ingress-nginx -o jsonpath='{.status.loadBalancer.ingress[0].ip}'
xxx.xxx.xxx.xxx

Our application will be accessible via the above IP address.

Deploy applications in Kubernetes cluster

To deploy applications in to the Kubernetes cluster, go into the Kubernetes folder and run the following command:

λ ./kubectl-apply.sh apply -f

All the deployments and services will be installed in the K8s cluster. Now we need to auto inject Linkerd into the khipster namespace for all the services in that particular namespace.

Next, let's add Linkerd to khipster namespace by running:

λ kubectl get -n khipster deploy -o yaml \
  | linkerd inject - \
  | kubectl apply -f -

You can also inject proxy automatically. Refer here for more information.

Now the Kubernetes cluster is ready with all the necessary configuration.

Configure traffic to application

Now the final step is to map the ingress service to the services. Note the annotation in the metadata section, the Nginx uses the proxy header to proxy the HTTP traffic. Refer here for more information.

apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  name: web-ingress
  namespace: khipster
  annotations:
    kubernetes.io/ingress.class: "nginx"
    nginx.ingress.kubernetes.io/configuration-snippet: |
      proxy_set_header l5d-dst-override $service_name.$namespace.svc.cluster.local:$service_port;

spec:
  rules:
  - host: <ip-address>.nip.io
    http:
      paths:
      - path: /
        backend:
          serviceName: gateway
          servicePort: 80
      - path: /service
        backend:
          serviceName: service
          servicePort: 8081

.nip.io refer the nip.io at the end. nip.io helps to redirect check here

We have also defined the spec section. The spec section provides the rules for redirection. We provide the host and map the path to the service with their name. Viola! Now the application is ready! Go to <ip-address>.nip.io to check your microservices running.

Linkerd comes with dashboard & grafana to monitor the services, traffic, and everything. You can check them out using linkerd dashboard.

🐦 Twitter // 💻 GitHub // ✍️ Blog

Open Source

Sendil Kumar — Sun, 05 Jul 2020 21:26:30 +0000

Open-source is everywhere. There is an extremely high chance that you used more than one open-source library in your last project.

The power of the open-source is the power of the people. The people rule - Philippe Kahn

The open-source has a lot of benefits, they include:

learning
hands-on experience
exposure (you to the community and vice versa)
collaboration

If you are not contributing to open source, then it is a good time to start. Some links that might help are -> GitHub explore, Good First Issues, Collaborators needed

While projects from big companies are attractive and give you more exposure. There are plenty of ideas/projects out there looking for contributors. Be a part of the next big thing.

Please do consider contributing to the idea that you love.

The open-source community is growing exponentially, as maintainers, we must ensure certain standards.

Appreciate / Recognize / Reward

Maintainers 👏 -> 🤝 -> 💰

Disclaimer: I know we (maintainers) juggle between many roles. But we should understand that we are shaping the community.

Appreciate the contributor. The project might have gazillion stars and thousands of contributors. No matter what appreciate the contributor. They spent their invaluable time to build your dream.

Irrespective of whatever the quality/quantity of the contribution, appreciate.

If it is a first-time contributor then congratulate them, make them feel welcomed.
If the contributor is consistent and looking for ways to contribute more, then Recognize them.

Create a team, and ask them to join the team. GitHub provides granular control for the teams, create a team, and add every contributor to that team.

Reward them if you have the funds. Projects like Webpack / JHipster reward the contributors for their contribution.

If your project is funded, then share it with the community.

Users 👏 -> ✨ -> 💰

Appreciate the project and the maintainers.

The product/software is not created in a single day. The maintainers put in hours and hours of dedicated work to make it work. So always respect and appreciate them.

Even if there are some mistakes, please fix them.

Recognize the project. Give stars 💫 if you like it. Share it on social media.

Reward them if you have funds or time. Fix that long-standing bug or donate a coffee to the maintainer.

Give constructive feedback 💬 💬 💬

Maintainers

The quality of the Pull Request may not be perfect always. Remember the person contributing may be new or have a different understanding.

Give constructive feedback. Instead of pointing the mistake, show them how to correct them.

If you have to close the work (Pull Request), give enough context why did you close it and at the very least wait for the approval before doing so.

Imagine how frustrated you were, when your last manager dismissed all the efforts that you made. Don't be like that.

Naturally, people like to contribute more if they feel welcomed.

Users

Please do respect the decisions made in the project. If you don't like a decision, but the project maintainers insist to go in that way, accept it. The answer is fork and not public shaming.

The same constructive feedback applies to you. If a maintainer makes a mistake, be constructive. At the end of the day, they are people too.

If you are an expert in the field, then encourage best practices and guide them. Not all project maintainers know everything, it is important to remember "open-source is all about the power of the people".

Document 📝

Maintainers

Document anything and everything.

Believe it or not! Documentation saves both your and users' time. Features are mandatory but documentation is an absolute necessity.

When documenting, add the following scenarios:

The basic usage (the default way to use your product)
The tips and tricks (that increases your user's productivity)
The essentials that your users need to know
Add Contribution guidelines

and others.

Think documentation as a feature, not as an overhead.

// Detect dark theme var iframe = document.getElementById('tweet-1276998490246262787-545'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1276998490246262787&theme=dark" }

Users

Understand it is not always possible to document everything. If something is missing, please do contribute.

Create a blog post, add links to the wiki page (if the project has one). Tell it to the maintainers, ask them for a review (if needed).

When using the product, you hit a roadblock, found a solution, document it, and share it with the community.

Always remember, in documentation, every single bit matters.

Do not enforce complex / stringent rules 👾 👾 👾

Maintainers

Often, some projects impose an incredible amount of perfection. Like your commit message should be in this tense, the issue should have the GitHub issue number, and others.

Please do not ever impose them. Have a system that automatically handles this or stop asking for it.

Always remember people are helping you to build your vision, enable them rather than blocking them. Make it easy for them.

Users

Certain projects have stringent rules for many reasons.

They are some good practices to follow.
They make it easier for maintainers, in their process.
They provide a great name for the project.
Always green build increases the confidence in the project.

Please read the contribution guidelines, if you understand and accept everything then contribute.

🐦 Twitter | 💻 GitHub | ✍️ Blog

Share your Open-source experience or idea to make it even better :)

✨Awesome fonts to code 💻

Sendil Kumar — Mon, 22 Jun 2020 15:01:07 +0000

We spend a lot of time interacting with type. They influence our thinking, alter trust, determine context, and play with our productivity.

In these weird times where our screen times skyrocket. We should do something to ease our contextual burden and increase our productivity.

This is a list of awesome fonts that will make your code look even more elegant and concise (and makes your more productive 🤞).

Note: This is a personal favourite list (and almost all of them are mono). Please feel free to comment your favourite.

Fira Code Mono

Any font list is incomplete, without this classic font.

Type: Mono | GitHub

Hasklig

This is forked from Source Code Pro and added some nice ligatures in it.

Type: Mono | GitHub

Source Code Pro

This one from Adobe is awesome. It is clean and crisp.

Type: Mono | GitHub

Anonymous Pro

It is fixed width font designed for coding.

Type: Mono | GitHub

Fantasque

A cool and refreshing font. This font has some handwriting like ligatures.

Type: Mono | GitHub

Jetbrains Mono

This one is from the Jetbrains. They already have cool abstract images in their IDE startups. The font is bit oversized but once again it is awesome.

Type: Mono | GitHub

Monoid

It is sharp, bit taller. But the font looks great even in low resolution displays.

Type: Mono | GitHub

Cascadia Code

Windows was the first machine that I ever had. And I used it for a long time at my work (now don't judge me). So this one was my long time favourite. Recently I saw they have open sourced it and it brings back a lot of memories.

Type: Mono | GitHub

Dank (Paid)

This one is pretty cool. But it is paid. I haven't used it personally, but used this in some of my slides (via carbon.now.sh)

Type: Mono | Buy it here

Special Mentions

Voila, meanwhile you have also learnt quickSort using Haskell 😜

Did you know? >> You can customise your dev.to font here

What is your favourite font?

What is in the font? Check out this book -> Why Fonts Matter - Sarah Hyndman

🐦 Twitter | 💻 GitHub | ✍️ Blog

Speed up JavaScript execution 🚀🚀🚀

Sendil Kumar — Sun, 03 May 2020 17:25:42 +0000

As a developer, we always look for ways to make our code faster and better.

But before that, writing high performance code requires three things:

Know about the language and how it works
Design based on the use case
Debug! Fix! Repeat!

Remember this,

Any fool can write code that a computer can understand. Good programmers write code that humans can understand. - Martin Fowler

Let us see how to make JavaScript code to run even faster.

Be lazy

A lazy algorithm defers computation until it is necessary to execute and then produces a result.

const someFn = () => {
    doSomeOperation();
    return () => { 
      doExpensiveOperation();
    };
}


const t = someArray
             .filter(x => checkSomeCondition(x))
             .map(x => someFn(x)); 

// Now execute the expensive operation only when needed.
t.map(x => t());

TL;DR; The fastest code is the code that is not executed. So try to defer execution as much as possible.

Beware of object chaining

The JavaScript uses prototype inheritance. All the objects in the JavaScript world are instances of the Object.

The MDN says,

When trying to access a property of an object, the property will not only be sought on the object but on the prototype of the object, the prototype of the prototype, and so on until either a property with a matching name is found or the end of the prototype chain is reached.

For every property the JavaScript engine will have to go through the entire object chain until it finds a match. This is so resource intensive and hogs on your application performance if not used correctly.

So don't do this

const name = userResponse.data.user.firstname + userResponse.data.user.lastname;

Instead do this

const user = userResponse.data.user;
const name = user.firstname + user.lastname;

TL;DR; Use temporary variable to hold the chained properties. Rather than repeatedly going through the chain.

Think before using transpilers

In the above case, the userResponse may or may not have the data object. That data object may or may not have the user property.

We can check that while getting the value like this

let name = '';
if (userResponse) {
    const data = userResponse.data;
    if (data && data.user) {
        const user = data.user;
        if (user.firstname) {
             name += user.firstname;
        }
        if (user.lastname) {
             name += user.firstname;
        }
    }
}

Well that is verbose. More the code, more the surface for bugs. Can we shrink it? of course, JavaScript has Optional chaining, destructuring assignment to make things less verbose.

const user = userResponse?.data?.user;
const {firstname = '', lastname = ''} = user;
const name = firstname + lastname;

Isn't it slick? Modern? But beware when using things like this, the Babel transpile them as follows:

"use strict";

var _userResponse, _userResponse$data;

var user = (_userResponse = userResponse) === null || _userResponse === void 0 ? void 0 : (_userResponse$data = _userResponse.data) === null || _userResponse$data === void 0 ? void 0 : _userResponse$data.user;
var _user$firstname = user.firstname,
    firstname = _user$firstname === void 0 ? '' : _user$firstname,
    _user$lastname = user.lastname,
    lastname = _user$lastname === void 0 ? '' : _user$lastname;
var name = firstname + lastname;

TL;DR; When using transpiling, make sure you choose the one that is more optimal for your use case.

Know SMI and heap numbers

Numbers are weird. The ECMAScript standardizes numbers as 64-bit floating-point values, also known as double precision floating-point or Float64 representation.

If the JavaScript engines store numbers in Float64 representation then it will lead to huge performance inefficiency. JavaScript Engines abstract the numbers such that its behavior matches Float64 exactly. The JavaScript engine executes integer operations much faster than compared to the float64 operations.

For more details, check this out.

TL;DR; Use SMI (small integers) wherever possible.

Evaluate Local Variables

Sometimes, folks think that it is readable to supply a value like this,

const maxWidth = '1000';
const minWidth = '100';
const margin = '10';
getWidth = () => ({
    maxWidth: maxWidth - (margin * 2),
    minWidth: minWidth - (margin * 2),
});

What if the getWidth function is called multiple times, the value is getting computed every time when you call it. The above calculation is not a big deal and you wouldn't notice any performance impact because of that.

But in general, lesser the evaluation at the runtime better the performance is.

// maxWidth - (margin * 2)
const maxWidth = '980';
// minWidth - (margin * 2)
const minWidth = '80';
const margin = '10';
getWidth = () => ({
    maxWidth,
    minWidth
});

lesser the evaluation (at runtime) better the performance.

Use Map instead of switch / if-else conditions

Whenever you want to check multiple conditions, use a Map instead of switch / if-else condition. The performance of looking up elements in a map is much more faster than the evaluation of switch and if-else condition.

switch (day) {
    case 'monday' : return 'workday';
    case 'tuesday' : return 'workday';
    case 'wednesday' : return 'workday';
    case 'thursday' : return 'workday';
    case 'friday' : return 'workday';
    case 'saturday' : return 'funday';
    case 'sunday' : return 'funday';
}

// or this

if (day === 'monday' || day === 'tuesday' || day === 'wednesday' || day === 'thursday' || day === 'friday') return 'workday';
else return 'funday';

Instead of both use this,

const m = new Map([
    ['monday','workday'],
    ['tuesday', 'workday'],
    ['wednesday', 'workday'],
    ['thursday', 'workday'],
    ['friday', 'workday'],
    ['saturday', 'funday'],
    ['sunday', 'funday']
];

return m.get(day);

TL; DR; Use Map instead of switch / if-else conditions

if-else ordering

For example if you are writing a React component, it is very common to follow this pattern.

export default function UserList(props) {
    const {users} = props;

    if (users.length) {
        // some resource intensive operation.
        return <UserList />;
    }

    return <EmptyUserList />;
}

Here, we render <EmptyUserList /> when there are no users or render <UserList />. I have seen people argue that we have to handle all the negative scenarios at first and then handle the positive ones. They often come up with an argument, it is clearer for any one who reads it and also it is much more efficient. That is the following code is more efficient than the previous one.

export default function UserList(props) {
    const {users} = props;

    if (!users.length) {
       return <EmptyUserList />;
    }

    // some resource intensive operation
    return <UserList />;
}

But what if the users.length always evaluate true. Use that first and then the negative condition.

TL;DR; While designing if-else condition, order them in such a way that the number of conditions evaluated is lesser.

// Detect dark theme var iframe = document.getElementById('tweet-1252952154966560768-513'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1252952154966560768&theme=dark" }

Types are your best friends

JavaScript is both interpreted and compiled language. The compiler in order to produce more efficient binary requires type information. But being a dynamically typed language makes it difficult for the compilers.

The compilers when compiling the hot code (the code that is executed many times), makes some assumptions and optimise the code. The compiler spends some time to produce this optimised code. When these assumption fails, the compilers has to throw away the optimised code and fallback to the interpreted way to execute. This is time consuming and costly.

TL;DR; Use Monomorphic types always.

Others

Avoid recursion, sure they are awesome and more readable. But they also affect the performance.

Use memoization wherever and whenever possible.

Sometimes bitwise and unary operators give a slight edge in the performance. But they are really useful when your performance budget is very tight.

Discussions 🐦 Twitter // 💻 GitHub // ✍️ Blog

If you like this article, please leave a like or a comment. ❤️

9 ways to level up your browser devtool skills

Sendil Kumar — Thu, 09 Apr 2020 23:56:49 +0000

This is a list of amazing things that browsers can help you with while developing web applications.

1. Colors

Wondering 🤔, What is the hex code for that rgb value? Chrome provides an easy way to get it. Open DevTools and shift + click on the color(swatch) to see their corresponding hex | rgb | hsl value.

2. Animation

Wondering how to tweak the animation? Use the animation editor in the devtools.

You can choose animation timing from a set of pre-defined functions.

You can slow down the animation and play with it to understand/debug how it works.

3. Shadow Editor

Shadows are tricky. Master box/text-shadow using the inline editor.

4. Command tool

Chrome provides Command tool to access files / actions. Use Cmd + Shift + P inside the Dev tools to open the Command tool.

5. Coverage

Check your CSS coverage.

Open Command tool and search for coverage.

6. Rendering

Wondering about the FPS, Layout / Paint in the page.

Open Command tool and search for rendering.

7. Emulate dark mode

Use the emulator to switch between dark and light mode.

8. Sensors

If you are creating an application that requires location based user experience, then you can use the sensors to change the location.

To open sensors, press cmd + shift + p and then type sensors to open the show sensors.

9. Short cut keys :)

Go straight to Address/Search bar using cmd + L.

Navigate through the tabs using ctrl + tab

Navigate tabs with the tab numbers ctrl + num-key.

Go to the last tab using ctrl + 1.
Go to the last tab using ctrl + 9.

Discussions 🐦 Twitter // 💻 GitHub // ✍️ Blog

If you like this article, please leave a like or a comment. ❤️

Forem: Sendil Kumar

Java turns 28

My favourite 28 features in Java as it turns 28

Sendil Kumar ・ May 25 ・ 5 min read

My favourite 28 features in Java as it turns 28

1. Collections

2. Non-Blocking Input Output (NIO)

3. Generics

4. Annotations

5. Varargs...

SafeVarargs & Variable arguments in Java | by sendilkumarn | Medium

sendilkumarn ・ Dec 21, 2018 ・ sendilkumarn.Medium

6. Concurrency

7. Enhanced For-Each Loop

8. Garbage Collection Improvements

9. TimSort

10. Lambda

11. <Optional>

12. Functional Interface

13. JShell

14. Modules

15. Vars

16. Faster Release cycles

17. Flight Recorder

18. Single File Source

19. RIP Applets

20. Switch Expressions

21. GC - Shenandoah

22. Text Blocks

23. Pattern Matching

24. Records

25. Sealed Classes

26. Vector API/SIMD

27. Virtual Threads

28. Community

My Other Posts on Java

Interesting features in Java 17

Sendil Kumar ・ Feb 5 '22 ・ 7 min read

Java enters its teenage 🎉 🎂

Sendil Kumar ・ Sep 22 '19 ・ 4 min read

9 tips to Increase your Java performance ☕️ 🚀 🚶‍♂️

Sendil Kumar ・ Jul 20 '19 ・ 4 min read

My top 5 book recommendations for EMs

Honorary Mentions

Diversity & Inclusion in hiring

Start with a Clear Job Description

Source Candidates from Diverse Channels

Use a Diverse Panel of Interviewers

Periodically Monitor Progress

Identify and Correct Biases

State of the WebAssembly 2022

Languages in the WASM world

Usage

Runtime & Features

Rust and WebAssembly for masses - Introduction

Sendil Kumar ・ Jan 1 '20 ・ 8 min read

My views on Ziglang

Simple language

No Null pointers

Error handling

Comptime

comptime in parameters

comptime in variables

comptime in expressions

To explore further

Interesting features in Java 17

Sealed Classes or Interfaces

final

sealed

non-sealed

Record classes & Sealed Interfaces Best Friends Forever

Pattern Matching in switch

Vector API

Foreign Function & Memory API

Microservices with Kotlin, Kubernetes, and Linkerd

Generate Microservices with KHipster

Step 1: Install KHipster

Step 2: Create JDL file

Generate Kubernetes configuration

Generate code using KHipster

sendilkumarn ・ Dec 21, 2018 ・
sendilkumarn.Medium