Why this exists

I wrote about building reusable Skills for Claude a few weeks ago. The same idea applies cleanly to React Native, maybe even more so. The ecosystem moves fast: the New Architecture is the default, Expo ships a new SDK every few months, and the “right” way to do navigation, state, or styling shifts often enough that stale answers are the norm. Packaging the current good practices as Skills means Claude loads the relevant slice on demand instead of guessing from training data.

What’s inside

Six skill groups, each focused on one part of the stack:

• React Native Core — native primitives, platform APIs, animations, gestures, accessibility.
• React Native Ecosystem — navigation, state management, data fetching, and the libraries you actually ship.
• React Native Expo — Router, EAS Build/Update/Submit, SDK upgrades.
• React Native Reusables — shadcn/ui-style components built on NativeWind v4.
• React Native Performance — profiling, measurement, and the optimizations that move the needle.
• React Native Testing — Testing Library v13/v14 patterns for unit and integration tests.

Tech the skills cover

• React Native 0.76+ with the New Architecture on by default
• Expo SDK 53 to 56
• React Navigation v7
• TanStack Query v5 for server state
• Zustand, Jotai, and Redux Toolkit for client state
• Reanimated v3 and Gesture Handler v2
• NativeWind v4 for styling
• Testing Library v13 and v14

How to use it

Drop the skills into your local Claude skills folder:

git clone https://github.com/maikotrindade/awesome-react-native-skills.git ~/.claude/skills/awesome-react-native-skills

From there, Claude’s progressive disclosure does the rest. The frontmatter of each skill stays in the system prompt, and the body loads only when your question matches. You don’t have to remember which skill to invoke.

Where it goes next

The repo is a starting point, not a finished thing. More skills are coming, and contributions are welcome if you’ve worked out a pattern that should be there. Check the project on GitHub and open an issue or PR if something’s missing or out of date.

Declarative UI: Composables vs. Components

In Jetpack Compose, you build UI by writing @Composable functions that describe what the screen should look like for a given state. React Native uses function components that do exactly the same thing. The rendering philosophy — describe, don’t impeach — is identical.

Jetpack Compose

@Composable
fun Greeting(name: String) {
    Text(text = "Hello, $name!")
}

React Native

function Greeting({ name }) {
  return <Text>Hello, {name}!</Text>;
}

Both frameworks re-run the function when inputs change and diff the result to update the UI. Compose calls this recomposition; React Native calls it re-rendering.

State Management

This is where the parallel is most striking. Compose’s remember { mutableStateOf(...) } maps almost one-to-one to React Native’s useState(). Both keep local state tied to the lifetime of the component and trigger a UI update on every change.

Jetpack Compose

@Composable
fun Counter() {
    var count by remember { mutableStateOf(0) }
    Button(onClick = { count++ }) {
        Text("Tapped $count times")
    }
}

React Native

function Counter() {
  const [count, setCount] = useState(0);
  return (
    <TouchableOpacity onPress={() => setCount(count + 1)}>
      <Text>Tapped {count} times</Text>
    </TouchableOpacity>
  );
}

The concept of state hoisting — lifting state up to the nearest common ancestor and passing it down as props — is equally central to both. Compose documentation uses the term explicitly; the React ecosystem calls it “lifting state up” and the outcome is the same pattern.

Props and Parameters

Composable function parameters are props. Both systems use the same mechanism: data flows down from parent to child, and only the parent owns the state.

Jetpack Compose

@Composable
fun UserCard(username: String, avatarUrl: String, onClick: () -> Unit) {
    // ...
}

React Native

function UserCard({ username, avatarUrl, onClick }) {
  // ...
}

Kotlin’s named arguments and default values map to React Native’s destructuring with default prop values. The ergonomics differ but the concept is the same.

Side Effects and Lifecycle

Traditional Android had a full Activity/Fragment lifecycle — onCreate, onResume, onPause, onDestroy. Compose collapsed this into LaunchedEffect and DisposableEffect. React Native takes the same simplified view via useEffect.

Jetpack Compose

// Runs on enter, cancels coroutine on leave
LaunchedEffect(userId) {
    viewModel.loadUser(userId)
}

// Runs on enter, cleanup block runs on leave
DisposableEffect(Unit) {
    val listener = registerEventListener()
    onDispose { listener.unregister() }
}

React Native

// Runs on mount and when userId changes
useEffect(() => {
  loadUser(userId);
}, [userId]);

// Cleanup runs on unmount
useEffect(() => {
  const subscription = subscribeToEvents();
  return () => subscription.remove();
}, []);

The returned cleanup function in useEffect corresponds directly to onDispose in DisposableEffect. Even the dependency array in useEffect has a Compose analogue — the key you pass to LaunchedEffect.

Navigation

If you’ve internalized Android’s back stack, React Navigation will feel natural. Pushing a screen is conceptually the same as starting an Activity with an Intent, just expressed in JavaScript.

Android (Intent with extras)

val intent = Intent(this, DetailActivity::class.java)
intent.putExtra("itemId", item.id)
startActivity(intent)

React Native (React Navigation)

navigation.navigate('Detail', { itemId: item.id });

Both maintain a stack, both support passing parameters to the destination, and both expose a back-navigation mechanism. The underlying implementation differs (system Intents vs. a JS stack), but the mental model transfers directly.

Key Differences to Keep in Mind

The similarities above are real, but a few structural differences matter:

• Language: Kotlin is statically typed with null safety built in. React Native typically uses JavaScript or TypeScript — TypeScript closes most of the gap.
• Rendering: Compose draws UI onto a canvas managed by the Android runtime. React Native (since the New Architecture, default in v0.76) uses JSI to bridge JavaScript to actual platform widgets — UIView on iOS, Android Views on Android. The output looks native because it is native.
• Tooling: Gradle, Android Studio, and adb are replaced by npm/yarn, Metro bundler, and the React Native CLI or Expo. The ecosystem is different even if the patterns are familiar.

The Takeaway

The shift from Jetpack Compose to React Native is not a paradigm shift — it is a syntax shift with a different language underneath. Composables, state, props, effects, and the navigation stack all have direct counterparts. If you already think declaratively about UI, you’re most of the way there.

What Is a Claude Skill?

A skill is a folder containing a single required file — SKILL.md — plus optional supporting directories:

• scripts/ — executable Python or Bash code that runs without consuming context
• references/ — additional documentation loaded only as needed
• assets/ — templates, fonts, or icons used in outputs

Skills are portable: the same skill works identically across Claude.ai, Claude Code, and the API without modification. They’re also composable — Claude can load multiple skills at once, each contributing specialized expertise without interfering with the others.

The Three-Level Progressive Disclosure Architecture

Skills use a three-level loading system designed to minimize token usage while preserving deep expertise:

• Level 1 — YAML frontmatter: Always loaded into Claude’s system prompt. Contains just enough information for Claude to decide when the skill is relevant — without pulling the full content into context.
• Level 2 — SKILL.md body: Loaded when Claude determines the skill is applicable. Contains the full workflow instructions, examples, and error handling.
• Level 3 — Linked files: Additional documents inside the skill folder that Claude navigates and reads only as needed — API guides, reference docs, or detailed examples.

This progressive approach means a skill library of dozens of entries adds minimal overhead until the right skill is needed.

Writing the SKILL.md Frontmatter

The YAML frontmatter is the most critical part of any skill — it determines whether Claude loads it at the right moment.

---
name: sprint-planner
description: Manages sprint planning workflows including task creation, velocity analysis, and capacity planning. Use when user mentions "sprint", "plan tasks", "create tickets", or "sprint planning".
---

Key rules:

• name must be kebab-case, no spaces, no capitals, matches the folder name
• description must include both what the skill does and when to trigger it — include specific phrases users would actually say
• Keep description under 1024 characters; no XML angle brackets (security restriction)
• Optional fields: allowed-tools (restrict tool access), license, and metadata for author, version, and MCP server info

A vague description like "Helps with projects" will never trigger reliably. A good description names file types, trigger phrases, and the concrete outcome the skill produces.

Three Categories of Skills

Anthropic’s guide identifies three common patterns in the wild:

Document & Asset Creation — Skills that produce consistent, high-quality output: frontend designs from specs, reports following team style guides, presentations from outlines. These rely only on Claude’s built-in capabilities with no external tools needed.

Workflow Automation — Multi-step processes that benefit from consistent methodology. A sprint planning skill, for example, can fetch project status via MCP, analyze team velocity, suggest prioritization, and create tasks — all as a single guided workflow with validation gates between steps.

MCP Enhancement — If you have a working MCP server, skills add the knowledge layer on top. Without a skill, users connect your MCP but don’t know what to do next and prompt inconsistently. With a skill, best practices are embedded: pre-built workflows activate automatically, reducing support burden and improving result consistency.

Testing, Iteration, and Distribution

Effective skills testing covers three areas:

• Triggering tests — Run 10–20 queries that should activate the skill and verify it loads without explicit invocation. Target: 90% auto-trigger rate.
• Functional tests — Verify correct outputs, successful API calls, and consistent structure across repeated runs.
• Performance comparison — Compare the same task with and without the skill enabled; measure tool calls, token consumption, and user corrections required.

The fastest path to a first skill is the skill-creator skill — available in Claude.ai via the plugin directory or for Claude Code. Describe your top 2–3 workflows, and skill-creator generates a properly formatted SKILL.md with frontmatter, trigger phrases, and suggested structure. Expect 15–30 minutes to build and test your first working skill.

For distribution: host the folder on GitHub, upload it to Claude.ai via Settings > Capabilities > Skills, or deploy organization-wide through enterprise managed settings (available since December 2025). For programmatic use, the /v1/skills API endpoint enables skills in production pipelines and agent systems via the container.skills parameter on the Messages API.

Skills are published as an open standard — portable across tools and platforms by design. Explore Anthropic’s public skills repository for production-ready examples across document creation, workflow automation, and partner integrations from Asana, Figma, Sentry, Zapier, and more. The complete guide and the introductory course are the best starting points to go deeper.

What if you could see exactly what stocks members of Congress are buying and selling—before the market fully reacts? What if artificial intelligence could analyze these public transactions in real-time and identify patterns that might inform your investment strategy?

Welcome to Capitol Trades Tracker, a groundbreaking mobile application that combines the power of agentic AI, multiple large language models (LLMs), and public government data to democratize access to political trading intelligence.

In an era where information asymmetry creates unfair advantages, Capitol Trades Tracker levels the playing field by making publicly disclosed congressional stock transactions not just visible, but understandable through cutting-edge AI analysis.

The Problem: Public Data, Hidden Insights

Federal law requires U.S. congressional members to disclose their stock transactions. This data is public, yet it remains largely inaccessible to everyday investors. The information exists in scattered government databases, difficult to parse, and nearly impossible to analyze at scale without sophisticated tools.

Meanwhile, institutional investors and hedge funds employ teams of analysts to monitor this exact data, looking for patterns that might indicate market-moving information. This creates a significant advantage for those with resources—until now.

The Solution: AI Agents Meet Public Transparency

Capitol Trades Tracker bridges this gap by combining three powerful elements:

1. Comprehensive Data Aggregation

Every publicly disclosed stock transaction made by congressional members is automatically collected, normalized, and made accessible through an intuitive mobile interface. Users can see:

• Who traded (politician, office, district)
• What they traded (stock symbols, asset types)
• Transaction details (buy/sell, amount ranges, dates)
• Disclosure timing (transaction date vs. public filing date)

2. Koog-Powered AI Agents

At the heart of Capitol Trades Tracker is an intelligent AI agent built with Koog, a cutting-edge framework for developing autonomous AI agents. This isn’t just simple data retrieval—it’s sophisticated, multi-layered analysis that:

• Continuously monitors official government disclosure databases in real-time
• Processes and analyzes trading patterns using advanced algorithms
• Generates actionable insights in human-readable format
• Adapts and learns from market outcomes and political contexts

How the AI Technology Works

The Agentic Architecture

Unlike traditional applications that simply display data, Capitol Trades Tracker employs agentic AI—autonomous intelligent systems that can:

1. Perceive: Monitor multiple data sources continuously, including official disclosure records, market data, and news feeds
2. Reason: Apply complex analytical frameworks to identify unusual patterns, timing anomalies, and potential insider signals
3. Act: Generate daily insights, flag significant trades, and deliver personalized notifications
4. Learn: Improve analysis quality over time based on market outcomes

Daily Intelligence Generation

Every day, the AI agent generates fresh insights by:

1. Scanning all new congressional trading disclosures
2. Analyzing patterns in transaction timing, volume, and assets
3. Correlating trades with pending legislation, industry trends, and market conditions
4. Assessing whether trades might indicate advance knowledge
5. Synthesizing findings into actionable investment intelligence

Each insight is delivered in clear markdown format with:

• Executive summary of key findings
• Detailed analysis of significant trades
• Potential investment implications
• Risk considerations
• Supporting context and reasoning

Key Features: Intelligence at Your Fingertips

📊 Trading Feed

Comprehensive, continuously updated feed of congressional stock transactions with visual indicators (green for purchases, red for sales), detailed trade information, and powerful filtering capabilities.

🤖 AI-Powered Insights Library

Complete archive of daily AI-generated analysis, showing:

• Which LLM model performed each analysis
• Date and context of the insight
• Detailed reasoning and recommendations
• Historical performance tracking

🏠 Intelligent Dashboard

Personalized home screen featuring:

• Latest AI insight with key takeaways
• Most recent congressional transaction
• Relevant news and market updates
• Quick access to all features

👤 Secure Profile Management

Google account integration for secure authentication, preference management, and personalized notifications.

📱 Mobile-First Design

Beautiful, responsive Android app built with modern Material Design, ensuring intuitive navigation and smooth performance.

Who Benefits: Democratizing Investment Intelligence

📈 Individual Investors

Gain the same insights that institutional investors pay millions for. Make informed decisions based on what politicians are actually doing with their money.

🎓 Researchers & Academics

Access comprehensive historical data and AI analysis to study political trading patterns, market behavior, and governmental transparency.

💼 Financial Advisors

Stay ahead of market-moving political activities to better serve clients with timely, data-driven advice.

🔍 Transparency Advocates

Monitor political accountability and potential conflicts of interest through accessible, AI-enhanced public data.

Real-World Impact: The Power of Transparency + AI

Capitol Trades Tracker represents a fundamental shift in how public data can serve public good:

Leveling the Playing Field: What was once exclusive intelligence for well-resourced institutions is now available to anyone with a smartphone.

Promoting Accountability: By making political trading patterns visible and understandable, we encourage greater scrutiny and responsibility.

Enabling Better Decisions: AI-powered analysis transforms raw data into actionable intelligence, helping users understand not just what happened, but why it matters.

Advancing Transparency: Making public data truly accessible furthers democratic ideals and informed citizenship.

The Future: Expanding AI-Powered Transparency

This is just the beginning. Future enhancements include:

• Predictive analytics using advanced machine learning
• Portfolio tracking to compare your holdings against congressional trades
• Custom alerts for specific politicians or sectors
• Expanded coverage to state-level officials
• Community insights where users can share analysis
• API access for developers and researchers

Conclusion: AI for Good, Intelligence for All

Capitol Trades Tracker demonstrates how cutting-edge AI technology can serve the public interest. By combining Koog’s agentic AI framework with multiple large language models and publicly available data, we’ve created a tool that:

• Makes government more transparent
• Empowers individual investors
• Advances democratic accountability
• Leverages AI for social good

This isn’t about creating unfair advantages—it’s about eliminating them. It’s about using the most advanced AI technology to ensure that public information serves the public, not just those with resources to analyze it.

The data is public. The AI is powerful. The insights are yours.

Modern mobile UIs increasingly rely on rich visual effects: gradients, blurs, distortions, ripple animations, and real-time visual feedback. On Android, AGSL (Android Graphics Shading Language) enables developers to create these effects efficiently by running custom GPU shaders directly within the Android rendering pipeline.

This article provides a quick, practical introduction to AGSL, explains where and how it is used, and compares it with similar technologies on iOS and other platforms, helping Android developers understand when AGSL is the right tool.

What is AGSL?

AGSL (Android Graphics Shading Language) is Android’s domain-specific shading language used to write fragment shaders that run on the GPU.

Key points:

• Based on SkSL (Skia Shading Language)
• Designed to be safe, portable, and optimized for Android
• Integrated with Skia, Android’s 2D graphics engine
• Primarily used for pixel-level visual effects

AGSL shaders operate on pixels, not geometry. This makes them ideal for:

• Color transformations
• Distortions
• Gradients
• Blur and glow effects
• Procedural textures

Why AGSL Exists

Historically, Android developers relied on:

• XML drawables
• Canvas drawing
• RenderScript (now deprecated)
• OpenGL ES (powerful but complex)

AGSL fills an important gap:

• ✅ Easier than OpenGL / Vulkan
• ✅ More powerful than XML or Canvas
• ✅ GPU-accelerated
• ✅ First-class support in modern Android APIs

It is especially relevant in the Jetpack Compose era, where expressive UI and animations are core expectations.

Shaders example from https://shaders.skia.org/

A Simple AGSL Example

Here’s a minimal AGSL fragment shader that creates a time-based color animation:

uniform float2 resolution;
uniform float time;

half4 main(float2 fragCoord) {
    float2 uv = fragCoord / resolution;
    float color = 0.5 + 0.5 * sin(time + uv.x * 10.0);
    return half4(color, uv.y, 1.0, 1.0);
}

This shader

• Uses uniforms (resolution, time)
• Computes colors per pixel
• Runs entirely on the GPU
• Using AGSL in Android

AGSL with Jetpack Compose

AGSL is most commonly used today via RuntimeShader in Jetpack Compose:

val shader = RuntimeShader(agslCode)

ShaderBrush(shader)

You can then:

