Kotlin is a free, open-source, statically typed "pragmatic" programming language that mixes object-oriented and functional programming capabilities. It was first created for the JVM (Java Virtual Machine) and Android. Interoperability, safety, clarity, and tooling support are all important factors.

What is Kotlin?

Kotlin is a great choice for Android development , not only because it provides a way to interoperate with Java, but also because it can do things that Java cannot. For example, you can define properties in Kotlin without defining a getter or setter. This means less boilerplate and more readable code. Additionally, Kotlin has features that make code more concise and readable compared to Java (companion objects, scope functions).

Kotlin is a Better Java

One of the best things about Kotlin is that it's 100% interoperable with Java. What this means is you have complete access to all existing Java frameworks, libraries, and tools and you can simply start using them for your new Kotlin projects. Like, for instance, you can use the Spring Framework in your Kotlin project—and also use your old Java code and call it from Kotlin code. This is possible because all the Java code is converted to the corresponding JVM (Java Virtual Machine) bytecode when built and then runs as usual.

Interoperability with Java

The big famous companies Google and Amazon,  use Kotlin for their android applications. Is there a secret behind all this? Let's find out.

The big famous companies Google and Amazon, use Kotlin for their android applications. Is there a secret behind all this? Let's find out.

7 Unknown Secrets of App Development With Kotlin

It’s easy to write bad, unorganized code, but it’s hard to maintain such code. Good code typically follows some standard for naming conventions, formatting, etc. Such standards are nice because they make things deterministic to those who read your code afterwards, including yourself. Use something like ﻿StyleCop ﻿to practice good habits.

1. Use a Coding Standard

Comments are crucial. You won’t appreciate them until you leave your thousand-line script for a couple of days and return to and try and make sense of it. ﻿Anyone who can read code knows WHAT the code is doing. Explain ﻿WHY ﻿you've done it this way. ﻿

2. Write Useful Comments

Global variables and loops are a mess and can prove problematic when your application grows to millions of lines of code (which most do!). They may influence code elsewhere that is difficult to discern, or cause noisy naming clashes. Think twice before you pollute the global namespace with variables, functions, loops, etc. ﻿ALWAYS USE NAMESPACES.

3. Avoid Global Code

Never use names like <code>$k </code>, <code>$m </code>, and <code>$test </code>for your variables. How do expect to read such code in the future? Good code should be meaningful in terms of variable names, function/method names, and class names. Some good examples of meaningful names are: <code>$request </code>, <code>$dbResult </code>, and <code>$tempFile </code>(depending on your coding style guidelines these may use underscores, camelCase, or PascalCase).

4. Use Meaningful Names

Managing changes and revisions should be easy but effective, so pick whatever version control software that will work best with the workflow of your development team. I prefer using a distributed version control tool like Git or Mercurial; both are free software/open source and very powerful.

5. Use Version Control Software

Try to use tools like Ant or Phing to get your source prepared, compressed, and deployed. Building your whole application with a single command is a marvelous way to prevent errors and omissions that are inherent when performing repetitive tasks.

6. Use Automated Build Tools

For large applications spanning several classes and namespaces, you should have automatically generated API documentation. This is very useful and keeps the development team aware of “what’s what.” And if you work on several projects at the same time, you will find such documentation a blessing since you may forget about structures switching back and forth between projects.

7. Use Code Documenters

It's easy to overlook writing tests for a simple application, but as they grow in size it becomes increasingly important to be sure a change in one location after a time doesn't break something. Having tests makes sure the specific process you're testing always stays functional as intended.

8. Write tests

Writing code can sometimes be the most difficult part of any software development process. In this article,we'll discuss 10 tips for better coding.

10 Tips for Better Coding

<a href="https://reactjs.org/">React </a>is a declarative component based UI library developed with the learn once write anywhere philosophy in mind. This definition suits react quite perfectly. Straight to the point, only a few terms to understand, terms that are easy to grasp, abstracting all the nitty gritty stuff away. So let's go on a ride to demystify what those terms mean and what React does in the background for us

React is a what?