• Pass uniforms (time, size, colors)
• Animate shaders using Compose animations
• Apply shaders to backgrounds, images, or custom layouts

This integration makes AGSL extremely powerful for modern UI effects.

Performance Characteristics

AGSL shaders:

• Run on the GPU
• Are compiled and optimized by Skia
• Avoid CPU-bound rendering

However, AGSL offers excellent performance-to-complexity balance:

• Complex shaders can still impact frame time
• Overuse can increase GPU load
• Always test on low-end devices

Comparison with Other Platforms

On iOS, the closest equivalent is Metal Shading Language (MSL). AGSL is UI-centric and constrained, while Metal is a general-purpose GPU API. Flutter also supports custom shaders via SkSL-compatible fragment programs.

When Should You Use AGSL?

Use AGSL when you need:

✨ Custom visual effects

🎨 Dynamic gradients or distortions

🌊 Shader-based animations

⚡ GPU-accelerated UI rendering

Avoid AGSL when:

• A standard Compose modifier already exists
• The effect is static and simple
• Maintainability is more important than visual fidelity

Limitations of AGSL

• Fragment shaders only (no vertex shaders)
• Limited API surface (by design)
• Debugging can be harder than CPU code
• Not suitable for complex 3D rendering

AGSL is not a replacement for OpenGL, Vulkan, or Metal.

This piece will examine what AI agents are, how they function, what distinguishes them from traditional AI processes, the skills needed to excel at agentic AI, and the most popular tools you can currently utilize to build your own AI agents.

What is an AI Agent?

An AI agent is a smart system capable of:

• Obtain a high-level goal;

• Break it down into steps;

• Decide on the tools or actions to employ;

• Perform those actions;

• Observe the outcomes and make adjustments in strategy;

Unlike conventional AI models (e.g., chatbots), AI agents are goal-oriented. They do not merely respond to inquiries — they make decisions on what actions to take next. This renders the AI agent a very effective tool for automation, research, testing, software development, data analysis, and decision-making systems.

It is useful to distinguish between:

LLMs → Responses to individual prompts;

Workflows → Predefined, human-designed sequences of steps;

Agents → Systems that choose and control the workflow themselves;

Core Components of an AI Agent

Most AI agents are based upon a few key elements:

Reasoning Engine

The reasoning layer is accountable for goal understanding, task breakdown, and determining the best possible next action. This is usually done with the help of an LLM (Large Language Model).

Planning

Planning enables the agent to plan the sequence of actions rather than acting step by step. Some agents plan ahead, while others plan dynamically after the execution of each action.

Memory

Memory enables agents to store: Past behavior, Intermediate results and Long-term knowledge. The knowledge that can be maintained within long-term memory needs to be adequate for the character to progress appropriately in the story. The type of knowledge that should be stored in this region of memory is the ability to ride a bicycle. This skill requires practice, and the character should demonstrate that they have learned it.

Tools & Actions

The agents interact with the world through tools such as: APIs, Databases, File systems or Browsers.

Feedback & Iteration

The agents assess the outcome of their actions and make decisions on whether to continue, retry, or modify their strategy. This process is what gives the agents autonomy. In agentic systems, decision-making is entrusted to the AI itself and not hard-coded by programmers.

Skills Needed to Master Agentic AI

Agentic AI requires more system design skill than prompt writing skill. The important skills are:

Goal Decomposition — The capacity to decompose complex objectives into smaller, solvable tasks that the agent can reason about.

Tool Design — Well-designed tools are essential. Agents work better when tools are: Clearly defined, Narrow in scope and Deterministic when possible.

Evaluation & Guardrails — Agents must have constraints to prevent infinite loops, hallucinations, or unsafe behaviors. These include: Success criteria, Step limits and Validation rules.

Memory Management — How much the agent should remember, and for how long, is a major architectural choice.

Human-in-the-Loop Design — In most practical scenarios, the agents would be working semi-autonomously with human approval checkpoints rather than full autonomy.

Iterative Improvement — Performance is improved through experimentations, logging, and refinements rather than one-shot executions.

Systems Thinking — In Agentic AI, one has to think beyond the response, including orchestration, observability, failure modes, and scalability.

Agent Frameworks for Developers

The environment for developing AI agents is an ever-changing one. Some of the most popular tools being used currently are listed below.

LangChain – A widely used framework that chains LLMs together using tools, memory, and control logic.

CrewAI – Emphasizes the collaboration of multiple agents with defined roles.

AutoGPT-like frameworks – Early autonomous agents that cycled between planning and execution loops.

OpenAI Agent Builder / AgentKit – Tools for building structured, tool-driven agents with safety guardrails.

Koog.ai – A Kotlin‑centric framework for developing AI agents, emphasizing strong typing, modular prompt executors, and a clean separation of reasoning, tools, and orchestration. Especially suited for backend and Android‑adjacent spaces.

The result is my new project: Koog - Agentic Mobile Tester.

Why I Built This

As an Android developer, I’ve used Espresso, UIAutomator, and other frameworks. They’re powerful, but still rigid: you need to write detailed test scripts and keep them updated. I wanted to explore whether an AI agent could take high-level goals like “Log in and navigate to the profile screen” and figure out the steps automatically.

How It Works

The project is powered by Koog.ai and Kotlin, using an LLM as the reasoning engine (options include Gemini, Llama, GPT, or Gwen). Here’s the flow:

Ktor API & Koog Agent (Backend)

The backend is built with Ktor in Kotlin and powered by a custom Koog agent (MobileTestAgent) plus a toolkit of device actions (MobileTestTools).

Ktor API The Ktor server exposes endpoints that receive test scenarios and configuration (LLM model, temperature, iterations). Each request is routed to the MobileTestAgent, which runs the scenario with the chosen parameters.

MobileTestAgent (Koog Agent) MobileTestAgent encapsulates the Koog agent setup. It translates high-level test goals into an iterative reasoning process, where the LLM plans actions like “tap login button” or “enter text”. The agent respects limits such as max iterations and temperature to balance creativity and determinism.

MobileTestTools (Device Interaction) MobileTestTools provides the executable layer via ADB commands. It includes functions for:

• Interactions: tap(), typeText(), scroll(), swipe()
• Checks: assertTextVisible(), getUiHierarchy()
• Utilities: launchApp(), installApk(), takeScreenshot()

These functions are registered as tools within Koog, so when the agent plans an action, Koog calls the corresponding method directly.

Execution Flow

• Ktor receives a scenario and sends it to the agent.
• Koog plans the next step using the LLM.
• The selected MobileTestTools method executes the action on the device.
• Feedback (UI state, success/failure) is fed back into the agent.
• This loop continues until the scenario ends or max iterations are hit.

At the end, a structured report is generated with actions, results, and optional artifacts (like screenshots), and returned to the frontend dashboard.

User Input (Frontend Dashboard)

• Users create test scenarios (goals & steps) via a ReactJS dashboard.
• The site was designed with Stitch and stores data in Cloud Firestore.
• Users can also tweak AI agent parameters like:
  • Model (Gemini, GPT, etc.)
  • Temperature
  • Max iterations

Sample Android App

• To showcase the system, I created a simple demo Android app.
• The agent can interact with it and validate flows end-to-end.

Example Flow

• User defines a scenario:
  “Tap Add Post button → Input “some text” in the Description → Tap Create Post button”

• The AI agent receives it, plans the steps, and uses ADB actions (tap, type, scroll, assert text).
• A report is generated with success/failure details.

No need to maintain test scripts—just provide the goal.

Why Kotlin + Koog?

Kotlin gave me the flexibility to build a clean API with Ktor and manage complex agent logic easily. Koog.ai, with its Model Context Protocol (MCP) integration and agentic design, allowed me to connect the LLM with Android tooling like ADB seamlessly.

This mix of Kotlin, LLMs, and Android dev tools opens a new way of thinking about mobile testing: instead of scripting, you describe intentions.

What’s Next

• Improving reporting (screenshots, videos, structured logs).
• Expanding to iOS and Web end-to-end testing.
• Exploring CI/CD integration for real-world teams.

Links

• 🔗 Koog - Agentic Mobile Tester (Agent)
• 🔗 Frontend Dashboard
• 🔗 Sample Android App
• 🔗 LinkedIn post

This was a fun experiment mixing Kotlin + AI agents + Android testing. If you’re curious about agentic AI, Koog, or just want to rethink mobile testing, I’d love feedback, feel free to DM on LinkedIn! 🚀

The Benefits of Koog for Your AI Agentic Projects

Koog offers a compelling set of features and advantages that make it an excellent choice for anyone looking to dive into AI agent development with Kotlin:

• Pure Kotlin Implementation: Build and run your AI agents entirely in idiomatic Kotlin. This means leveraging all the benefits of Kotlin – conciseness, null safety, and excellent tooling – for your AI projects.
• Modular Feature System: Extend your agent’s capabilities through a highly composable feature system. This allows for flexible and scalable agent design.
• Tool Integration: Koog allows you to create and integrate custom tools, giving your agents access to external systems and resources. This is crucial for agents that need to interact with the real world or specific APIs.
• Powerful Streaming API: Process responses from Large Language Models (LLMs) in real-time. This is essential for responsive user interfaces and efficient handling of large outputs. It even supports invoking multiple tools on the fly from a single LLM request.
• Intelligent History Compression: Optimize token usage while maintaining conversation context through various pre-built strategies. This helps manage costs and improves efficiency when dealing with long conversations.
• Persistent Agent Memory: Enable knowledge retention across different sessions and even between different agents, leading to more robust and capable AI.
• Comprehensive Tracing: Debug and monitor agent execution with detailed and configurable tracing of LLM calls, tools, and agent stages. This provides invaluable insight into your agent’s behavior.
• Support for Various LLM Providers: Koog integrates with popular LLM providers like Google, OpenAI, Anthropic, OpenRouter, and Ollama, giving you flexibility in choosing your underlying AI models.

My Experience with Koog

As someone who is currently working on an AI agentic project and, honestly, without previous AI code experience, I can confidently say that Koog (version 0.2.1) is super good for it. The framework’s design is incredibly intuitive, making it easy to grasp the core concepts of building AI agents. The clear documentation and the idiomatic Kotlin approach meant that I could quickly get started and see tangible results. The ability to integrate tools and design complex workflows without getting bogged down in low-level AI complexities has been a game-changer for my project.

Conclusion

Koog is truly a game-changer for Kotlin developers venturing into the exciting field of AI agents. Its pure Kotlin implementation, comprehensive features, and developer-friendly design make it an exceptionally powerful and enjoyable framework to work with. It’s clear that JetBrains has put a lot of thought into making AI agent development accessible and efficient. Even for someone like me, who previously lacked extensive AI coding experience, Koog has proven to be incredibly easy to work with and an excellent foundation for building sophisticated AI agentic projects. If you’re a Kotlin developer looking to build AI agents, I highly recommend giving Koog a try – you won’t be disappointed!

What is Gemini Journeys?

Gemini Journeys represents a paradigm shift in mobile testing methodology. Instead of writing complex test scripts line by line, developers can now describe their testing intentions in plain English, and Gemini AI translates these prompts into comprehensive end-to-end tests.

The feature integrates seamlessly with Android Studio’s preview environment, offering developers an intuitive way to:

• Generate automated UI tests through conversational prompts
• Create comprehensive test scenarios without deep testing framework knowledge
• Accelerate the testing workflow significantly
• Reduce the barrier to entry for comprehensive mobile testing

Hands-On Experience: Building with KoinBase

To explore Gemini Journeys’ capabilities, I created a demo project called KoinBase - a simple cryptocurrency tracking application built with Jetpack Compose. The app showcases modern Android development practices while serving as a perfect testing ground for AI-assisted test generation.

Key Features of the Demo:

• Clean Architecture: Implementing MVVM pattern with proper separation of concerns
• Jetpack Compose UI: Modern declarative UI framework
• Dependency Injection: Using Koin for lightweight DI
• Network Integration: RESTful API consumption for crypto data
• Material 3 Design: Following latest design guidelines

First Impressions: A Game Changer

After experimenting with Gemini Journeys on the KoinBase project, here are my initial thoughts:

The Good:

• Intuitive Workflow: Describing test scenarios in natural language feels remarkably natural
• Productivity Boost: Test creation time reduced significantly compared to manual approaches
• Intelligent Context: Gemini understands app structure and suggests relevant test scenarios
• Quality Output: Generated tests are comprehensive and well-structured

The Promise: This technology represents a fundamental shift toward more accessible and efficient mobile testing. For teams struggling with testing coverage or developers new to automated testing, Gemini Journeys could be transformational.

Looking Forward

Gemini Journeys appears to be more than just another AI tool - it’s positioning itself as a genuine game changer for mobile testing workflows. The ability to generate robust E2E tests through conversational prompts could democratize comprehensive testing practices across development teams of all skill levels.

As AI continues to integrate deeper into development workflows, features like Gemini Journeys demonstrate how machine learning can augment human creativity rather than replace it. The future of Android development looks increasingly collaborative between human insight and artificial intelligence capabilities.

Try It Yourself

Interested in exploring Gemini Journeys? Check out the official documentation and consider experimenting with your own projects. The KoinBase demo is also available as a reference implementation.

The intersection of AI and mobile development continues to evolve rapidly, and Gemini Journeys represents an exciting step toward more intelligent, efficient development practices.

Thankfully, Jetpack Compose, Android’s modern UI toolkit, offers some elegant patterns to keep your state under control. Let’s break down some of the key ideas, making them easier to understand than a complex technical paper.

The Core Idea: State Hoisting

Imagine you have a Checkbox in your app. It has two states: checked or unchecked. If the Checkbox manages its own state, it’s called “internal state.” But what if another part of your app needs to know if it’s checked?

This is where State Hoisting comes in. Instead of the Checkbox holding its own “checked” status, we “hoist” that status up to a parent component. The Checkbox then becomes a “dumb” component. It just shows what it’s told to show and tells its parent when it’s clicked.

Think of it like a child asking a parent for permission. The child (our Checkbox) doesn’t decide if it can have a cookie (change its state). It asks the parent (the higher-level component), and the parent makes the decision and tells the child what to do.

In Compose, this often looks like:

@Composable
fun MyFancyCheckbox(
    isChecked: Boolean, // The state is passed in
    onCheckedChange: (Boolean) -> Unit // An event is passed out
) {
    Checkbox(
        checked = isChecked,
        onCheckedChange = onCheckedChange // The parent handles the actual state update
    )
}

@Composable
fun ParentScreen() {
    var checkedState by rememberSaveable { mutableStateOf(false) } // Parent manages the state
    MyFancyCheckbox(
        isChecked = checkedState,
        onCheckedChange = { newCheckedState -> checkedState = newCheckedState }
    )
}

This makes MyFancyCheckbox reusable and testable because it doesn’t care how its state is managed, only what its state is and when it’s interacted with.

State Holders: Your State Organizers

As your app gets more complex, you’ll have more and more state. Just having a bunch of vars in your @Composable function can get unwieldy. This is where State Holders come in handy.

A State Holder is essentially a plain old Kotlin class that holds and manages a piece of your UI’s state. It centralizes all the logic related to that state.

Imagine a user profile screen. It might have the user’s name, email, and a “save” button. Instead of managing all these bits of information directly in your ProfileScreen Composable, you could have a ProfileScreenStateHolder (or ViewModel if it’s lifecycle-aware).

// A simple example of a State Holder
class MyLoginScreenStateHolder {
    var username by mutableStateOf("")
    var password by mutableStateOf("")

    fun onUsernameChanged(newUsername: String) {
        username = newUsername
    }

    fun onPasswordChanged(newPassword: String) {
        password = newPassword
    }

    fun login() {
        // Perform login logic using username and password
        println("Attempting to log in with username: $username")
    }
}

@Composable
fun LoginScreen(stateHolder: MyLoginScreenStateHolder = remember { MyLoginScreenStateHolder() }) {
    Column {
        TextField(
            value = stateHolder.username,
            onValueChange = stateHolder::onUsernameChanged,
            label = { Text("Username") }
        )
        TextField(
            value = stateHolder.password,
            onValueChange = stateHolder::onPasswordChanged,
            label = { Text("Password") }
        )
        Button(onClick = stateHolder::login) {
            Text("Login")
        }
    }
}

This separates the UI (LoginScreen) from the logic and state management (MyLoginScreenStateHolder), making your code cleaner and easier to understand.

ViewModels: The Android-Aware State Holders When your State Holder needs to survive configuration changes (like rotating your phone) or interact with data from your app’s deeper layers (like a database or network), you often use a ViewModel.

A ViewModel is a special kind of State Holder provided by Android Architecture Components. It’s designed to hold UI-related data in a way that survives app lifecycle events. It’s often where you’ll find your network calls, database operations, and other business logic that feeds into your UI.

Think of it as the brain of your screen or feature. It fetches data, processes it, and then exposes that data to your Composables.

When to Choose What?

• State Hoisting: For simple UI elements where the parent needs to control the state. It makes components reusable and less coupled.
• Simple State Holders (Plain Kotlin classes): When you have a group of related UI state that needs to be managed together within a single Composable, and it doesn’t need to survive lifecycle changes or interact with deeper app layers.
• ViewModels: For complex screens or features where you need to manage state that survives configuration changes, interacts with data sources (like network or database), or requires more complex business logic. They are typically used for a whole screen or a significant portion of it.

The Benefits of Good State Management

By applying these patterns, you gain:

• Cleaner Code: Your UI code focuses solely on how things look, not what data they hold or how that data changes.
• Easier Testing: You can test your State Holders and ViewModels independently of your UI.
• Better Reusability: Components become generic and can be used in different parts of your app.
• Improved Maintainability: When something breaks, it’s easier to pinpoint where the issue lies.

Understanding and applying these state management patterns in Jetpack Compose will significantly improve the quality and maintainability of your Android applications. It’s a fundamental concept that will serve you well as you build more complex and robust experiences.

🎭 Composables = Stage Actors

Composables are like actors:

• They enter when the screen appears.

• They update their lines when state changes (recomposition).

• They exit when removed from the UI.

🕯️ LaunchedEffect = Candle in a Room

• You light a candle when entering a room → LaunchedEffect runs.

• If the room changes (key changes), you blow it out and light a new one.

• If you leave, the candle is blown out.

• Use it for one-time effects or state collection.

🧹 DisposableEffect = Hotel Housekeeping

• Housekeeper sets up the room → DisposableEffect runs.

• When you check out (or key changes), the room is cleaned → onDispose is called.

• Perfect for listeners or subscriptions that need cleanup.

🔄 Recomposition = Changing Actor’s Lines

If the script (state) changes, actors stay on stage but adjust their lines. No need to re-run effects unless keys change.

Quick Comparison

✅ Final Tip

So next time you add a LaunchedEffect or a DisposableEffect, ask yourself:

• Is this a one-time action? → Use LaunchedEffect.

• Does it need cleanup? → Use DisposableEffect.

• Thinking this way makes Compose easier and your code cleaner.

• Side-Effect official docs.

• LaunchedEffect official docs.

What is Android XR?

• XR (Extended Reality) encompasses all immersive technologies—AR, VR, and mixed reality (MR). Android XR integrates these experiences seamlessly into Android devices, allowing developers to create cutting-edge applications that:

• Overlay digital objects on the real world (AR).

• Fully immerse users in virtual environments (VR).

• Combine real and virtual objects that interact in real-time (MR).

• Android’s XR ecosystem is built on frameworks like ARCore and leverages powerful hardware capabilities available in modern devices.

Key Components of Android XR

1. ARCore

ARCore is Android’s primary SDK for building AR applications. It provides tools to:

• Track motion in 3D space.

• Understand environmental features like flat surfaces.

• Estimate lighting conditions for realistic AR rendering.

2. XR Interaction Tools

Android XR provides APIs and libraries to simplify interactions, such as detecting gestures or recognizing physical objects. Developers can use Unity or Unreal Engine to create rich 3D experiences or integrate ARCore directly into Android apps for custom solutions.

3. Cross-Platform Development

Android XR supports frameworks like OpenXR, making it easier to build applications that work across multiple devices, from smartphones to head-mounted displays (HMDs).

Getting Started with Android XR Development

1. Set Up Your Development Environment

Start by installing Android Studio and configuring it for XR development:

• Install the latest version of Android Studio.

• Add the ARCore dependency to your project.

• Use a physical device with ARCore support for testing.

2. Learn the Basics

Explore Android XR’s official documentation:

• Android XR Overview

• Developing XR Applications

3. Build Your First App

Try creating a simple AR app that displays a 3D object on a flat surface. ARCore’s Plane Detection API can help you get started quickly.

My Android XR Demo Project

To help you jumpstart your journey, I’ve created a simple demo app showcasing basic XR features using ARCore and Jetpack Compose. This project serves as a practical example to learn XR development fundamentals.

Check it out on GitHub: Android XR Demo

Notice that you can also check some samples from Google team.

During the session, titled “Creating Inclusive Experiences: A Guide to Accessibility in Android Apps with Jetpack Compose,” I delved into the vital role accessibility plays in shaping a truly universal user experience. We explored topics such as:

The challenges faced by users with disabilities, including visual, mobility, cognitive, and hearing impairments. The accessibility services provided by Android, like TalkBack, Switch Access, and Voice Access. Practical guidelines for creating inclusive designs, such as optimizing touch targets, simplifying gestures, and ensuring sufficient color contrast. Tools and methods for testing accessibility, including manual testing with TalkBack and automated testing using semantics in Jetpack Compose. The presentation also included practical demonstrations of accessibility testing, featuring examples from an app I created specifically to highlight accessibility issues and solutions (InaccessibleApp).

Why Accessibility Matters

As the World Health Organization notes, over 1.3 billion people live with some form of disability. Accessibility isn’t just about compliance; it’s about empathy and inclusion. By leveraging Jetpack Compose’s accessibility tools, we can build Android apps that make everyone feel welcome and empowered.

Thank You to the Community

I want to extend a heartfelt thank you to the organizers, attendees, and everyone who made this event possible. The energy in the room was fantastic, with engaging questions and thoughtful discussions. It was a delightful evening where we all learned so much about building better, more inclusive experiences.

Looking forward to more opportunities to share knowledge and grow together with this vibrant community!

1. Code Writing and Refactoring Made Easy

Gemini doesn’t just suggest code snippets—it can write, refactor, and document code. With Gemini, you can:

Generate commit messages: Analyze your code changes and get suggested descriptions for version control. Refactor code with ease: Rename variables, classes, and methods using intuitive AI-driven suggestions. Streamline prototypes to production: Implement common design patterns and iterate faster than ever.

2. UI Automation for Jetpack Compose

Visualizing and fine-tuning UI designs can be tedious. Gemini enhances Compose workflows by:

Auto-generating UI previews: Use AI to create relevant mock data and preview your Composables without manual setup. Simplifying multimodal design: Gemini can process contextual image attachments to assist in crafting visually engaging user interfaces.

3. Improving App Quality with AI Insights

Gemini integrates directly with the App Quality Insights tool, leveraging local code context to:

Suggest fixes for crashes reported via Firebase Crashlytics or Google Play Console. Generate unit test scenarios based on your codebase, helping ensure robustness. Provide insights into build and sync errors for faster troubleshooting.

4. Streamlined Documentation

With Gemini, generating documentation is no longer a chore. Simply highlight your code, and Gemini will produce clear, comprehensive comments, making it easier to onboard new team members and maintain codebases.

5. Why Gemini Matters

AI tools like Gemini represent the future of app development. By automating routine tasks, developers can focus on solving complex problems and innovating in their projects. With features like commit message generation and error analysis, Gemini ensures your codebase is not only efficient but also of high quality.

Android has a collection of tools which can help people with disability and the following list has the most important features in my opnion:

✨ Talkback screen reader and Select to Speak

This feature helps you as you navigate your smartphone. On a given screen, it will tell you what kind of screen it is, and what’s on it. For example, if you’re on a settings page, Talkback will read out the section name (such as notifications). When you tap an icon or item, your selection gets a green outline, and the assistant identifies it. Double tapping the same icon opens it. Talkback reminds you to double-tap when you tap on an item.

✨ Font Size and High Contrast Text

This setting lets you change the font size on your device from the default. You can make the text smaller than the default, or various levels larger. As you make adjustments, you can see how it will look.

✨ Magnification 🔍

The user can use a gesture to zoom in on certain parts of your screen. Once you enable the feature in settings, you can zoom in by tapping the screen three times with your finger.

✨Switch Access

Users can Interact with Android app using one or more switches or a keyboard instead of the touch screen. It is also possible to use Camera Switches to navigate with facial gestures.

Jetpack Compose & Accessibility

Jetpack Compose is great when it comes accessibility - it uses semantics properties to pass information to Accessibility services to transform what’s shown on screen to a more fitting format for a user with a specific need.

Most built-in composables like Text and Button fill these semantics properties with information inferred from the composable and its children. Some modifiers like toggleable and clickable will also set certain semantics properties.

However, sometimes the framework needs more information to understand how to describe a UI element to the user.

Improving accessibility using Jetpack compose

This list is mainly focused on some approaches you should think about while developing the app.

There are a bunch of other items related to UI/UX which weren’t included on this list (eg. Colour contrast ratios, minimum touch target sizes, High Contrast theme, etc).

The following items are meant to help people with accessibility needs use the app successfully:

Describe visual elements

Pass a textual description of the visual element whenever is relevant.

Describe click labels

You can use a click label to add semantic meaning to the click behavior of a composable. This way, accessibility services can explain to the user what will happen when the user interacts with the component.

Describe an element’s state

You can describe the state of a component in order to Android to read out the state that the component is in. For example, a toggleable checkbox can be in either a “Checked” or an “Unchecked” state.

Merge visual elements

Sometimes you need to merge elements to make Talkback and Switch Access more efficient. For example if every single low-level visual element in your screen is focused independently, a user will have to interact a lot to move across the screen. Other issue you may face is a user not being able to understand lists of the app because each element of the list will be focused independently (instead of the item itself).

Kotlin Multiplatform (KMP) takes a unique approach by enabling code sharing while retaining native capabilities, making it a compelling choice for modern developers. Let’s dive into the benefits of KMP for Android and iOS development, compare it with other alternatives, and explore why KMP might be the right fit for your next project.

What is Kotlin Multiplatform?

Kotlin Multiplatform (KMP) is a feature of Kotlin, a programming language developed by JetBrains and widely adopted for Android development. Unlike other cross-platform tools that require you to build the entire application using their framework, KMP focuses on sharing business logic, network code, and data layers while allowing you to write platform-specific UI code. This balance provides a unique blend of code reusability and platform fidelity.

Key Benefits of KMP

1. Code Reuse with Platform Flexibility KMP allows you to write common business logic once and share it across platforms, reducing duplication and development time. At the same time, you can implement platform-specific UI and interactions, ensuring that your app feels native on both Android and iOS.

2. Native Performance Unlike JavaScript-based frameworks, KMP compiles shared code to native binaries using Kotlin/Native for iOS and the JVM for Android. This results in high-performance apps that leverage each platform’s full capabilities.

3. Leverage Existing Ecosystems KMP integrates seamlessly with native development tools:

For Android: KMP works directly with Android Studio, Gradle, and Kotlin extensions. For iOS: You can use Xcode and Swift alongside KMP-generated binaries.

1. Interoperability KMP provides robust interoperability with both Java on Android and Swift/Objective-C on iOS, enabling you to integrate shared and native code effortlessly.

2. Future-Proof Solution As Kotlin is officially supported by Google and widely adopted for Android, KMP aligns with the long-term direction of modern Android development. Its active community and JetBrains’ backing ensure continued innovation.

Why KMP is Better for Modern Teams

1. Focus on Native-Like User Experiences Unlike Flutter and React Native, which use custom rendering engines, KMP encourages developers to craft native UIs for each platform. This ensures the app feels truly native, aligning with platform-specific design guidelines.

2. Incremental Adoption You don’t need to rewrite your app to use KMP. It’s easy to adopt incrementally, sharing only selected modules like data access or networking while leaving existing code intact.

3. Shared Code Without Compromising Control KMP provides the best of both worlds: code reuse where it matters (business logic) and full control over platform-specific implementations. This is ideal for teams that prioritize user experience.

4. Fewer External Dependencies KMP uses Kotlin, which is already a familiar and powerful language for Android developers. There’s no need to learn a new framework or deal with third-party dependencies for basic functionality.

When to Choose KMP

KMP is ideal if:

• You already have an Android development team familiar with Kotlin.
• You need a shared codebase for business logic but want platform-specific UIs.
• Performance is critical, and you can’t compromise with JavaScript-based solutions.
• You’re migrating an existing codebase and prefer incremental adoption.

Conclusion

Kotlin Multiplatform offers a pragmatic approach to cross-platform development, empowering developers to share code where it matters while crafting tailored, high-performance native experiences. Its seamless integration with native ecosystems, native performance, and incremental adoption make it a future-ready choice for teams looking to optimize their development processes. If you’re building a new app or looking to reduce technical debt in an existing one, Kotlin Multiplatform might just be the game-changer you need.

Performance Optimization

One of the core focuses of Kotlin 2.0 is to enhance performance. The compiler has been meticulously refined to generate highly optimized bytecode, resulting in faster application startup times and smoother overall execution.

• Optimized Bytecode Generation: The compiler diligently produces more efficient bytecode, minimizing instruction count and memory footprint.
• Enhanced Garbage Collection: The garbage collector has been meticulously tuned to reduce pause times and improve overall performance.

Innovative Language Features

Kotlin 2.0 introduces a suite of new language features that empower developers to write more concise, expressive, and type-safe code.

• Value Classes: Value classes provide a lightweight and efficient mechanism to represent immutable data. They are akin to data classes but offer a more streamlined and performant implementation.
• Inline Classes: Inline classes enable the creation of custom types that are seamlessly integrated with primitive types, enhancing type safety and expressiveness.
• Sealed Interfaces: Sealed interfaces offer a powerful tool for defining a set of related classes, aiding in the construction of type-safe state machines and intricate data structures.

Robust Tooling Support

Kotlin 2.0 is accompanied by substantial improvements in tooling support, ensuring a seamless development experience.

• IntelliJ IDEA: The IntelliJ IDEA Kotlin plugin has been fortified with cutting-edge features and enhancements, including advanced code completion, refactoring, and navigation capabilities.
• Android Studio: The Android Studio Kotlin plugin has likewise been bolstered with new features and optimizations, such as refined code analysis, debugging, and testing tools.

Why Kotlin 2.0 is a Game-Changer for Android Development

Kotlin 2.0 represents a quantum leap for Kotlin, making it an even more compelling choice for Android development. With its performance optimizations, innovative language features, and robust tooling support, Kotlin 2.0 empowers developers to build more efficient, reliable, and maintainable Android applications.

To delve deeper into Kotlin 2.0, explore the official documentation and tutorials.

Understanding Liquidity Pools

Imagine a giant pot of crypto assets. Anyone can add funds (deposit), and anyone can borrow from this pot (withdraw). This pot is essentially a liquidity pool. They fuel DeFi by providing the necessary assets for lending and borrowing activities. Users who deposit their crypto into the pool earn interest on their holdings, while borrowers can access funds at market-determined rates.

Aave: A Liquidity Powerhouse

Aave is a prominent DeFi platform that leverages liquidity pools. Here’s how it works:

• Supplying Crypto: Users can deposit various cryptocurrencies into Aave’s liquidity pools. These deposits earn interest as borrowers pay back their loans.
• Borrowing Crypto: Users can borrow crypto from the pool by putting up collateral (another cryptocurrency). The interest rate on these loans depends on various factors like supply and demand for the specific crypto.
• Earning AAVE: Aave has its own governance token, AAVE. By holding AAVE, users can participate in the platform’s governance and potentially earn additional rewards.

Benefits of Aave

• Passive Income: Supplying crypto to Aave’s pools offers a way to earn interest on your holdings without actively trading.
• Flexible Borrowing: Borrowers can access various cryptocurrencies at competitive rates.
• Transparency & Security: Aave is an open-source platform, meaning its code is publicly available for scrutiny.

Additionally, smart contracts automate transactions, reducing the risk of human error or manipulation. Drawbacks to Consider

• Volatility: Cryptocurrency prices can fluctuate significantly. Supplying crypto to liquidity pools exposes you to potential impermanent loss, where the value of your deposit might be lower when you withdraw compared to simply holding the asset.
• Smart Contract Risk: Smart contracts, while generally secure, can have vulnerabilities. A successful exploit could lead to loss of funds deposited in the pool.
• Complexity: DeFi can be complex for beginners. Understanding interest rates, collateralization ratios, and potential risks is crucial before diving in. Conclusion

Liquidity pools are the backbone of DeFi, and Aave is a leading platform that utilizes them effectively. While Aave offers attractive opportunities for earning interest and borrowing crypto, it’s important to be aware of the potential risks involved. As with any investment, careful research and understanding the underlying technology are crucial before participating in DeFi.

Meme coins, as highlighted in the article from Investopedia are a unique category of cryptocurrencies that have gained popularity through social media trends and viral marketing. Unlike traditional cryptocurrencies driven by technological advancements or real-world utility, meme coins derive their value primarily from community involvement and social media excitement. These digital assets have become a cultural phenomenon, offering emotional support or recognition to specific communities despite lacking substantial economic value.

Why Meme Coins Lack Utility

While meme coins can provide emotional backing to certain groups, they are often criticized for their lack of real-world application and limited utility. These coins are primarily driven by hype and social media trends rather than fundamental value or technological innovation. Critics argue that meme coins do not contribute significantly to the cryptocurrency ecosystem in terms of solving real-world problems or advancing blockchain technology.

Criticizing the Meme Coin Frenzy

Vitalik Buterin’s critique of meme coins, sheds light on the investment frenzy surrounding these digital assets. Buterin emphasizes the need for more meaningful engagement and support within the crypto infrastructure, highlighting the importance of balancing investment to foster a more equitable and functional ecosystem. The criticism points towards the speculative nature of meme coins and the risks associated with investing in assets driven primarily by social media influence rather than intrinsic value.

In conclusion, while meme coins offer a unique avenue for high-risk, high-reward investments and have captured significant attention in the cryptocurrency landscape, it is essential for investors to approach them with caution. Understanding the limitations of meme coins in terms of utility and being aware of the potential risks associated with market speculation is crucial for making informed investment decisions in this dynamic sector. Conducting thorough research, staying updated on market trends, and diversifying investments are key strategies to navigate the meme coin market responsibly.

Vitalik Buterin’s Vision for AI-Assisted Code Audits

Vitalik Buterin’s proposal suggests integrating AI into the code auditing process to improve efficiency and effectiveness. By harnessing AI capabilities, developers can enhance their ability to detect vulnerabilities and ensure the robustness of smart contracts within the Ethereum ecosystem

The Role of AI in Smart Contract Audits

AI-assisted code audits offer a unique advantage over traditional automated tools by adapting and learning from new information. This adaptability is crucial in the dynamic landscape of smart contract security, where emerging vulnerabilities require swift detection and mitigation strategies

Industry Response and Potential Benefits

Ethereum project developers have shown support for Buterin’s idea, emphasizing the potential of combining human expertise with AI systems to create a comprehensive security framework. The collaboration between AI and human inspection could significantly strengthen code integrity and mitigate risks associated with bugs and exploits

Addressing Security Challenges in Blockchain Projects