When you learn to code, you are though procedural programing, which is a form of imperative programing. You are thought to tell the computer step by step what to do.This works fine for a independent, pure function which doesn't care about anything else outside it's scope. But when doing UI... that turns into a nightmare really fast. Which of this variables has the current button state? Where does this value change come from? Should I re-render the UI in this function? Whoops, forgot to reset that variable.This is what declarative programing solve

Bolognese with a touch of Imperative please

When coding in a declarative style, you only need to define how you want your data to look and the computer will do it for you.React gives us JSX and hooks for that. JSX brings HTML into JS. You just tell React how your UI should look, and he takes care of every document.createElement , document.querySelector(...)[...] = ... and all that fun stuff for you.Ever wondered why a component can only return one element? Because that element will become the root of your component that React will diff check to see if the UI change and he should appendChild something or setAttribute other.

Declarative code and JSX

How do hooks know to return the correct state?Unlike class components, functions don't hold state (let's not talk about ... this 😨) . But React has to save your state or the previous values of your useEffect deps somewhere. We can cheat a bit by creating a <a href="https://www.netlify.com/blog/2019/03/11/deep-dive-how-do-react-hooks-really-work/">closure </a>around your component that holds these. Now how we retrieve those values? Here come those rules of hooks. That closure holds a hook <a href="https://dev.to/rembrandtreyes/wait-how-does-react-usestate-work-44np">call counter</a>. You call a hook, it gets id'd by the current counter value, the counter goes up. So if hooks don't get called in the same order each time, that id system breaks.

React hooks

A component is an indivisible, reusable parts of your code. We use them to better organize our ui, implement separation of concerns and avoid code duplication. But React also likes when we use them smart.When something changes in your app and a re-rerender is triggered, that update doesn't end up straight in the DOM. Updating the DOM many times sequentially would be too slow.React keeps a copy of the DOM in memory. That is fast to update. Also, when a component changes, React will update only the sub-tree of that component. When the update flood is done, boom, only one update to the real DOM.

Components and the virtual DOM

I just said that React doesn't immediately commit updates to the DOM because they are slow. Sometimes though, even in memory updates can be slow.  Traditionally, rendering is blocking. Once a render starts, it can't be stopped. This can delay a DOM update by too much making the experience choppyLet's take as an example a search box that shows results while you type. After you press a key, at some point, React will have to start to render the updated results list. In that time, it can't also work on updating the text input. Thus, the typing feels choppy

Blocking rendering

React 18 will support some new awesome features that will help us overcome these issues.<ol><li>Suspense</li><li>Transitions</li><li>Streaming HTML and Selective Hydration</li></ol>

Concurrent mode to the rescue

If your component needs async data, you will either have to<ul><li>Implement some really rigid logic for each and every component</li><li>Show incomplete UI</li><li>Re-render all your UI when the data is ready</li></ul>This is where <a href="https://reactjs.org/docs/concurrent-mode-suspense.html">Suspense </a>comes in. Wrapping a component in Suspense will tell React that it will have to Suspend the rendering at some point to wait for some data. But it will try to render as much of the UI as possible. As data comes, it will render more of the UI. And in the end, you will get your DOM painted faster since most of the work was done while waiting for the network.

Suspense

Here is another one. You press a button that takes you to another screen. You start fetching the data for that screen. In the meantime, a white screen or maybe a spinner. But why. Why did the developer made you see that other screen if it wasn't ready to be shown. Well... because they couldn't tell React that.With the <a href="https://reactjs.org/docs/concurrent-mode-patterns.html#wrapping-setstate-in-a-transition">transition API</a> they will be able to do just that. This allows us to tell React to wait for a suspending compoent to be done rendering (with a timeout) until it commits a state update, thus delaying any undesirable loading states.

Transitions

React 18 brings huge improvements to server side rendering. Now when performing SSR we have to <ol><li>Wait for all the data to be fetched</li><li>Wait for the server to render the whole page</li><li>Display the rendered page</li><li>Wait for the whole page to be hydrated</li></ol>Too much stuff to do at once and wait for. We could do one <a href="https://github.com/reactwg/react-18/discussions/37">better</a>. We could partially render the page on the server when data starts coming in and start streaming the page to the client. This way, the client can start hydrating parts of the page and show parts of the UI to the user while the server finishes the heavy work in the background.