The increasing complexity of blockchain projects necessitates advanced security measures to safeguard user funds and maintain trust within the ecosystem. By exploring AI-based solutions for code audits, Ethereum aims to proactively address security challenges and enhance the resilience of its decentralized applications

In conclusion, Vitalik Buterin’s proposal to incorporate AI into code audits represents a significant step towards fortifying Ethereum’s security infrastructure. By embracing innovative technologies like AI, Ethereum demonstrates its commitment to advancing blockchain security standards and fostering a more secure environment for decentralized applications.

Easy Setup

Jetpack Compose provides a streamlined approach to setting up UI tests. By adding the necessary dependencies to the build.gradle file, developers can easily incorporate Compose testing libraries into their projects. This simplified setup ensures that developers can focus on writing effective tests without the hassle of complex configurations.

Enhanced Test Implementation

Jetpack Compose UI testing allows developers to write tests that focus on specific UI components and interactions. By following best practices and structuring tests around states and events, developers can ensure that their UI composable functions are thoroughly tested. This approach enhances the reliability and robustness of UI components, leading to a more stable and user-friendly application.

Comprehensive Test Rule Integration

Jetpack Compose offers test rule integration that simplifies the process of writing and executing UI tests. Developers can leverage test rules like createComposeRule() or createAndroidComposeRule() to set up test environments and interact with UI components effectively. These test rules provide a structured framework for writing test functions and validating UI behavior.

Real-time Testing Feedback

Jetpack Compose UI testing provides real-time feedback on UI interactions, allowing developers to validate changes and ensure that the app behaves as expected. By utilizing features like assertExists(), performClick(), and assertDoesNotExist(), developers can simulate user interactions and verify the responsiveness of their UI components. This real-time feedback loop accelerates the testing process and aids in identifying potential issues early on.

Test Tag Implementation

Jetpack Compose introduces the concept of test tags, which serve as references for making specific components detectable in tests. By assigning test tags to composable functions, developers can easily locate and interact with UI elements during testing. This approach enhances test readability and maintainability, making it easier to identify and troubleshoot issues within the UI. Don’t overuse testTag once it may pollute your production code. Instead of that, you can use semantics to interact with the UI on your tests. Using semanatics improves your app’s accessibility once Android utilizes semantics to offer alternative interaction methods for users with special needs, such as TalkBack, a screen reader, or Switch Access.

In conclusion, Jetpack Compose UI testing in Android offers a comprehensive framework for validating UI components, interactions, and behaviors. By leveraging the testing capabilities provided by Jetpack Compose, developers can ensure the quality, reliability, and performance of their Android applications, leading to enhanced user experiences and increased app stability.

Seamless Integration with Existing Code

Jetpack Compose is designed to be compatible with existing codebases, allowing developers to adopt it gradually and integrate it seamlessly into their projects. This compatibility ensures that developers can leverage the power of Compose without the need for a complete overhaul of their existing codebase, enabling a smooth transition to modern UI development practices.

Live Previews and Full Android Studio Support

Jetpack Compose accelerates development by providing live previews and full support within Android Studio. Developers can visualize changes to the UI in real-time, iterate quickly, and ensure a consistent user experience across different screen sizes and orientations. The robust tooling support offered by Compose enhances developer productivity and facilitates a more efficient development workflow.

Direct Access to Android Platform APIs

Jetpack Compose offers direct access to Android platform APIs, enabling developers to create feature-rich and visually appealing apps with ease. By leveraging built-in support for Material Design, Dark theme, animations, and more, developers can create apps that adhere to Android design guidelines and provide a seamless user experience.

Adaptive UI Development

Compose for large screens and Wear OS extends the capabilities of Jetpack Compose to cater to different form factors and screen sizes. The adaptive layout ensures that the UI of the app responds effectively to varying screen dimensions, orientations, and device types, providing a consistent and optimized user experience across all platforms.

In conclusion, Android Jetpack Compose emerges as a game-changer in the realm of Android UI development, offering a plethora of benefits that enhance developer productivity, streamline UI creation, and elevate the user experience of Android applications. By embracing Jetpack Compose, developers can unlock new possibilities in UI design and development, leading to the creation of visually stunning and feature-rich Android apps.

Android Jetpack Compose has revolutionized the way developers create user interfaces for Android applications. By leveraging this modern toolkit, developers can streamline UI development, enhance user experience, and boost productivity. Let’s delve into the benefits of Android Jetpack Compose based on insights from various sources. Simplified UI Development Jetpack Compose simplifies UI development by allowing developers to describe the UI using Kotlin code. This declarative approach eliminates the need for XML layouts, reducing boilerplate code and making UI development more intuitive and efficient with Compose, developers can create custom and non-standardized components with ease, enabling them to build visually appealing interfaces for their apps.

Enhanced Developer Satisfaction

One of the key benefits highlighted by developers using Jetpack Compose is the satisfaction it brings. The technology is well-received among developers, who appreciate the modern approach to UI development and the ease of creating interactive and dynamic interfaces. By adopting Compose, developers can work more efficiently, leading to a more motivated and engaged team.

Reduced Technological Debt

Jetpack Compose offers a lower risk of technological debt compared to traditional UI development approaches. Google’s emphasis on the adaptation and development of Compose, along with positive feedback from developers, positions it as a safer choice for long-term project development. Additionally, being part of the Jetpack package means that Compose is well-integrated with other Google solutions, paving the way for future enhancements and integrations.

Faster Software Development

Despite being a relatively new technology, Jetpack Compose enables faster native Android UI development compared to traditional XML-based approaches. By leveraging Compose’s capabilities, developers can iterate quickly, build UI components efficiently, and create visually appealing apps with less code. The intuitive nature of Compose allows for rapid prototyping and iteration, leading to shorter software development cycles.

Step 1: Setting up the Development Environment Before we begin, make sure you have the following tools installed: Node.js and npm (Node Package Manager) A code editor or IDE (Integrated Development Environment) such as Visual Studio Code or IntelliJ IDEA A web3 library for JavaScript, such as Web3.js or ethers.js

Step 2: Creating a GraphQL Schema A GraphQL schema is a definition of the types of data that can be queried and the relationships between them. To create a GraphQL schema for our app, we will use the GraphQL schema language.

`type Query {
  token(id: ID!): Token
}

type Token {
  id: ID!
  name: String!
  symbol: String!
  totalSupply: Int!
  balanceOf(address: String!): Int!
}`

In this schema, we have defined a Query type that has a single field called token. The token field takes an id argument of type ID!, which means that it is a required field. The token field returns a Token type, which has several fields: id, name, symbol, totalSupply, and balanceOf. The balanceOf field takes an address argument of type String!, which means that it is a required field.

Step 3: Creating a GraphQL Resolver A GraphQL resolver is a function that is called when a query is executed. The resolver is responsible for fetching the data for the query and returning it in the correct format. To create a GraphQL resolver for our app, we will use the graphql-tools library.

const { graphqlHTTP } = require('express-graphql');
const { buildSchema } = require('graphql');

const schema = buildSchema(`
  type Query {
    token(id: ID!): Token
  }

  type Token {
    id: ID!
    name: String!
    symbol: String!
    totalSupply: Int!
    balanceOf(address: String!): Int!
  }
`);

const rootValue = {
  token: async (parent, { id }) => {
    const token = await getToken(id);
    return token;
  },
};

const app = express();
app.use('/graphql', graphqlHTTP({
  schema: schema,
  rootValue: rootValue,
  graphiql: true,
}));

app.listen(4000, () => {
  console.log('GraphQL server running on port 4000');
});

In this code, we have defined a schema object that contains our GraphQL schema. We have also defined a rootValue object that contains the resolver functions for our schema. The token resolver function takes an id argument and returns a Token object.

Step 4: Connecting to Ethereum Networking To connect to the Ethereum network, we will use the web3 library.

const Web3 = require('web3');

const web3 = new Web3(new Web3.providers.HttpProvider('https://mainnet.infura.io/v3/YOUR_PROJECT_ID'));

In this code, we have created a new Web3 object and passed it a HttpProvider object that connects to the Ethereum mainnet through Infura/Alchemy.

Step 5: Querying ERC20 Tokens To query ERC20 tokens, we will use the web3.eth.getToken method. const token = await web3.eth.getToken(tokenAddress);

In this code, we have called the getToken method on the web3.eth object and passed it the address of the ERC20 token we want to query.

Step 6: Returning the Token Data Once we have queried the ERC20 token, we can return the data to the client.

return {
  id: token.id,
  name: token.name,
  symbol: token.symbol,
  totalSupply: token.totalSupply,
  balanceOf: token.balanceOf,
};

In this code, we have returned an object that contains the id, name, symbol, totalSupply, and balanceOf fields of the ERC20 token.

Conclusion In this blog post, we have covered the basics of creating a GraphQL app that connects with Ethereum networking to communicate with ERC20 tokens. We have learned how to create a GraphQL schema, create a GraphQL resolver, connect to Ethereum networking, query ERC20 tokens, and return the token data to the client. With this knowledge, you can build your own GraphQL app that interacts with the Ethereum blockchain.

No significant change happened to the $1.9 trillion travel industry. The pandemic led to unprecedented low travel volumes and financial strain, and all those business trips year-round are now 30-minute Zoom meetings. The travel and hospitality industries (and their customers) are stuck with dated solutions, where online booking, cheap flight platforms, and lousy loyalty mechanics are not sufficing modern travelers and modern challenges and needs. Nomad rethinks the role of blockchain, empowering travelers and companies alike with unprecedented opportunities and creating a harmonious ecosystem that fosters trust, transparency, and unforgettable experiences.

What it does

The user’s journey starts when he/she decides to book a flight. To do so, the user can install the Nomad App and check the flights available. Due to the hackathon, we are using a specific flight (YYC - SEA) as a use case but the project can be more flexible and include more flight legs.

The app’s home screen integrates with Nomad core (NodeJs app - Backend) which provides a list of flights based on Flights API (Aviation stack API). Our Backend is hosted on [Heroku platform] Nomad Backend.

The user can go through the sign-in flow and create an account. For this step, the Nomad app integrates with Firebase Authentication (Firebase Authentication) and lets the user choose a Google account. This step is crucial because it is part of the Seamless Web3 wallet creation - the user creates a Web3 wallet with 3 clicks and does not need to worry about the bureaucratic Web3 wallet creation. During this process, the Backend will store the user’s credentials on MongoDB (MongoDB Atlas). It will automagically ether.js create the user’s Ethereum wallet and store the private key on the MongoDB. We are not really concerned about security here since the wallet will not store a huge number of tokens/rewards initially.

The app also has two other screens: Admin and Profile. Admin screen provides triggers to the Backend force interactions with the smart contract NomadBadge and the Flights API for only testing purposes. The Profile gives some information about User’s data on the MongoDB database and also exposes the user’s private key for testing purposes.

A flight can be booked on the Home screen. The user can tap the Buy ticket button which will trigger the Backend to add a Flight (scheduled flight status) entry on the blockchain. Notice the user has to have Funds in his wallet in order to buy a flight ticket. After the flight is added on-chain, the user has an eligible flight and can get rewards from it. The Backend will update all the scheduled flight statuses and also update the smart contract.

Chainlink Automation executes the rewarding process for NomadBadge automatically. Once per pay, Chainlink Automation triggers the rewarding process for all the ACTIVE flights. The NomadBadge mints an NBG token if the user does not have an NBG token according to the Soulbound token specification.

We used a Soulbound token as a reference to a user’s non-transferable experience with the airline/flight. This and in conjunction with the reward system offers airlines a unique and dynamic loyalty system that engages users with their experience/status and rewards them with points they can use or transfer to others.

After that, the NomadBadge attributes rewards points to the user token and also transfers ERC20 tokens (NomadRewardToken - NRT) to the user’s wallet. The ERC20 tokens can be transferred at any time by the user. By the end of the process, NomadBadge changes the flight status to REWARDED.

Built With

• alchemyapi
• chainlink
• ethersjs
• express.js
• firebase
• heroku
• javascript
• kotlin
• mongodb
• node.js
• openzeppelin
• solidity
• typescript

Material3 Components

1. Typography Typography in Material3 focuses on readability and hierarchy. It includes a range of text styles and weights to help developers create visually appealing and accessible interfaces.
2. Color System Material3 introduces a new color system that offers a wider palette and more flexibility for customizing app themes. It includes primary, secondary, surface, and on-surface colors to ensure consistency across the app.
3. Shape The shape system in Material3 defines the corner radius for components like buttons, cards, and dialogs. It allows for consistent and visually pleasing rounded corners throughout the app.
4. Elevation Elevation helps create a sense of depth and hierarchy in the UI. Material3 provides a standardized elevation system for components, making it easier to design interfaces with consistent shadows and overlays.
5. Motion Motion in Material3 adds fluidity and responsiveness to app interactions. It includes predefined animations for common UI transitions, enhancing the user experience and making the app feel more dynamic.

Integrating Material3 with Jetpack Compose

Jetpack Compose simplifies UI development by using a declarative approach to building interfaces. When integrating Material3 with Jetpack Compose, developers can leverage the following:

1. MaterialTheme The MaterialTheme composable allows developers to apply Material3 styles and components to their UI elements. It provides easy access to typography, colors, shapes, and other design elements defined in Material3.

2. Material3 Components Material3 components like Button, TextField, Card, and BottomSheet are designed to work seamlessly with Jetpack Compose. Developers can use these components to create modern and consistent UIs that follow Material Design guidelines.

3. Theming Jetpack Compose makes theming easy by allowing developers to define custom themes and apply them to different parts of the app. By combining Material3’s design system with Jetpack Compose’s theming capabilities, developers can create visually appealing and cohesive user interfaces.

In conclusion, Material3 for Android and Jetpack Compose offer a powerful combination for building modern and visually engaging apps. By understanding the main components of Material3 and how they integrate with Jetpack Compose, developers can create UIs that are not only beautiful but also user-friendly and consistent.

In the realm of modern UI development, two prominent technologies have emerged as game-changers: Jetpack Compose for Android app development and Reactive JS for web development. As a software engineer specializing in Android app development and interested in web technologies, you’ll find this comparison insightful. In this blog post, we’ll explore the key features, benefits, and use cases of Jetpack Compose and Reactive JS, shedding light on their similarities and differences.

Jetpack Compose: Unleash the Android Magic

If you’re all about crafting pixel-perfect Android apps that dazzle users, Jetpack Compose is your new best friend. This Google-born toolkit is like a breath of fresh air in the Android development scene. With Kotlin as its wingman, Compose lets you conjure up UIs using a super cool declarative style. You’re basically telling your app what you want it to look like, and boom, it works its magic!

Key Features and Perks:

1. Declarative UI: Jetpack Compose allows developers to describe UI components using a declarative syntax, which eliminates the need for manually managing UI updates and simplifies the codebase.

2. Reactive Data Flow: Jetpack Compose utilizes a reactive programming model, ensuring that UI updates are automatically triggered when the underlying data changes.

3. Compose UI Elements: UI components in Jetpack Compose are themselves functions, enabling developers to create complex UIs by composing smaller, reusable building blocks.

4. State Management: Jetpack Compose provides built-in tools for managing UI state, reducing the complexity associated with state management in traditional Android development.

Reactive JS: Web Wizardry at Its Best

But hey, let’s not forget the web realm! Reactive JS, the rockstar of web development, is all about building those slick and responsive web apps. It’s the magic wand for creating dynamic user interfaces that dance to the tune of data and events.

Key Features and Cool Stuff:

1. Component-Based Architecture: Reactive JS frameworks promote component-based development, enabling developers to create modular UI components that can be reused and managed more efficiently.

2. Virtual DOM: Reactive JS frameworks employ a Virtual DOM, which optimizes UI updates by calculating the minimal set of changes needed to update the actual DOM, leading to improved performance.

3. One-Way Data Flow: Reactive JS follows a unidirectional data flow, where data flows from parent components to child components, simplifying the debugging process.

4. Efficient Updates: By tracking changes in data and events, Reactive JS frameworks only update the UI elements that require changes, minimizing unnecessary re-renders.

The Ultimate Face-Off: What to Choose?

So, which path should you tread? If you’re all about crafting Android apps that feel like a dream, Jetpack Compose is calling your name. With your Android expertise and Kotlin superpowers, it’s a match made in UI heaven. However if your heart beats for the web and you want to create dynamic, kickass web apps, Reactive JS is your ticket to the web wonderland. With its component party and data flow dance, you’ll be the life of the web development bash.

Understanding the Basics

Before diving into the migration process, it’s important to understand the basics of Jetpack Compose. Jetpack Compose uses a completely different approach to building UI compared to XML-based UI. Instead of defining UI elements in XML files, Jetpack Compose uses composable functions to create the user interface. Composable functions are lightweight and modular, allowing for easier composition and reuse. With Jetpack Compose, UI elements are defined using simple Kotlin functions that return UI components, making the code more concise and readable.

Step-by-Step Migration Process

1. Identify the Scope of Migration: Start by determining the scope of the migration. Analyze your XML-based UI code and identify the screens or components that you want to migrate to Jetpack Compose. It’s a good idea to start with smaller, less complex screens for the initial migration.
2. Create a Composable Function: For each screen or component you want to migrate, start by creating a new composable function in your Jetpack Compose code. This function will replace the XML file and will be responsible for defining the UI elements and layout.
3. Translate XML Elements to Compose: Analyze the XML code and translate each XML element and its attributes to the equivalent Jetpack Compose code. For example, if you have a TextView in XML, you would replace it with a Text composable function in Jetpack Compose.
4. Refactor Layouts: XML-based layouts often use LinearLayout, RelativeLayout, or ConstraintLayout for positioning UI elements. In Jetpack Compose, you can use the powerful layout composable functions like Column, Row, and Box to achieve the desired layout. Refactor your layout code accordingly.
5. Handle Styling: XML-based UI often relies on styles and themes for consistent styling. In Jetpack Compose, you can use the Material Design Components library to apply styles and themes. Refactor your styling code to use the appropriate Compose functions and APIs.
6. Migrate Business Logic: Along with the UI code, you’ll also need to migrate any associated business logic. This could include event handling, data binding, or any other logic related to the UI. Update your code to use the Jetpack Compose equivalents, such as using onClick instead of onClickListener for handling click events.
7. Gradual Migration: Consider adopting a gradual migration approach. Instead of migrating all screens at once, you can start by migrating individual screens or components and gradually expand the migration. This allows you to validate the changes, adapt to the new workflow, and measure the impact before fully migrating your entire application.