Streaming HTML and Selective Hydration

This explains what React is, how it works behind the scenes and its new features. Researching for this really helped me get a clearer picture of the matter in my head

What is React and how Concurrent mode is changing it

<ul><li class="ql-align-justify">New rust compiler</li><li class="ql-align-justify">Middleware (beta)</li><li class="ql-align-justify">React 18 Support</li><li class="ql-align-justify"> AVIF Support</li><li class="ql-align-justify">Bot-aware ISR Fallback</li><li class="ql-align-justify">Native ES Modules Support</li><li class="ql-align-justify">URL Imports (alpha)</li><li class="ql-align-justify">React Server Components(Alpha)</li></ul>You can update the library on your local project with npm i next@latest

Summary

The new Rust Compiler takes advantage of native implementation and improved on speeds, making the refresh 3x faster and the builds 5x faster. It is optimised for large projects, with improvements on performance and webpack. Also, the builds are 17x faster than using Babel and the minification is 7x faster than using Terser.

Faster builds and Fast Refresh with Rust Compiler

Middleware gives you the possibility to run code before a request is complete and based on the incoming request, you can rewrite, redirect, add headers or even stream HTML. It can be used for anything that shares logic for a set of pages, including:<ul><li class="ql-align-justify"> </li></ul><a class="idea-content-link" href="https://github.com/vercel/examples/tree/main/edge-functions">Authentication</a><ul><li class="ql-align-justify"> </li></ul><a class="idea-content-link" href="https://github.com/vercel/examples/tree/main/edge-functions">Bot protection</a><ul><li class="ql-align-justify"> </li></ul><a class="idea-content-link" href="https://github.com/vercel/examples/tree/main/edge-functions">Redirects and rewrites</a><ul><li class="ql-align-justify"> </li></ul><a class="idea-content-link" href="https://github.com/vercel/examples/tree/main/edge-functions">Handling unsupported browsers</a><ul><li class="ql-align-justify"> </li></ul><a class="idea-content-link" href="https://github.com/vercel/examples/tree/main/edge-functions">Feature flags and A/B tests</a><ul><li class="ql-align-justify"> </li></ul><a class="idea-content-link" href="https://github.com/vercel/examples/tree/main/edge-functions">Server-side analytics</a><ul><li class="ql-align-justify"> </li></ul><a class="idea-content-link" href="https://github.com/vercel/examples/tree/main/edge-functions">Advanced i18n routing requirements</a><ul><li class="ql-align-justify"> </li></ul><a class="idea-content-link" href="https://github.com/vercel/examples/tree/main/edge-functions">Logging</a><ul><li class="ql-align-justify">And more!</li></ul>

Middleware

The new update comes with support for React 18, which is starting to become stable. Some new interesting features from React 18 would be Suspense, APIs like startTransition and a new streaming API for server rendering with support for React.lazy

React 18 on the horizon

React Server Components allow us to render everything on the server, including the component themselves. This is completely different from SSR which you pre-generate HTML on the server. With these components, there won't be any client-side JS needed => faster rendering.  To make this kind of components, all you have to do is to name the file Filename.server.js.

React Server Components

This new Next.js version includes experimental support for importing ES Modules through URLs, no install or separate build. You just need to declare the list of allowed URLs inside the next.config.js inside the experimental field, at urlImports. Any CDN that serves ES modules will work, including tools like Framer: Skypack, esm.sh, jsDelivr, JSPM, unpkg.

URL Imports

In Next.js 12, web crawlers (e.g. search bots) will automatically server-render ISR pages using <code>fallback: true</code>, while still serving the previous behavior of the fallback state to non-crawler User-Agents. This prevents crawlers from indexing loading states.

Bot-Aware ISR Fallback

The built-in Image Optimization API now supports AVIF images, enabling 20% smaller images compared to WebP.AVIF images can take longer to optimize compared to WebP, so this feature is opt-in using the new <code>images.formats</code> property in <code>next.config.js,</code>as shown in the picture above.

Smaller images using AVIF