Best Practices

Here are some best practices to keep in mind during the migration process:

• Start with Small Screens - Begin the migration process with smaller, less complex screens or components. This will help you learn and understand the Compose syntax and concepts before moving on to more complex parts of your application.
• Refactor Incrementally - Instead of rewriting your entire XML-based UI codebase, refactor and migrate sections incrementally. This ensures that your app remains functional during the migration and reduces the chances of introducing bugs.
• Leverage Compatibility Libraries - Jetpack Compose provides compatibility libraries that allow you to use Compose alongside your existing XML-based UI code. You can gradually start using Compose in existing activities or fragments before fully migrating them.
• Validate and Test - Thoroughly test and validate your migrated screens or components to ensure they are visually and functionally equivalent to the XML-based UI. Writing unit tests and UI tests for your Compose code is crucial to catch any potential issues.

Common Challenges

Migrating from XML-based UI to Jetpack Compose can come with its fair share of challenges. Here are a few common challenges you might encounter:

• Learning Curve - Jetpack Compose introduces a new syntax and concept. It takes time to get familiar with the Compose way of building UI, especially if you are coming from an XML-based UI background.
• Interoperability with Existing Code - Integrating Jetpack Compose with existing XML-based UI code can be challenging. You might need to find workarounds or use compatibility libraries to bridge the gap between the two approaches.
• Integrating with 3rd Party Libraries - Some 3rd party libraries might not have built-in support for Jetpack Compose. You might need to find alternative libraries or write custom wrappers to integrate them seamlessly.
• Limited Documentation and Resources - Since Jetpack Compose is still relatively new, you might find limited documentation and resources compared to XML-based UI. However, the Jetpack Compose documentation and community are continuously growing.

Additional Information

Jetpack Compose official documentation

Migrating an app to use Jetpack Compose

Material Design Components for Jetpack Compose

Jetpack Compose Samples GitHub repository

sendTransaction is a method that is used to send transactions on the public Ethereum network. It is a standard method that is available in all Ethereum clients and is used to send transactions from one public account to another public account. The transaction details, such as sender address, recipient address, transaction amount, gas price, and gas limit, are publicly visible on the blockchain.

On the other hand, eth_sendPrivateTransaction is a method that is used to send private transactions on a private Ethereum network. Private networks are typically used in enterprise settings where transactions need to be kept confidential. The transaction details, including the smart contract code, are visible only to the parties involved in the transaction. This is achieved using private contracts and private transactions that are only visible to a subset of nodes on the private Ethereum network.

eth_sendPrivateTransaction is relevant because it provides a way for enterprises to use the Ethereum blockchain to conduct business in a private and secure manner. By keeping transactions confidential, companies can protect their proprietary information and maintain the privacy of their customers. Additionally, private Ethereum networks can provide faster transaction times and lower transaction costs than the public Ethereum network.

Private Ethereum networks are important because they allow organizations to take advantage of the benefits of blockchain technology while tailoring the network to their specific needs. By offering greater privacy, customization, control, scalability, and cost-effectiveness, private Ethereum networks are an excellent choice for businesses looking to leverage blockchain technology to achieve their strategic goals.

The future of gaming in the world of cryptocurrency is an exciting and rapidly evolving space. As the use of cryptocurrency and blockchain technology continues to grow and gain mainstream acceptance, it’s likely that we’ll see more and more game developers integrating these technologies into their products.

One potential use for cryptocurrency in gaming is as a means of in-game currency. In many games, players can earn or purchase virtual currency that can be used to buy in-game items or unlock new content. By using cryptocurrency as the medium of exchange, players could potentially buy and sell these virtual items on external marketplaces, potentially even making real-world profits from their in-game activities.

Another possibility is the use of cryptocurrency and blockchain technology to enable cross-game item interoperability. Currently, items and currency earned in one game are often not transferable to other games. By using blockchain technology to create a shared, decentralized ledger of in-game items, players could potentially take their hard-earned virtual items with them from game to game, creating a more immersive and persistent gaming experience.

In addition to these potential uses, we could also see the emergence of entirely new types of games built on blockchain technology. For example, some developers are already working on creating blockchain-based games that use non-fungible tokens (NFTs) to represent unique in-game items or assets. These NFTs could potentially be bought, sold, and traded on external marketplaces, adding a whole new level of value and ownership to in-game items.

Type Inference

Type inference is a feature that allows the Kotlin compiler to infer the type of a variable or expression based on the context in which it is used. This means that you don’t always have to specify the type explicitly, and the compiler will fill it in for you.

For example, consider the following code:

val x = 1
val y = 2
val z = x + y

In this code, the variables x, y, and z are all inferred to be of type Int, because they are all assigned integer values. This is convenient because it saves you from having to specify the type explicitly, and it also makes the code more readable because it is less cluttered with type annotations.

Type inference can also be used with generic types. For example, consider the following code:

val list = listOf(1, 2, 3)

Here, the type of the list variable is inferred to be List, because it is assigned a list of integers.

Inline Functions

In Kotlin, you can use the inline keyword to annotate a function as inline. This means that the function will be inlined at the call site, which can improve the performance of your code by avoiding the overhead of function calls.

For example, consider the following code:

inline fun foo(block: () -> Unit) {
    println("Before")
    block()
    println("After")
}

foo {
    println("Inside")
}

In this code, the foo function is annotated as inline, which means that the code inside the function will be inlined at the call site. The output of this code will be:

Before
Inside
After

Inlining functions can be especially useful when working with higher-order functions, which we will discuss next.

Higher-Order Functions

A higher-order function is a function that takes one or more functions as arguments or returns a function as a result. Kotlin has excellent support for higher-order functions, which can be used to write concise and expressive code.

For example, consider the following code:

fun foo(list: List<Int>, predicate: (Int) -> Boolean): List<Int> {
    return list.filter(predicate)
}

val result = foo(listOf(1, 2, 3, 4, 5), { it % 2 == 0 })

In this code, the foo function is a higher-order function because it takes a function (predicate) as an argument. The predicate function is a lambda expression that takes an Int and returns a Boolean. The foo function uses the filter higher-order function to filter the list based on the predicate.

Higher-order functions can be used in combination with inline functions to write even more concise and expressive code. For example, consider the following code:

inline fun <T> Iterable<T

First, let’s define what collections are in Jetpack Compose. Collections are simply groups of data that can be iterated over and manipulated. This can include lists, sets, and maps. In Jetpack Compose, you can use collections to build UI elements that display multiple items, such as lists or grids.

One of the most useful ways to work with collections in Jetpack Compose is through the use of the @Composable function For. This function allows you to iterate over a collection and build a UI element for each item in the collection. For example, you could use For to build a list of items like this:

@Composable

fun MyList(items: List<Item>) {
    Column {
        For(items) { item ->
            Text(text = item.name)
        }
    }
}

This will create a Text element for each item in the items list, displaying the name property of each Item.

There are a few best practices to keep in mind when using collections in Jetpack Compose. Firstly, try to minimize the number of times you iterate over a collection. This can help improve the performance of your app, as each iteration can take time. Secondly, be mindful of the size of your collections. Large collections can lead to slower rendering times, so try to keep your collections as small as possible.

In summary, collections in Jetpack Compose are groups of data that can be iterated over and manipulated to build UI elements. The For function is a useful tool for working with collections, and it’s important to keep performance in mind when using them. By following these best practices, you can effectively use collections in your Jetpack Compose projects to build dynamic and efficient UI elements.

Blockchain technology has the potential to revolutionize supply chain management by providing a decentralized, transparent, and secure platform for managing and tracking the flow of goods and services. Here are some key ways that blockchain can improve supply chain management:

Increased transparency: Blockchain allows for the creation of a shared, immutable record of transactions that can be accessed by all stakeholders in the supply chain. This increased transparency can help to reduce fraud and errors, and improve trust and collaboration between partners.

Improved traceability: With blockchain, it is possible to track the movement of goods from the point of origin to the final destination. This can help to improve the efficiency and accuracy of the supply chain, and reduce the risk of counterfeiting or other types of fraud.

Enhanced security: Blockchain provides a secure and decentralized platform for storing and sharing data, making it difficult for hackers to access or alter information. This can help to protect sensitive data and reduce the risk of data breaches.

Improved efficiency: By automating many of the processes involved in supply chain management, blockchain technology can help to streamline operations and reduce the need for manual intervention. This can lead to cost savings and improved efficiency.

In conclusion, blockchain technology has the potential to significantly improve supply chain management by increasing transparency, improving traceability, enhancing security, and improving efficiency. As more and more businesses adopt blockchain technology, it is likely that we will see a transformation in the way supply chains are managed and operated.

One of the main challenges facing Ethereum governance is balancing the needs of the different stakeholders involved. This includes developers, users, investors, and the Ethereum Foundation itself. Ensuring that the needs of all of these groups are taken into account can be difficult, and it requires ongoing communication and collaboration to ensure that the platform is able to meet the needs of all of these groups.

Another challenge is ensuring that the Ethereum governance process is transparent and accountable. This is especially important given the decentralized nature of the platform, as it is critical that all stakeholders have the ability to have their voices heard and their concerns addressed.

One way that Ethereum is addressing these challenges is through the use of voting mechanisms, such as the ECF, which allow for more democratic decision-making processes. In addition, the Ethereum Foundation has implemented a number of transparency initiatives, such as open meetings and the creation of a transparency portal, to ensure that stakeholders are able to stay informed about the latest developments and decisions being made within the Ethereum community.

Despite these challenges, Ethereum governance has been largely successful in ensuring that the platform is able to adapt and evolve over time. It has been able to successfully navigate significant challenges, such as the DAO hack, and has continued to grow and thrive as a result.

One key best practice for Ethereum development is to use a modular architecture. This involves breaking down the dApp into smaller, more manageable components that can be tested and developed independently. This not only makes the development process more efficient, but it also makes it easier to identify and fix issues.

Another important best practice is to use version control systems such as Git to track changes to the dApp’s codebase. This allows developers to easily revert to previous versions if necessary and collaborate with other team members.

Design patterns are also essential for Ethereum development. One commonly used pattern is the factory pattern, which allows developers to create new instances of a contract without having to hardcode its address. This is useful for deploying contracts to different networks or for testing purposes.

Another useful design pattern is the upgradable contract pattern, which allows developers to make changes to a contract without having to deploy a new version. This is particularly useful for bug fixes or feature updates, as it avoids the need to migrate users to a new contract.

Overall, adhering to best practices and utilizing design patterns can help ensure the success of an Ethereum dApp. By following these guidelines, developers can create more efficient and secure dApps that are better able to meet the needs of users.

There are several different types of consensus mechanisms, each with its own strengths and weaknesses. Here are some of the most common ones:

Proof of Work (PoW)

Proof of Work is the consensus mechanism that is used by the Bitcoin blockchain. It works by requiring participants (miners) to solve complex mathematical puzzles in order to validate transactions and add them to the blockchain. The first miner to solve the puzzle gets to add the block to the chain and is rewarded with a small amount of cryptocurrency.

Proof of Stake (PoS)

Proof of Stake is a consensus mechanism that uses a different approach to validate transactions. Instead of requiring miners to solve complex puzzles, it relies on a group of validators who are chosen based on the amount of cryptocurrency they hold (their stake). The more cryptocurrency a validator has, the more likely they are to be chosen to validate a transaction. This system is less resource-intensive than Proof of Work, but it has its own set of potential problems, such as the potential for validators with a large stake to dominate the process.

Delegated Proof of Stake (DPoS)

Delegated Proof of Stake is a variation of Proof of Stake that involves a group of elected representatives who are responsible for validating transactions. The representatives are chosen by the network participants through a voting process. This system is meant to be more democratic and efficient than Proof of Work, but it has faced criticism for being susceptible to centralization and bribery.

Federated Byzantine Agreement (FBA)

Federated Byzantine Agreement is a consensus mechanism that is used by the Stellar blockchain. It works by having a group of trusted nodes (called validators) that are responsible for verifying transactions. The validators reach consensus by communicating with each other and agreeing on the validity of the transaction. This system is faster and more efficient than Proof of Work, but it relies on the trustworthiness of the validators.

Proof of Authority (PoA)

Proof of Authority is a consensus mechanism that is used by private blockchains or those that require a high level of security. It works by having a group of trusted individuals or organizations (called validators) that are responsible for verifying transactions. This system is more efficient and secure than Proof of Work, but it relies on the trustworthiness and integrity of the validators.

Consensus mechanisms are an important part of any decentralized system, as they ensure that the network is secure, efficient, and fair. It’s important to carefully consider the pros and cons of different consensus mechanisms before choosing one for your project.

Chainlink is a decentralized network of nodes that provide data and information from off-blockchain sources to on-blockchain smart contracts via oracles

Chainlink greatly expands the capabilities of smart contracts by enabling access to real-world data and off-chain computation while maintaining the security and reliability guarantees inherent to blockchain technology.

This tutorial will be based on this repo and we will use Truffle – a development environment, testing framework and asset pipeline for Ethereum

Prerequisite

1. Install NodeJS
2. Install Truffle: npm install -g truffle
3. Install Metamask
4. Install Ganache
5. Install VSCode
6. Install Solidity Plugin

Hands on: Truffle + Chainlink

npm install --global yarn

mkdir Chainlink

cd Chainlink

truffle unbox smartcontractkit/box

yarn

Running tests Run Ganache or enable/integrate Kovan testnet npm test

All tests of /test will be executed. There are tests about creating requests with and without Link tokens, sending these requests to oracle contract addresses, and testing contract ownership.

Note You must acquire some LINK for interact with you smart contract. Get some LINK via Chainlink Kovan Faucet website 🤑 🤑 🤑

Ganache deployment

truffle migrate --network ganache --reset

Kovan deployment

1. Setup Metamask and connect to Kovan network
2. Faucet: faucet.kovan.network
3. Create account and a project using Infura.io – step-by-step tutorial
4. Infura setup and “env.sample” file configuration

truffle migrate --network kovan --reset

Helper scripts

Scripts to interact with deployed smart contract without any frontend implementation:

1. fund-contract.js

npx truffle exec scripts/fund-contract.js --network kovan

1. request-data.js

npx truffle exec scripts/request-data.js --network kovan

1. read-contract.js

npx truffle exec scripts/read-contract.js --network kovan

● fund-contract.js

➢ Send 1 LINK to requesting contract

● request-data.js

➢ Chainlink request to be created from the requesting contract

● read-contract.js

➢ Read the data variable of the requesting contract (current price of pair ETH/USD)

Additional Information

Chainlink docs

Chainlink official website

Truffle Starter kit impl

Code a REAL WORLD dApp with Chainlink - Ethereum, Solidity, Web3.js

What Is Chainlink in 5 Minutes

Blockchain’s inability to fetch reliable information from the real world

● Huge vulnerability in decentralized applications when Blockchain wants to take advantage of off-chain data

● Origins of data are also the points where data can be manipulated, compromised, or simply falsified

● Chainlink started on Ethereum but it’s also available on Polkadot, Hyperledger, etc…

Chainlink

Decentralized network of nodes that provide data and information from off-blockchain sources to on-blockchain smart contracts via oracles. LINK is built on Ethereum in accordance with the ERC-20 standard for tokens

❏ Sep 2017 – Chainlink raises $32 million in an ICO creating 1 billion LINK tokens

❏ Nov 2018 – Chainlink acquires TownCrier

❏ May 2019 – Chainlink is launched on Ethereum mainnet

❏ May 2021 – Chainlink 2.0 whitepaper

The Chainlink’s oracle

Oracle – Middleware that acts as an intermediary, translating data from the real world to smart contracts on the blockchain and back again

Chainlink – Decentralized network of nodes that provide data and information from off-blockchain sources to on-blockchain smart contracts via oracles

🥇 Market standard for decentralized oracles

✅ Enhance and extend the capabilities of smart contracts on a target blockchain through functions that are not available natively

✅ To minimize the potential failure of oracles: Distribution of data sources, Distribution of oracles and Use of trusted hardware

✅ The Chainlink Reputation Contract

Chainlink 2.0

Chainlink 2.0: Next Steps in the Evolution of Decentralized Oracle Networks

Oracle networks go far beyond delivering highly validated data, they provide the various decentralized
services that are combined with smart contracts to create real world outcomes. These hybrid smart
contracts are already redefining our industry as DeFi.

🔥 Hybrid Smart Contracts that are seamlessly connected to all necessary off-chain resources, while retaining increased levels of privacy and being secured

🔥 New “architecture” enables more advanced off-chain computation

🔥 Increase number of services since ecosystem is more flexible and enhance its capabilities. Chainlink is the future of DeFi

Glossary

ERC-20: technical standard used to issue and implement tokens on the Ethereum blockchain. It makes easier for developers to predict with more accuracy the interaction between different tokens and applications

Faucet: website that distributes small amounts of crypto

ICO: An Initial coin offering occurs when company looking to raise money to create a new coin, app, or service launches an ICO as a way to raise funds. Similar to an IPO

Middleware: software that acts as a bridge between an operating system or database and applications, especially on a network

Off-chain: Transactions which agree to happen outside the blockchain

On-chain: normally refer to as blockchain transactions which happens inside the blockchain

Additional Information

Top Oracles Tokens by Market Capitalization

77 Smart Contract Use Cases Enabled By Chainlink

Expanding Beyond Data Delivery With Chainlink 2.0

Solidity supports multiple inheritance including polymorphism. Inheritance is the process of defining multiple contracts that are related to each other through parent-child relationships. The contract that is inherited is called the parent contract and the contract that inherits is called the child contract.

When a contract inherits from other contracts, only a single contract is created on the blockchain, and the code from all the base contracts is compiled into the created contract. This means that all internal calls to functions of base contracts also just use internal function calls.

The benefits of using inheritance are: Ability to change one contract and have those modifications reflected in others, Reducement of dependency nad Ability to reuse existing code more.

Example of Inheritance

pragma solidity ^0.8.0;

contract Grandparent {
    function myFunction() public pure virtual returns (string memory) {
        return "Contract Grandparent";
    }
}

// Contracts inherit other contracts by using the keyword 'is'.
contract Parent is Grandparent {
    // Override Grandparent.myFunction()
    function myFunction() public pure virtual override returns (string memory) {
        return "Contract Parent";
    }
}

contract Uncle is Grandparent {
    // Override Grandparent.myFunction()
    function myFunction() public pure virtual override returns (string memory) {
        return "Contract Uncle";
    }
}

Note: Solidity copies the base contracts into the derived contract and a single contract is created with inheritance. A single address is generated that is shared between contracts in a parent-child relationship.

💡 Gotchas

• In the case of multiple inheritances, function calls using super gives preference to most derived contracts;
• There are different types of inheritances: Single, Multi-level, Multiple and Hierarchical;
• A derived contract can access all non-private members including state variables and internal methods. But using this is not allowed;
• We can call a super contract’s function using a super keyword or using a super contract name;

Additional Information

Inheritance in Solidity – Solidity docs

Mappings are declared using the mapping keyword followed by data types for both key and value separated by the => notation. Mappings have identifiers like any other data type and they can be used to access the mapping and can only have type of storage and are generally used for state variables. Solidity automatically creates a getter function for it.

Although it is similar to a hash table and dictionary, Solidity does not allow iterating through mapping. A value from mapping can be retrieved if the key is known. The next example illustrates working with mapping.

Another characteristic about mapping is the absence of iteration support but there are ways to work round this limitation. Notice that iterating and looping are an expensive operation in Ethereum in terms of gas usage and should generally be avoided.

💡 Gotchas

• Mappings do not have a length, nor do they have a concept of a key or a value being set
• It is also possible to have nested mapping, that is mapping consisting of mappings
• Mappings can only be used for state variables that act as storage reference types
• Mapping cannot be declared within functions as memory mappings
• When mappings are initialized every possible key exists in the mappings and are mapped to values whose byte-representations are all zeros

Additional Information

Types in Solidity – Solidity Docs v0.4.21

Every transaction on Ethereum Virtual Machine costs us some amount of Gas. The lower the Gas consumption the better is your Solidity code. The Gas consumption of Memory is not very significant as compared to the gas consumption of Storage. Therefore, it is always better to use Memory for intermediate calculations and store the final result in Storage.

State variables

The variable can be used at multiple places within code and they will all refer to the value stored within it. Solidity provides two types of variable: state and memory.

The default for function parameters (including return parameters of functions) is memory, the default for local variables is storage.

Storage

Persistent data is referred to as storage and is represented by state variables. These values get stored permanently on the blockchain. You need to declare the type so that the contract can keep track of how much storage on the blockchain it needs when it compiles.

Structure

Structures or structs helps implement custom user-defined data types. A structure is a composite data type, consisting of multiple variables of different data types. They are very similar to contracts; however, they do not contain any code within them. They consist of only variables.

Additional Information

ANATOMY OF SMART CONTRACTS by Ethereum.org

Solidity is a programming language targeting Ethereum Virtual Machine (EVM). Ethereum blockchain helps extend its functionality by writing and executing code known as smart contracts. Ethereum Virtual Machines have been successfully implemented in various programming languages including C++, Java, JavaScript, Python, Ruby, and many others.

EVM executes code that is part of smart contracts. Smart contracts are written in Solidity; however, EVM does not understand the high-level constructs of Solidity. EVM understands lower-level instructions called bytecode. Solidity code needs a compiler to take its code and convert it into bytecode that is understandable by EVM.

For every instruction implemented on the EVM, a system that keeps track of execution cost, assigns to the instruction an associated cost in Gas units (See our What is Gas? article). When a user wants to initiate an execution, they reserve some Ether, which they are willing to pay for this gas cost.

In order to facilitate Keccak-256 cryptographic hash scheme, the EVM is a stack-based architecture with a word size of 256-bits. This architecture also allows for the use of elliptic-curve cryptography in Ethereum’s signature scheme for validating the origin and integrity of transactions.

Additional Information

ETHEREUM VIRTUAL MACHINE (EVM) by Ethereum.org

In the end, they do the exact same thing: wait until a result is available from a long-running task and continue execution. However, in code they look very different.

The keyword suspend is Kotlin’s way of marking a function, or function type, available to coroutines. When a coroutine calls a function marked suspend, instead of blocking until that function returns like a normal function call, it suspends execution until the result is ready then it resumes where it left off with the result. While it’s suspended waiting for a result, it unblocks the thread that it’s running on so other functions or coroutines can run.

Note

The pattern of async and await in other languages is based on coroutines. If you're familiar with this pattern, the suspend keyword is similar to async. However in Kotlin, await() is implicit when calling a suspend function.

Scopes

All coroutines run inside a CoroutineScope. A scope controls the lifetime of coroutines through its job. When you cancel the job of a scope, it cancels all coroutines started in that scope. On Android, you can use a scope to cancel all running coroutines when, for example, the user navigates away from an Activity. Scopes also allow you to specify a default dispatcher. A dispatcher controls which thread runs a coroutine.

GlobalScope - Lifetime of the new coroutine is limited only by the lifetime of the whole application

CoroutineScope - Is destroyed after all launched children are completed

MainScope - Scope for UI applications and uses Dispatchers.Main

Note

Libraries like Room and Retrofit offer main-safety out of the box when using coroutines, so you don't need to manage threads to make network or database calls. This can often lead to substantially simpler code.

Channels

Channels are a way to communicate (transfer data) between coroutines similar to a blocking queue. It Uses send and receive for normal values, produce and consume for streams. Moreover, Channels can be closed to indicate no more elements are coming.

Exception handling

Coroutines will delegate uncaught exceptions to the system’s uncaught exception handler. On Android, the handler will output the exception and crash the app.

try {
    GlobalScope.launch {
        throw NullPointerException()
    }
} catch (e: Exception) {
    // Exceptions will never land here because `launch` propagates uncaught exceptions
    // to the default handler and will never pass them to the outer scope.
    System.err.println("Caught exception! $e")
}

Additional Information

Use Kotlin Coroutines in your Android App by Google

Android Kotlin Fundamentals 06.2: Coroutines and Room by Google

Understand Kotlin Coroutines on Android at Google/IO 19

Kotlin, as a language, provides only minimal low-level APIs in its standard library to enable various other libraries to utilize coroutines. Unlike many other languages with similar capabilities, async and await are not keywords in Kotlin and are not even part of its standard library. Moreover, Kotlin’s concept of suspending function provides a safer and less error-prone abstraction for asynchronous operations than futures and promises.

On Android, coroutines help to solve two primary problems:

• Manage long-running tasks that might otherwise block the main thread and cause your app to freeze.
• Providing main-safety, or safely calling network or disk operations from the main thread.

Get Started

Essentially, coroutines are light-weight threads. They are launched with launch coroutine builder in a context of some CoroutineScope. Here we are launching a new coroutine in the GlobalScope, meaning that the lifetime of the new coroutine is limited only by the lifetime of the whole application.

See this example:

import kotlinx.coroutines.*

fun main() {
    GlobalScope.launch { // launch a new coroutine
	delay(1000L) // non-blocking delay
	println("World!")
}

	println("Hello,") // main thread continues
	Thread.sleep(2000L) // block main thread
}

Coroutines allows us to mix blocking and non-blocking code in the same place. See the following example which has two delays. The first one is a non-blocking code inside a courotine and the second is blocking. Both work correctly once they are wrapped bt another courotine.

Note: Delaying for a time while another coroutine is working is not a good approach.

import kotlinx.coroutines.*

fun main() = runBlocking<Unit> { // start main coroutine
	GlobalScope.launch { // launch a new coroutine
	delay(1000L)
	println("World!")
}
    
	println("Hello,") // main coroutine continues
	delay(2000L)      // delaying
}

Designate a CoroutineScope

When defining a coroutine, you must also designate its coroutineScope. A coroutineScope manages one or more related coroutines. You can also use a coroutineScope to start a new coroutine within that scope. Unlike a dispatcher, however, a coroutineScope doesn’t run the coroutines.

One important function of coroutineScope is stopping coroutine execution when a user leaves a content area within your app. Using coroutineScope, you can ensure that any running operations stop correctly.

runBlocking and coroutineScope may look similar because they both wait for its body and all its children to complete. The main difference between these two is that the runBlocking method blocks the current thread for waiting, while coroutineScope just suspends, releasing the underlying thread for other usages. Because of that difference, runBlocking is a regular function and coroutineScope is a suspending function.

The current global financial system has proved to be inefficient in multiple aspects. With so many financial intermediaries present in the system, the users face countless security risks. According to CIODIVE, cyber criminals target financial services 300 times more than other sectors. PWC analysts claim that 45% of financial intermediaries such as money transfers and stock exchanges suffer from serious cyber crimes every year.

The growing number of cyber attacks leaves the public at risk of financial loss and data exploitation. The existing financial system deprives millions of people from basic financial services because of barriers such as location, wealth, and status.

A decentralized financial system based on a public blockchain would provide access to financial services to everyone, regardless of their location and status. Numerous startups and companies have recognized the potential of open source networks to change and decentralize economic activity. Networks such as Bitcoin and Ethereum could solve the issues of the traditional financial system because of their permissionless nature. Blockchain could replace the current financial system because it is permissionless, decentralized and transparent.

Here’s what all of this means:

• Blockchain is permissionless, which means that anyone in the world can connect to it. This kind of accessibility on a global level would solve the issue of inequality posed by the current centralized financial system.

• Blockchain is decentralized. This means that its records are kept scattered across thousands of devices. There is no centralized server or body of authority that controls the blockchain.

• Blockchain is completely transparent, since all transaction records are publicly auditable.

First Things First: Blockchain

With a blockchain, many people can write entries into a record of information, and a community of users can control how the record of information is amended and updated. Likewise, Wikipedia entries are not an article of a single publisher. No one person controls the information.

Blockchain is based on distributed ledger technology, which securely records information across a peer-to-peer network.

A distributed ledger is a database of transactions that is shared and synchronized across multiple computers and locations – without centralized control. Each party owns an identical copy of the record, which is automatically updated as soon as any additions are made. The distributed database created by blockchain technology has a fundamentally different digital backbone. This is also the most distinct and important feature of blockchain technology.

A blockchain records data across a peer-to-peer network. Every participant can see the data and verify or reject it using consensus algorithms. Approved data is entered into the ledger as a collection of “blocks” and stored in a chronological “chain” that cannot be altered.

Ethreum and the Smart Contracts

A smart contract is a set of computer code between two or more parties that run on the top of a blockchain and constitutes of a set of rules which are agreed upon by the involved parties. Upon execution, if these set of pre-defined rules are met, the smart contract executes itself to produce the output. This piece of code allows decentralized automation by facilitating, verifying, and enforcing the conditions of an underlying agreement.

The Ethereum blockchain enables more open, inclusive, and secure business networks, shared operating models, more efficient processes, reduced costs, and new products and services in banking and finance. It enables digital securities to be issued within shorter periods of time, at lower unit costs, with greater levels of customization.

1. Security: Its distributed consensus based architecture eliminates single points of failure and reduces the need for data intermediaries such as transfer agents, messaging system operators and inefficient monopolistic utilities. Ethereum also enables implementation of secure application code designed to be tamper-proof against fraud and malicious third parties— making it virtually impossible to hack or manipulate.
2. Transparency: It employs mutualized standards, protocols, and shared processes, acting as a single shared source of truth for network participants
3. Trust: Its transparent and immutable ledger makes it easy for different parties in a business network to collaborate, manage data, and reach agreements
4. Programmability: It supports the creation and execution of smart contracts— tamper proof, deterministic software that automates business logic – creating increased trust and efficiency
5. Privacy: It provides market-leading tools for granular data privacy across every layer of the software stack, allowing selective sharing of data in business networks. This dramatically improves transparency, trust and efficiency while maintaining privacy and confidentiality.
6. High-Performance: It’s private and hybrid networks are engineered to sustain hundreds of transactions per second and periodic surges in network activity
7. Scalability: It supports interoperability between private and public chains, offering each enterprise solution the global reach, tremendous resilience, and high integrity of the mainnet

The state of the art of main Decentralized Finance projects

• PAYMENTS

  • OmiseGO Interoperability and scaling solutions for payments over Ethereum

• STABLECOINS

  • Dai A USD-pegged stablecoin built on the Ethereum and governed by the MakerDAO system

  • Digix Physical gold with DGX tokens, where 1 DGX represents 1 gram of gold on Ethereum.

• INFRASTRUCTURE

  • 0x An open protocol for the peer-to-peer, decentralized exchange of digital assets

  • 0xcert Open source framework for creating, managing, and swapping NFTs and tokens

• EXCHANGES & LIQUIDITY

  • Bancor A decentralized liquidity network

  • Airswap Peer-to-peer trading on Ethereum

• INVESTMENT

  • Meridio A platform for fractional ownership shares in real estate assets

  • Polymath Network A platform for the creation of tokenized securities

• KYC & IDENTITY

  • uPort The open identity system for the decentralized web

  • Civic Secure blockchain identity toolbox and ecosystem

  • Sovrin Open source, self-sovereign identity network

• DERIVATIVES

  • dYdX Open-Source Protocols for decentralized margin trading and derivatives

  • bZx (b0x) A decentralized margin lending protocol on Ethereum

• MARKETPLACES

  • Gitcoin A marketplace for open source development work

  • OpenSea A peer to peer trading market for crypto collectibles and rare digital items

  • District0x A network of decentralized markets on Ethereum that operate via DAOs by utilizing Aragon

  • Ethlance A marketplace for freelance work in the Ethereum space

  • Origin A protocol for creating peer-to-peer marketplaces utilizing Ethereum and IPFS

• PREDICTION MARKETS

  • Augur Prediction market protocol built on Ethereum

  • Gnosis Open platform for creating prediction market applications on the Ethereum protocol

  • Helena Prediction markets platform for forecasting blockchain developments, events, and projects

• CREDIT & LENDING

  • SALT A lending and borrowing platform that allows users to leverage their crypto-assets to secure loans.

  • Dharma A suite of smart contracts and developer tools that make it possible to borrow and lend crypto-assets on blockchains like Ethereum

  • Compound Finance Open source protocol for algorithmic, efficient money markets on the Ethereum.

• INSURANCE

  • Etherisc A decentralized insurance protocol to collectively build risk transfer solutions

• CUSTODIAL SERVICES

  • MetaMask A browser extension that allows users to run Ethereum dApps

  • MyEtherWallet A free, open-source, client-side interface for generating Ethereum wallets and more

  • Trust Wallet Ethereum wallet and multi cryptocurrency wallet to store your favorite ERC721 & ERC20 tokens

• DE-FI DATA & ANALYTICS

  • Prediction Global Shows a list of all the markets on Augur.

  • Stablecoin Index Tracks and monitors the price, volume, and stability of stablecoins

  • Augur Leaderboard Number of trades and profits on Augur by ethereum address

• DECENTRALIZED FINANCE SOLUTIONS

  • Adhara A real-time gross settlement platform providing liquidity management and international payments for decentralized financial networks

  • Kaleido An all-in-one SaaS blockchain business cloud

References

• forbes - The Shift Toward Decentralized Finance: Why Are Financial Firms Turning To Crypto?
• coindesk - What is Blockchain Technology?
• consensys - Blockchain in Banking and Financial Services

Koin is a lightweight dependency injection library for Kotlin and written in pure Kotlin. using functional resolution only: no proxy, no code generation, no reflection. Koin is a DSL, using Kotlin’s DSLs, that describes your dependencies into modules and sub-modules. You describe your definitions with certain key functions that mean something in the Koin context.

In this article, we are going to pass through the basic steps to setup and take advantage of dependency injection with Koin for a simple project.

1. Setup

// Add Jcenter to your repositories if needed
repositories {
    jcenter()
}
dependencies {
    // Koin for Android
    implementation 'org.koin:koin-android:{revnumber}'
}

2. Declare a module

Defines those entities which will be injected in the app.

val appModule = module {
	single { DataRepository }
}

3. Use Application layer to initialize Koin injection

Trigger the DI process and indicate which modules will be available when needed

class BaseApplication : Application() {

  override fun onCreate() {
    super.onCreate()
    startKoin(this, appModule)
  }

}

4. Use the actual injection

class MainActivity : AppCompatActivity() {
  private val repository: DataRepository by inject()
  ...
}

This was the basic usage of koin which has much more power/features available in its framework. Another great Koin feature is the integration with the Architecture Component View Model. Koin has a specif project called koin-android-viewmodel project is dedicated to inject Android Architecture ViewModel.

Architecture Components with Koin: ViewModel

1. Setup

// Add Jcenter to your repositories if needed
repositories {
    jcenter()
}
dependencies {
    // ViewModel for Android
    implementation 'org.koin:koin-android-viewmodel:{revnumber}'
    // or ViewModel for AndroidX
    implementation 'org.koin:koin-androidx-viewmodel:{revnumber}'
}

2. Declare a module for your viewModule