<ul><li class="ql-align-justify">After webpack 5 was the default in Next.js 11, officially the webpack 4 was removed. </li><li class="ql-align-justify"><code>target</code> in <code>next.config.js</code> is no longer needed.</li><li class="ql-align-justify"><code>next/image</code> now uses a <code>span</code> as the wrapping element instead of a <code>div</code>.</li><li>The minimum Node.js version has been bumped from <code>12.0.0</code> to <code>12.22.0</code>, which is the first version of Node.js with native ES modules support.</li></ul>

Breaking changes

Next.js 12 introduces a brand-new Rust compiler, Middleware (beta), React 18 Support, Native ESM Support, URL Imports, React Server Components (alpha), and more!

Next.js 12

<ul><li>There are two realms: JS and Native which are not really aware of each other and do not share the same memory</li><li>The communication is async through the bridge between the two realms</li><li>It is slow to transfer large chunks of data. Since the memory is not shared, all the data passed between js and native is a new copy</li><li>No way to update the UI in a sync way. </li><li>The library repo is HUGE. It makes the library heavier and also making it slower to contribute code from outside or release new fixes</li></ul>

Some of the main disadvantages of the current structure

Don’t get them wrong, Facebook is using React Native by themselves for the Marketplace app, Ads app and more which servers millions of daily users. In addition, some well-known companies like Wix, Bloomberg, Tesla, Zynga and much more using RN in production with the current architecture. But all of the above companies and especially Facebook got to a point where they understood that if they want to make a better native experience and better developer experience they have to do a huge move and change and this is exactly what they are in a process of doing (part of it is already completed)

The current Arhitecture

Now, let’s explain about all the new words you see here: JSI, Fabric, Turbo ModulesJSI is gonna replace the BridgeJSI (Will replace the Bridge) — Its purpose is to make the JS and Native are aware of each other. There won’t be any need to serialize JSON through the bridge and even more than that — there won’t be a bridge! It will allow to expose native object as js objects and vice-versa. It will also expose an API for synchronous calling on this object on both sides. Actually, all the rest of the architecture will be built on top of that (Fabric, Turbo Modules which will be explained next).

The New Arhitecture

Fabric — the new name for the UIManager which will be responsible for the native side. The biggest difference now that instead of communicating the JS side by the bridge, it will expose its native function using the JSI so the JS side and vice-versa can communication directly those ref functions. Better and efficient performance and passing data between sides.

Fabric

Remember the native modules from the last post? Text, Image, View. So their new name is Turbo Modules. They have the same purpose but implemented and acting differently. First, they are lazy-loaded (only when the app needs them) comparing to loading all of them on the launch time. In addition, they are also exposed using the JSI so JS holds a ref to use them on the React Native JS lib side. Result => better performance especially on launch time.

Turbo Modules

CodeGen — Suppose to make the JS side a Single Source Of Truth. Can let you create static types of the js so the native side (Fabric and Turbo Modules) will be aware to them and avoid validating the data each time => better performance and less place for mistakes when passing data.Lean Core — A change in React native repository structure. The purpose is to make the lib lighter and help the community resolve more pull requests faster than before. Facebook splits some of its parts to an external repo. It is already a process in progress that you can follow in their Github here.

CodeGen & Lean Core

We now go over the flow from the previous post and will show the differences. There isn’t a bridge anymore<ol><li>User clicks on the app icon</li><li>Fabric loads the native side (no native modules)</li><li>It tells the JS thread that it is ready and now the JS side loads all the main.bundle.js which contains all js and react logic + components</li><li>JS called through the ref native function (the one that was exposed as an object using the JSI API) to Fabric and the shadow node creates the tree as before</li><li>Yoga does the layout calculation converting from flexbox-based style to host layout</li><li>Fabric does its thing and shows the UI </li></ol>

The new flow

We discussed the current structure until now and it is time to talk about the stuff that was not the perfect choice, looking backward as React team leader on Facebook at this time mentioned in her…

7 Unknown Secrets of App Development With Kotlin

10 Tips for Better Coding

What is React and how Concurrent mode is changing it

Next.js 12

React Native — A Bridge To Fabric

It's time to

READ

LIKE

A PRO!