val appModule = module {
    // ViewModel for News View with a dependency in its constructor
    viewModel { NewsViewModel(get()) }
}

3. Use the actual injection

class MainActivity() : AppCompatActivity() {

  // lazy inject MyViewModel
  val viewModel : NewsViewModel by viewModel()
}

Koin Key Functions

• module { } - create a Koin Module or a submodule (inside a module)
• factory { } - provide a factory bean definition
• single { } - provide a bean definition
• get() - resolve a component dependency
• bind - additional Kotlin type binding for given bean definition
• getProperty() - resolve a property

Futher Details

I highly recommend the official docs and the following articles: Koin - Simple Android DI and Ready for Koin 2.0 by Arnaud Giuliani

Google announced official support for the Kotlin language at Google I/O 2017. Many developers started migrating the code base away from Java and learning Kotlin on the way. We are going to discuss how you can go from Java to Kotlin and also talk about some tips about this process.

Getting started

The very easy/initial thing you could do: use the Android Studio IDE to starting the convertion:

In the IDE, go to Android Studio -> Code -> Convert Java File to Kotlin File: The converter is really nice, it is smart and does the most of job gracefully. However during the automated process the converter would choose not the most appropriate choice, so you must look into the code and figure out if the converter was right in all the scenarios. Probably the most interesting issue you may face is the nullability, because by default, all the converted object will be non-nullable and you will have to explicitly specified them to be nullable or change your logic. Another issue is about usage of android-annontations will most likely break. There is a shortcut to access the converter: CMD+SHFT+ALT+K or CTRL+SHIFT+ALT+K depending of your operational system.

Another option of converting the code is using the online tool try.kotlinlang. Access the URL https://try.kotlinlang.org and click on “Convert from Java”. In this way you can convert your project graduallly and observe all the changes clearly.

Things to keep in mind

Interoperability – Java and Kotlin work perfectly together. So don’t be afraid to add Kotlin code step by step, it’s not necessary to migrate all code to another language. Pitfalls –  Automatic conversions can also be dangerous to your project, there are some scenarios that you may face new bugs in your code, for example an unexpected nullability. Some code converted can be asserted as not null which in turn can lead to a NullPointerException. Usage of val and lateinit – the misusage of these can cause problems to your actual project. val is like Java final variable and it’s known as immutable in kotlin and can be initialized only single time. A misusage of this field is setting a variable would be changed somehow, for example, a variable inside your model which will be used in a parcelable or as response of networki request. Make the property nullable if it makes better sense and improves null safety. lateinit might be good if used properly but it has its cons as well. Don’t make it a replacement for NullPointerException.

Google Codelab “Refactoring to Kotlin”

Google offers a Codelab specifically for refactoring Java code to Kotlin. Besides this course provides a very interesting channel to learn more about Koltin, its features and concepts, this is the list of what you will learn in the codelab:

• Handling nullability
• Implementing singletons
• Data classes
• Handling strings
• Elvis operator
• Destructuring
• Properties and backing properties
• Default arguments and named parameters
• Working with collections
• Extension functions
• Top-level functions and parameters
• let, apply, with, and run keywords

Check the codelab versions in Chinese and Brazilian Portuguese.

Dependency Injection (DI) is a design pattern that removes the dependency from the programming code so that it can be easy to manage and test the application. Dependency Injection makes our programming code loosely coupled. DI allows classes to define their dependencies without constructing them. At runtime, another class is responsible for providing these dependencies.

Problems of Dependency There are mainly two problems of dependency lookup:

• The dependency lookup approach makes the code tightly coupled. If resource is changed, we need to perform a lot of modification in the code.

• Not easy for testing This approach creates a lot of problems while testing the application especially in black box testing.

Dagger 2

Dagger 2 automatically constructs objects by walking the dependency tree, and it provides compile-time guarantees on dependencies. Dagger 2 is also recommended by Android team.

Dagger 2 uses the following annotations:

@Module and @Provides: define classes and methods which provide dependencies. @Module are responsible for providing objects which can be injected. Such classes can define methods annotated with @Provides. The returned objects from these methods are available for dependency injection.

@Inject: requests the dependencies. In other words, this annotation will let Dagger knows what the dependencies it is needed to be used by the dependant. Can be used on a constructor, a field, or a method.

@Component: enables selected modules and used for performing dependency injection.

Further Details

The Future of Dependency Injection with Dagger 2 by Jake Wharton DAGGER 2 - A New Type of dependency injection

ERC20 is a standard which defines a common list of rules that an Ethereum token has to implement, giving developers the ability to program how new tokens will function within the Ethereum ecosystem. ERC20 defines how the tokens are transferred between addresses and how data within each token is accessed.

The ERC777 token standard specifies an improvement of ERC20 while remaining backward compatible. It defines advanced features to interact with tokens. Namely, operators to send tokens on behalf of another address—contract or regular account—and send/receive hooks to offer token holders more control over their tokens.

ERC777 in a nutshell

Transactions – Let’s talk about of the most interesting features that this new standard is bringing to the world. ERC777 has a function called send() consists in having a transaction with an amount field and a data bit field. Thus the parameters can be freely selected again by the token user and the token operator in order to forward data to the recipient.

function send(address to, uint256 amount, bytes calldata data) external;
    function operatorSend(
        address from,
        address to,
        uint256 amount,
        bytes calldata data,
        bytes calldata operatorData
    ) external;

Burning Tokens – ERC777 provides a feature called “Burning tokens”. It is the act of destroying existing tokens that explicitly defines two functions to burn tokens (burn and operatorBurn). These functions facilitate the integration of the burning process in wallets and dapps. However, the token contract may prevent some or all holders from burning tokens for any reason. The token contract may also define other functions to burn tokens.

Backward Compatibility – The standard does not use transfer and transferFrom and uses send and operatorSend to avoid confusion and mistakes when deciphering which token standard is being used. Besides, ERC777 allows the implementation of ERC20 functions transfer, transferFrom, approve and allowance alongside to make a token fully compatible with ERC20.

Reference Implementation - getting started

I would suggest two references:

1. 0xjac
2. OpenZeppelin

0xjac

This repository contains all reference implementation and all tests. The reference implementation is also available via npm. In order to use it, you can download and setup the npm in your machine, access the npm website to see the instructions.

After the npm configuration, install the erc777 with:

npm install erc777

OpenZeppelin

OpenZeppelin is an open framework of reusable and secure smart contracts in the Solidity. It provides implementations of standards like ERC20, ERC721 and now ERC777 too. The project started providing ERC777 after implementing the issue-1159.

In this contract ERC777.sol, we can see how the ERC777 implementation are being organized. The contract implements the interface IERC777 and IERC20, it is possible to safely interact with ERC22 and ERC777 while all the events are emitted during the interactions.

In order to use the OpenZeppelin implementation in your project, you can download and setup the npm in your machine, access the npm website to see the instructions.

After the npm configuration, install the openzeppelin with:

npm install openzeppelin-solidity

Further details

See ERC777: a New Advanced Token Standard by Jordi Baylina, ERC777’s author, along Jacques Dafflon and Thomas Shababi

Every Android app has a main thread which is in charge of handling UI (including measuring and drawing views), coordinating user interactions, and receiving lifecycle events. If there is too much work happening on this thread, the app appears to hang or slow down, leading to an undesirable user experience. Any long-running computations and operations such as decoding a bitmap, accessing the disk, or performing network requests should be done on a separate background thread.

Applications may also require some tasks to run even when the user is not actively using the app such as syncing periodically with a backend server or fetching new content within an app on a periodic basis. Applications may also require services to run immediately to completion even after the user has completed interacting with the app. Google created a guide called Guide to background processing which determines which solution best meets your needs for these use cases.

Diagram from Modern background execution in Android

WorkManager

Title WorkManager is part of Android Jetpack and an Architecture Component for background work that needs a combination of opportunistic and guaranteed execution. Opportunistic execution means that WorkManager will do your background work as soon as it can. Guaranteed execution means that WorkManager will take care of the logic to start your work under a variety of situations, even if you navigate away from your app.

WorkManager is a simple, but incredibly flexible library that has many additional benefits. These include:

1. Support for both asynchronous one-off and periodic tasks
2. Support for constraints such as network conditions, storage space, and charging status
3. Chaining of complex work requests, including running work in parallel
4. Output from one work request used as input for the next
5. Handles API level compatibility back to API level 14(see note)
6. Works with or without Google Play services
7. Follows system health best practices
8. LiveData support to easily display work request state in UI

Get started

Add the WorkManager dependency in Java or Kotlin to your Android project by openning the build.gradle file for your project and add the google() repository as shown below:

allprojects {
    repositories {
        google()
        jcenter()
    }
}

Add the dependencies for the artifacts you need in the build.gradle file for your app or module. Currently you are able to add AndroidX dependencies or legacy Pre-AndroidX dependencies, so please choose the dependence what fit your project. Remember you can also add the $work_version into your gradle.build (project scope).

dependencies {
	def work_version = "2.0.1"

 	// (Java only)
	implementation "androidx.work:work-runtime:$work_version"

	// Kotlin + coroutines
	implementation "androidx.work:work-runtime-ktx:$work_version"
    
	// optional - RxJava2 support
	implementation "androidx.work:work-rxjava2:$work_version"
	// optional - Test helpers
	androidTestImplementation "androidx.work:work-testing:$work_version"
}

By default, WorkManager is initialized using a ContentProvider with a default Configuration. ContentProviders are created and run before the Application object, so this allows the WorkManager singleton to be setup before your code can run in most cases. This is suitable for most developers. However, you can provide a custom Configuration by using Configuration.Provider or initialize(android.content.Context, androidx.work.Configuration).

WorkManager BroadcastReceivers to monitor Constraints on devices before API 23. The BroadcastReceivers are disabled on API 23 and up. In particular, WorkManager listens to the following Intents:

android.intent.action.ACTION_POWER_CONNECTED
android.intent.action.ACTION_POWER_DISCONNECTED
android.intent.action.BATTERY_OKAY
android.intent.action.BATTERY_LOW
android.intent.action.DEVICE_STORAGE_LOW
android.intent.action.DEVICE_STORAGE_OK
android.net.conn.CONNECTIVITY_CHANGE

In addition, WorkManager listens to system time changes and reboots to properly reschedule work in certain situations. For this, it listens to the following Intents:

android.intent.action.BOOT_COMPLETED
android.intent.action.TIME_SET
android.intent.action.TIMEZONE_CHANGED

WorkManager uses the following permissions:

android.permission.WAKE_LOCK to make //it can keep the device awake to complete work before API 23
android.permission.ACCESS_NETWORK_STATE //to listen to network changes before API 23 and monitor network Constraints
android.permission.RECEIVE_BOOT_COMPLETED //to listen to reboots and reschedule work properly.

Note that WorkManager may enable or disable some of its BroadcastReceivers at runtime as needed. This has the side-effect of the system sending ACTION_PACKAGE_CHANGED broadcasts to your app. Please be aware of this use case and architect your app appropriately.

Further Details

Watch the full session: WorkManager — Android Jetpack (YouTube)

Lifecycle-aware components perform actions in response to a change in the lifecycle status of another component, such as activities and fragments. These components help you produce better-organized, and often lighter-weight code, that is easier to maintain.

A common pattern is to implement the actions of the dependent components in the lifecycle methods of activities and fragments. However, this pattern leads to a poor organization of the code and to the proliferation of errors. By using lifecycle-aware components, you can move the code of dependent components out of the lifecycle methods and into the components themselves.

Components

ViewModel - provides a way to create and retrieve objects that are bound to a specific lifecycle. A ViewModel typically stores the state of a view’s data and communicates with other components, such as data repositories or the domain layer which handles business logic. To read an introductory guide to this topic, see ViewModel.

LifecycleOwner/LifecycleRegistryOwner - both LifecycleOwner and LifecycleRegistryOwner are interfaces that are implemented in the AppCompatActivity and Support Fragment classes. You can subscribe other components to owner objects which implement these interfaces, to observe changes to the lifecycle of the owner. To read an introductory guide to this topic, see Handling Lifecycles.

LiveData - allows you to observe changes to data across multiple components of your app without creating explicit, rigid dependency paths between them. LiveData respects the complex lifecycles of your app components, including activities, fragments, services, or any LifecycleOwner defined in your app. LiveData manages observer subscriptions by pausing subscriptions to stopped LifecycleOwner objects, and cancelling subscriptions to LifecycleOwner objects that are finished. To read an introductory guide to this topic, see LiveData.

Lifecycle

Lifecycle is a class that holds the information about the lifecycle state of a component (like an activity or a fragment) and allows other objects to observe this state. Lifecycle uses two main enumerations to track the lifecycle status for its associated component:

Event – The lifecycle events that are dispatched from the framework and the Lifecycle class. These events map to the callback events in activities and fragments. State – The current state of the component tracked by the Lifecycle object.

LifecycleOwner

LifecycleOwner is a single method interface that denotes that the class has a Lifecycle. It has one method, getLifecycle(), which must be implemented by the class. If you’re trying to manage the lifecycle of a whole application process instead, see ProcessLifecycleOwner.

This interface abstracts the ownership of a Lifecycle from individual classes, such as Fragment and AppCompatActivity, and allows writing components that work with them. Any custom application class can implement the LifecycleOwner interface.

Components that implement LifecycleObserver work seamlessly with components that implement LifecycleOwner because an owner can provide a lifecycle, which an observer can register to watch.

Get Started

First thing we need to do is to enable the Data Binding library in yout project. So modify your build.gradle (app module context) and add the following code:

android {
...
     dataBinding {
   	enabled true
	}
}

Sync your project and now you are able to convert or create a layout to a Data Binding layout. You must wrap your layout with a <layout> tag and optionally use the tags data, variables and expressions. You can also automatically convert a regular layout to Data Binding using the Android Studio by right-clicking the parent layout tag and selecting “Convert data binding layout”.

Example of usage 1

<layout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools">
	<data>

  	<variable
      	name="viewmodel"
      	type="com.android.databinding.viewmodels.MyExampleViewModel"/>

		<variable name="funds" type="Integer"/>

	</data>

	<androidx.constraintlayout.widget.ConstraintLayout
       android:layout_width="match_parent"
       android:layout_height="match_parent">

.....

	</androidx.constraintlayout.widget.ConstraintLayout
</layout>

Layout variables are used to write layout expressions which are placed in the value of element attributes and they use the @{expression} format. See the following example:

Example of usage 2

<ImageView
	android:id="@+id/imageView"
	android:layout_width="wrap_content"
	android:layout_height="wrap_content"
	android:visibility="@{funds < 0 ? View.GONE : View.VISIBLE}"/>

Observing data

Instead of explicitly updating the UI when values changes, you can use [observables] to automatically updates the UI. In this way, another Architecture component of Android Jetpack library is recommended: LiveData.

Let’s discuss about only the observables and data binding works since this article is only explanning about Data Binding. When an observable value changes, the UI elements it’s bound to are updated automatically.

Use can freely interact with your data using DataBindingUtil. See the following example and notice DataBinding will auto-generate a class for you. In the Example, the class generated was MainActivityBinding because our original layout did not specify a name for the class so DataBinding simply used the name of the layout file and add word ‘Binding’ in the end:

main_activity.xml -> MainActivity + Binding -> MainActivityBinding

Example of usage 3

override fun onCreate(savedInstanceState: Bundle?) {
  super.onCreate(savedInstanceState)

  val binding : MainActivityBinding =
  DataBindingUtil.setContentView(this, R.layout.main_activity)

  	binding.viewmodel = viewModel
}

More details

I recommend you to watch this amazing tutorial presented by Dan Galpin: Level up with Data Binding and simplify your Android coding

Fungible Tokens and Non Fungible Tokens

Fungibility is important in the world of blockchain and cryptocurrency. It is desired for any currency, traditional or digital, since most currencies aim to be an interchangeable asset. A token can be exchanged for any other token of the same value. For example, One US dollar currency can be changed for another US dollar currency without any difference to the user.

On the other hand, Non-Fungible Token can’t be exchanged for any other NFT, because it has a unique and non-interchangeable behavior. These characteristics make them different from each other and digitally scarce. It is possible to create an analogy of NFTs with opera show tickets. Although the tickets are for the same show and everyone will listen to the same songs, each ticket has an identifier, buyer’s name and seat number. They are not easily transferable because each ticket has its value in a unique way.

In the Ethereum network, there are popular patterns that have been specified by the community itself. Each standard is known as ERC which stands for Ethereum Request for Comments. It defines methods, technology, behaviors for a particular functionality in Ethereum and it is submitted either for peer review.

ERC-1155

ERC-1155 is a standard for contracts that manage any combination of fungible tokens and non-fungible tokens.

Let’s talk about how the management works in every mentioned pattern in this article. Each ERC-20 token is required to be deployed in separate contracts. In case of ERC-721, this requires a single contract for managing a group of non-fungible tokens. However ERC-1155 works differently, it can handle any fungible and non-Fungible tokens in a single contract. This allows control of multiple tokens with different types in the same deployed contract.

As a result, the pattern avoids tons of repetitive code circulating the several contracts in the Ethereum ecosystem and saving significant storage space and gas costs.

What is special about ERC1155?

The new standard is a powerful tool that joins fungible tokens that have been widely accepted (list of ERC-20 tokens) to the non-fungible tokens that are popularizing themselves (list of NFT tokens).

In addition, the interface ERC-1155 provides ways to make transactions more efficient. The interface defines the function “safeBatchTransferFrom” to group multiple tokens and enable atomic swaps. In other words, the interface allows multiple complex operations in a single transaction. This procedure is quite simple and does not involve complex implementation.

Backwards Compatibility is another feature of the standard. It is compatible with ERC-721 and ERC-20 which can be inherited without any issue. ERC-1155 allows smart contracts to reference other contracts’ storage whenever it necessary. In this way, it avoids duplicating of code or misuse of storage by smart contracts. As a result, it improves the efficiency of the Ethereum ecosystem.

Continuous Integration aka CI is a development practice that requires developers to integrate code into a shared repository several times a day. Each check-in is then verified by an automated build, allowing teams to detect problems early. By integrating regularly, you can detect errors quickly, and locate them more easily and not integrating continuously you will have longer periods between integrations. This makes it exponentially more difficult to find and fix problems. Such integration problems can easily knock a project off-schedule, or cause it to fail altogether.

Travis CI

Using Travis CI, the users can easily sync Github projects and test the code test the code in minutes. Travis CI can be configured to run the tests on a range of different machines, with different software installed (such as older versions of a programming language implementation, to test for compatibility), and supports building software in numerous languages, including C, C++, C#, Clojure, D, Erlang, F#, Go, Apache Groovy, Haskell, Java, JavaScript, Julia, Perl, PHP, Python, R, Ruby, Rust, Scala and Visual Basic. Several high-profile open source projects are using it to run builds and tests on every commit, such as Plone, Ruby on Rails, and Ruby.[8][9

Truffle with Travis CI

Firstly, as prerequisite you should follow the Travis CI docs in order to integrate your Github project with Travis. Then add the following chunk of code into your .travis.yml:

View the full .travis.yml snippet on GitHub Gist.

In this script, we are selecting nodeJs version 8.11.3 with latest version of Node package manager (npm). Ganache (old testRPC) and truffle are also installed. The trigger mechanisms starts with ganache initialization and the truffle command truffle test. In other words, the code will be compiled and the tests will ran too.

This Realtime Database (RTDB) is highly integrated with Firebase platform, including Google’s Cloud Functions serverless platforms. Besides Firestore was designed for making it easier for developers to build offline apps with the help of a local database for web, iOS and Android and to easily sync data between different apps and users in real time.

Features

Designed for scaling – Cloud Firestore delivers the best of the Google Cloud platform;

Offline Support – Write, read, examine, and query data, even if the file is offline;

Flexibility – Store your data in documents, organized into collections architectured in a flexible hierarchical data structures;

Expressive Queries – Use queries to retrieve documents and choose the documents in a collection corresponding to the query parameters;

Real-time updates – Data is synchronizated to update data on any connected party;

buildscript {
// …
ext.kotlin_version = ‘'

dependencies {  
    classpath "org.jetbrains.kotlin" +   
        "kotlin-gradle-plugin:$kotlin_version"    
}    }   

apply plugin: ‘kotlin’

dependencies {
compile “org.jetbrains.kotlin:kotlin-stdlib-jre8”
}

Utility Functions
Favor Kotlin top-level extension functions over the typical Java utility classes. And for easier consumption within Java code, use @file:JvmName to specify the name of the Java class which would get generated by the Kotlin compiler.

// Use this annotation so you can call it from Java code
@file:JvmName(“StringUtil”)
fun String.lengthIsEven(): Boolean = length % 2 == 0
val lengthIsEven = “someString”.lengthIsEven()

Data classes
They are classes that have the specific purpose of holding data:

data class Dog(val name: String, val age: Int)

The data class will have the following function out of the box:

toString of the form “Dog(name=Mark, age=12)” equals() and hashCode() copy()

It will also become a subject for destructuring declarations:

val markTurtle = Dog(“Joe”, 50)
val (name, age) = markTurtle
println(name)

Inline functions
A lambda expression in Kotlin is translated to Java anonymous classes in Java 6 or 7, that is an overhead. Lambda calls are affecting the call stack which has a performance impact.

inline functions can be used to flat out calls instead of invoking another method call and adding that to the call stack. So it makes sense to use inline functions when we pass in the lambdas.

inline fun callBlock(block: () -> Unit) {
println(“Before calling block”)
block()
println(“After calling block”)
}

When we call callBlock it gets translated to something like the following:

callBlock { println(“The block operation”) }
String var1 = “Before calling block”;
System.out.println(var1)
String var2 = “The block operation”;
System.out.println(var2);
var1 = “After calling block”;
System.out.println(var1);

vs. the following if the function was not marked as inline

callBlock { println(“The block operation”) } callBlock((Functinos0)null.INSTANCE);

You have to be careful with inline functions though because it literary copies the method content where it is called and if the body of the functions is too large you really do not want to do this.

Knowing that, the following obviously will not make any sense because it has zero effect.

inline fun foo(noinline block: () -> Unit) {// Single lambda marked as noinline inline fun foo() { // No lambdas

Checking for null in conditions
First, you can explicitly check if b is null, and handle the two options separately:

val l = if (b != null) b.length else -1

The compiler tracks the information about the check you performed, and allows the call to length inside the if. More complex conditions are supported as well:

if (b != null && b.length > 0) print(“String of length ${b.length}”) else print(“Empty string”)

Note that this only works where b is immutable (i.e. a local variable which is not modified between the check and the usage or a member val which has a backing field and is not overridable), because otherwise it might happen that b changes to null after the check.

Safe Calls
Your second option is the safe call operator, written ?.:

b?.length

This returns b.length if b is not null, and null otherwise. The type of this expression is Int?.

Safe calls are useful in chains. For example, if Bob, an Employee, may be assigned to a Department (or not), that in turn may have another Employee as a department head, then to obtain the name of Bob’s department head, if any), we write the following:

bob?.department?.head?.name

Such a chain returns null if any of the properties in it is null.

Elvis Operator
When we have a nullable reference r, we can say “if r is not null, use it, otherwise use some non-null value x”:

val l: Int = if (b != null) b.length else -1

Along with the complete if-expression, this can be expressed with the Elvis operator, written ?::

val l = b?.length ?: -1

If the expression to the left of ?: is not null, the elvis operator returns it, otherwise it returns the expression to the right. Note that the right-hand side expression is evaluated only if the left-hand side is null.

Note that, since throw and return are expressions in Kotlin, they can also be used on the right hand side of the elvis operator. This can be very handy, for example, for checking function arguments:

fun foo(node: Node): String? {
val parent = node.getParent() ?: return null
val name = node.getName() ?: throw IllegalArgumentException(“name expected”)
}

The !! Operator
We can write b!!, and this will return a non-null value of b (e.g., a String in our example) or throw an NPE if b is null:

val l = b!!.length()

Thus, if you want an NPE, you can have it, but you have to ask for it explicitly, and it does not appear out of the blue.

Safe Casts
Regular casts may result into a ClassCastException if the object is not of the target type. Another option is to use safe casts that return null if the attempt was not successful:

val aInt: Int? = a as? Int

Installation and Usage

The process is really straightforward. First of all, you need to add the library’s dependency in your project:

dependencies: flutter_offline: "^0.2.1"

Next step is import the package that you included in you project and start using the library as the following example shows:

View the full usage example on GitHub Gist.

Transaction

A piece of data, signed by an External Actor. It represents either a Message or a new Autonomous Object. Transactions are recorded into each block of the blockchain.

Message Call

The act of passing a message from one Account to another. If the destination account is associated with non-empty EVM Code, then the VM will be started with the state of said Object and the Message acted upon. If the message sender is an Autonomous Object, then the Call passes any data returned from the VM operation.

In other words, a transaction is an asynchronous operation which is broadcasted to the network and processed by miners. A transaction consumes Ether and modify the blockchain. A message call is a read-only and not Ether consumer operation of a contract function. The results of a ‘call’ will not be published or broadcasted on the blockchain.

Modifiers and Visibility

Solidity Modifiers

Since Solidity 0.4.17, it provides the following functions modifiers on its framework: view and pure.

View – should be used in functions that did not change any state values of a contract;

Pure – should be used if it does not even read any state information. Pure functions can be used for tasks like permission-control, calculations and typecasting.

Visibility

public – are part of the contract interface and can be either called internally or via messages. For public state variables, an automatic getter function (see below) is generated;

private – and state variables are only visible for the contract they are defined in and not in derived contracts;

internal – and state variables can only be accessed internally (i.e. from within the current contract or contracts deriving from it), without using this;

external – are part of the contract interface, which means they can be called from other contracts and via transactions. An external function f cannot be called internally (i.e. f() does not work, but this.f() works). External functions are sometimes more efficient when they receive large arrays of data;

gas price – a value set by the creator of the transaction; it’s a single gas unit’s price;

fee – the result of gas * gas price

Transactions costs x Ethereum system

• Have in mind if the gas price is too low, no one will process your transaction;

• The fees are paid in ether, though, which is different from gas;

• The transaction fails (still goes into the blockchain) in case of gas price is fine but the gas cost runs “over budget”. You don’t get the money back for the work that the miners did.

• Transaction fee = Amount of work that goes into something + storage space your code will take;

Optimize gas usage of your smart contract

Gas is necessary for the execution of smart contracts, but you shouldn’t specify too low or high price. Consider optimizing your smart contract to minimize the amount of gas required.

What should I take into account for optimized contracts?

Global Variables usage – storage: Global variables are stored in a contract’s state on the blockchain, so you are going to be charged if you use global variables. Just use when it is necessary, this is a practice in several languages, but it is especially crucial in ethereum development;

Contract Size: The size of your contract will influence the transaction cost for all interactions with it. So how big is your contract, more expansive your contract will be to processed in the Ethereum’s network. If you are able to break the Solidity contract up into smaller separate contracts, this will decrease user’s gas costs;

Further Details

Take a look in this documentation from ConsenSys for Ethereum Smart Contract Security Best Practices and this Medium post about Optimizing gas usage.

• block.blockhash (uint blockNumber) returns (bytes32): Hash of the given block, works for only the 256 most recent blocks
• block.coinbase (address): Current block miner’s address
• block.difficult (uint): Current block difficulty
• block.gaslimit (uint): Current block gas limit
• block.number (uint): Current block number
• block.timestamp (uint): Current block timestamp
• msg.data (bytes): Complete call data
• msg.gas (uint): Remaining gas
• msg.sender (address): Sender of the message (current call)
• msg.sig (bytes4): First 4 bytes of the call data (function identifier)
• msg.value (uint): Number of wei sent with the message
• now (uint): Current block timestamp (alias for block.timestamp)
• tx.gasprice (uint): Gas price of the transaction
• tx.origin (address): Sender of the transaction (full call chain)

In Solidity, it is possible to use the keccak256 function to get a hash. Ethereum’s KECCAK-256 algorithm produces a 256-bit hexadecimal number.

keccak256(…) returns (bytes32): compute the Ethereum-SHA-3 (Keccak-256) hash of the (tightly packed) arguments

Usage Examples

keccak256(6382179)
keccak256(97, 98, 99)

Typecasting

Solidity is a statically typed language, which means that the type of each variable (state and local) needs to be specified at compile-time. Solidity is able to perform operations between two variables that have the same type. Therefore you can convert one of the variables to the type of the others.

uint256 z = y * uint256(x);
uint8 x = 8;
uint256 y = 10 ** 18;

Alright, let’s talk about Solidity’ syntax and its features. Basically I’m mention the following subjects: Contracts, Types of variables, Math operations, Functions, Arrays, Structs and Events.

Let’s start

A contract is the fundamental building block of Ethereum applications — everything goes inside the contracts. This is very similar to Java, commonly all the code is encapsuled in ‘Class’.

First important thing you need to learn is how Solidity handles variables. Solidity is a statically typed language, which means that the type of each variable. Once you start coding variables and functions inside you Contract file, you need to understand Solidity has two types of variables: state and local. State variables are permanently stored in contract storage - into the Ethereum blockchain, it may cost some ‘gas’ in case you try to modify them. Local variable you can modify them freely but remember you will loose their value right after the context/scope change - they are not stored.

Booleans bool: The possible values are constants true and false.

Integers int / uint: Signed and unsigned integers of various sizes. Keywords uint8 to uint256 in steps of 8 (unsigned of 8 up to 256 bits) and int8 to int256. uint and int are aliases for uint256 and int256, respectively.

Address address: Holds a 20 byte value (size of an Ethereum address). Address types also have members and serve as a base for all contracts.

Members of Addresses balance and transfer: It is possible to query the balance of an address using the property balance and to send Ether (in units of wei) to an address using the transfer function.

Fixed-size byte arrays bytes1, bytes2, bytes3, …, bytes32. byte is an alias for bytes1.

Dynamically-sized byte array bytes: Dynamically-sized byte array. string: Dynamically-sized UTF-8-encoded string.

String Literals They are written with either double or single-quotes (“foo” or ‘bar’). They do not imply trailing zeroes as in C; “foo” represents three bytes not four. As with integer literals, their type can vary, but they are implicitly convertible to bytes1, …, bytes32, if they fit, to bytes and to string.

Math Operations

Solidity offers the following math operations (it is almost the same as in most programming languages):

Addition: x + y Subtraction: x - y, Multiplication: x * y Division: x / y Modulus / remainder: x % y Support an exponential operator (i.e. “x to the power of y”, x^y):

Structs

Sometimes you need a more complex data type. For this, Solidity provides structs:

`struct Person { uint age; string name; } Structs allow you to create more complicated data types that have multiple properties.

Events

Events are a way for your contract to communicate that something happened on the blockchain to your app front-end, which can be ‘listening’ for certain events and take action when they happen.

Events are inheritable members of contracts. When they are called, they cause the arguments to be stored in the transaction’s log - a special data structure in the blockchain. These logs are associated with the address of the contract and will be incorporated into the blockchain and stay there as long as a block is accessible (forever as of Frontier and Homestead, but this might change with Serenity). Log and event data is not accessible from within contracts (not even from the contract that created them).

Further details

I’d recommend this article Ethereum Smart Contract Best Practices for beginners.

Room

This is my favorite library of Architecture Components, surely. Room is an object mapping library that let the code clean and collaborate with SQL queries. Furthermore, the library provides SQL queries validation compilation time, annotations and observables for database changes. I knew this today would come, a day that Google will release a library for persistence such Apple offer for iOS (Core Data). Hereafter I have no doubt Room will be a reference for the persistence layer although there are tons of similar libraries such as ORMLite, Active Android or GreenDAO.

ViewModel

• Provide data for fragment/activity;
• Independent of View: configuration changes don’t affect ViewModel;
• Similar to an usual presenter however the retention/loading is built-in;
• Retention happens through FragmentManager and HolderFragment;

Live Data

it is responsible for listen and propagate data changes: an observable data holder It allows broadcasting of data changes all over the architecture layers taking into account all system issues eg. memory leaks.

Lifecycle Owner - Lifecycle

It allows the creation of lifecycle-aware components which are able to adjust itself automatically according to the current lifecycle. This feature is possible because Lifecycle owner associates a class to the lifecycle via an abstract class called getLifecycle().

Further Details

I recommend this project which Google team implemented samples of Architecture Componentes and this video from Google I/O.

I’m gonna be straightfoward because this topic it is a well known case that you only learn by doing. Basically, this is how it works: A Subscriber subscribes to Observable, then Observable calls Subscriber.onNext() for any number of items, if something goes wrong here is Subsciber.onError() and if all finishes fine, here is Subscriber.onCompleted().

The foundations

Subscribers -> It listens to the events/items;

Observables -> It emits events/items - This class provides methods for subscribing to the Observable as well as delegate methods to the various Observers. It is necessary to trigger/listen/activate/start the observables otherwise they don’t do anything;

Operators -> Functions responsible for manipulate observables. It can applyed along other operators and it has seveval goals: creation, combination, transformation, filtering, etc;

Schedulers -> It manages the work with thread pools via Executors (java.util.concurrent);

Transforming Streams with operators

As it was said before, operators can manipulate observables. There are plenty of them and it is really important to know how/when use them. Here is the most popular RxJava operators:

Further details

I totally recommend this talk by Jake Wharton, an outstanding developer and a reference in opensource projects. Another option is watch this video but don’t forget to practice, try to implement what it is suggested in the video.

git config

Sets configuration values for your user name, email, gpg key, preferred diff algorithm, file formats and more.

git branch -a

Lists existing branches, including remote branches.

git branch -d [branch-name]

Deletes the specified branch

git push origin –delete [branch-name]

Deletes the specified branch from remote

git stash

Temporarily stores all modified tracked files

git stash list

Lists all stashed changesets

git stash pop

Restores the most recently stashed files

git stash drop

Discards the most recently stashed changeset

git reset [commit]

Undoes all commits afer [commit], preserving changes locally

git reset –hard [commit]

Discards all history and changes back to the specified commit

git show

Shows information about a git object.

git grep

Lets you search through your trees of content for words and phrases. Example: git grep “www.google.com” – *.js

Check this simplified MVP example for Android

Model: This is the well known model, present in many of the most common patterns and use cases. It represents the world we are working with, every real world element that our app should know how to represent. Both the View and the Presenter are aware of this model and they know how to use its properties and methods (the view doesn’t really need to know the model and originally shouldn’t but it’s a tradeoff that avoids the need to have setter methods for every field that we want to update).

View: As stated before, views are our Fragment and Activity classes that we are using, they are able to alter the UI as we need and they need to receive structured data from a source in order to populate themselves. This layer shouldn’t know anything else about the obtention of the data, we made it as simple as we could.

Presenter: This layer, introduced here, is implemented with native java code meaning it doesn’t need to know whether it’s used in an Android application or a web service. How does this work with our structure previously described? Easy, what we are going to add to each view is a simple interface which defines the actions that any view using a specific presenter would need to do in order to populate itself with the data it provides. The presenter is responsible to act as the middle man between view and model. It retrieves data from the model and returns it formatted to the view. But unlike the typical MVC, it also decides what happens when you interact with the view.

References

• https://medium.com/mobiwise-blog/android-basic-project-architecture-for-mvp-72f4b33252d0#.gebnmc1rq
• http://antonioleiva.com/mvp-android
• http://hannesdorfmann.com/mosby/mvp/